feat: Splash 2.0 Milestone 2 - Hermes-Grade Memory & CLI Redesign

Author: Splash Agent

examples/cli.ts

@@ -143,42 +143,22 @@ async function main() {
 // Help
 // ──────────────────────────────────────────────────────────────────────────
 
-function printHelp() {
-  console.log(renderBanner({ subtitle: "Autonomous Agent" }));
+function printHelp(): void {
+  console.log(renderBanner({ compact: true }));
   console.log(
     [
-      pc.bold("USAGE"),
-      `  ${pc.cyan("splash")}                            Open an interactive chat`,
-      `  ${pc.cyan("splash")} "build me a script"        Run a one-shot task`,
-      `  ${pc.cyan("splash")} "..." --background          Detach and return a run id`,
       "",
-      pc.bold("CORE COMMANDS"),
-      `  ${pc.cyan("splash init")}                       30-second setup wizard`,
-      `  ${pc.cyan("splash tui")}                        Open the live run dashboard`,
-      `  ${pc.cyan("splash help")}                       Show this help`,
+      `  ${pc.cyan("Run   ")} ${pc.dim("│")} run, exec, ask, "prompt"`,
+      `  ${pc.cyan("Memory")} ${pc.dim("│")} memory list/search/export, profile show/set`,
+      `  ${pc.cyan("Config")} ${pc.dim("│")} config list/get/set, providers list/test`,
+      `  ${pc.cyan("Skills")} ${pc.dim("│")} skills list, skills enable/disable, skills suggest`,
+      `  ${pc.cyan("Runs  ")} ${pc.dim("│")} runs list/logs/stop/retry`,
+      `  ${pc.cyan("System")} ${pc.dim("│")} doctor, update, auth, init`,
       "",
-      pc.bold("RUNS"),
-      `  ${pc.cyan("splash runs list")}                  Show active/recent runs`,
-      `  ${pc.cyan("splash runs logs")} ID [--follow]    Tail events for a run`,
-      `  ${pc.cyan("splash runs attach")} ID             Open a run in the TUI`,
-      `  ${pc.cyan("splash runs stop")} ID               Cancel a running run`,
-      `  ${pc.cyan("splash runs retry")} ID [-b]         Re-run a task`,
+      pc.dim(`  Config: ${globalConfigPath()}`),
+      pc.dim(`  Env:    SPLASH_* vars work. .env in cwd is read.`),
       "",
-      pc.bold("CONFIG"),
-      `  ${pc.cyan("splash config list")}                Show effective config`,
-      `  ${pc.cyan("splash config doctor")}              Verify keys / perms / reachability`,
-      `  ${pc.cyan("splash config preset")} fast|balanced|safe`,
-      `  ${pc.cyan("splash config set")} KEY VAL         Set a field`,
-      `  ${pc.cyan("splash config set-key")} P VAL       Save API key for provider`,
-      "",
-      pc.bold("PLATFORMS"),
-      `  ${pc.cyan("splash telegram")}|${pc.cyan("slack")}|${pc.cyan("whatsapp")}|${pc.cyan("messenger")}|${pc.cyan("discord")}`,
-      "",
-      pc.dim(`Config: ${globalConfigPath()}`),
-      pc.dim(`Env:    SPLASH_* and legacy ALPCLAW_* vars both work. .env in cwd is read.`),
-      pc.dim(`Alias:  \`alpclaw\` still works — it delegates to \`splash\`.`),
-      "",
-    ].join("\n"),
+    ].join("\n")
   );
 }
 
@@ -196,13 +176,19 @@ async function runInit() {
   next.apiKeys = { ...(existing.apiKeys || {}) };
 
   const provider = await p.select({
-    message: "Default provider:",
+    message: "1. Default provider:",
     options: [
-      { value: "openrouter", label: "OpenRouter — recommended, unlocks Kimi K2, DeepSeek, Qwen, Claude, GPT-4" },
+      { value: "openrouter", label: "OpenRouter — recommended, unlocks massive model catalog" },
       { value: "claude",     label: "Anthropic Claude" },
       { value: "openai",     label: "OpenAI (GPT-4o)" },
       { value: "gemini",     label: "Google Gemini" },
       { value: "deepseek",   label: "DeepSeek" },
+      { value: "nous",       label: "Nous Portal" },
+      { value: "groq",       label: "Groq (ultra-fast)" },
+      { value: "mistral",    label: "Mistral" },
+      { value: "cerebras",   label: "Cerebras" },
+      { value: "cohere",     label: "Cohere" },
+      { value: "nvidia",     label: "NVIDIA NIM" },
       { value: "ollama",     label: "Ollama (local, no key needed)" },
     ],
   });
@@ -211,14 +197,14 @@ async function runInit() {
   next.defaultProvider = provider as string;
 
   if (provider !== "ollama") {
-    const key = await p.password({ message: `Paste your ${provider} API key (input hidden):` });
+    const key = await p.password({ message: `2. Paste your ${provider} API key (input hidden):` });
     if (p.isCancel(key)) return abort();
     if (key) next.apiKeys[provider as string] = key as string;
   }
 
   if (provider === "openrouter") {
     const model = await p.select({
-      message: "Default model:",
+      message: "3. Default model:",
       options: [
         { value: "moonshotai/kimi-k2",           label: "Kimi K2 (Moonshot) — long context, strong coding" },
         { value: "moonshotai/kimi-k2-0905",      label: "Kimi K2 0905 (newer snapshot)" },
@@ -232,7 +218,7 @@ async function runInit() {
   }
 
   const safety = await p.select({
-    message: "Safety level:",
+    message: "4. Safety level:",
     options: [
       { value: "standard",   label: "Standard — confirms risky actions (recommended)" },
       { value: "strict",     label: "Strict — confirms every action" },
@@ -241,6 +227,20 @@ async function runInit() {
   });
   if (!p.isCancel(safety)) next.safetyMode = safety as GlobalConfigShape["safetyMode"];
 
+  const theme = await p.select({
+    message: "5. CLI Theme:",
+    options: [
+      { value: "splash",     label: "Splash (Default) — Water animations & rich output" },
+      { value: "hermes",     label: "Hermes — Clean bracket-based logs" },
+      { value: "openclaw",   label: "OpenClaw — Compact status-light header" },
+      { value: "minimal",    label: "Minimal — Pure prompt, silent execution" },
+    ],
+  });
+  if (!p.isCancel(theme)) {
+    next.cli = next.cli || {};
+    next.cli.style = theme as "splash" | "hermes" | "openclaw" | "minimal";
+  }
+
   writeGlobalConfig(next);
   p.outro(pc.green(`✓ Saved to ${globalConfigPath()}`));
   console.log(pc.dim(`\nTry it: ${pc.cyan("splash \"summarize this folder\"")}`));
@@ -340,8 +340,9 @@ async function runConfig(args: string[]) {
 
 async function runDoctor(args: string[]): Promise<void> {
   const json = args.includes("--json");
+  const autofix = args.includes("--fix") || args.includes("--autofix");
   const cfg = readGlobalConfig();
-  const checks: { name: string; ok: boolean; detail: string; fix?: string }[] = [];
+  const checks: { name: string; ok: boolean; detail: string; fix?: string; autoFixer?: () => Promise<void> | void }[] = [];
 
   // 1. provider key present
   const hasAnyKey =
@@ -357,6 +358,10 @@ async function runDoctor(args: string[]): Promise<void> {
     ok: hasAnyKey,
     detail: hasAnyKey ? "found" : "none",
     fix: "splash init  — or  splash config set-key openrouter sk-or-...",
+    autoFixer: async () => {
+      console.log(pc.yellow("\nMissing provider key. Launching setup wizard..."));
+      await runInit();
+    }
   });
 
   // 2. write perms
@@ -374,6 +379,12 @@ async function runDoctor(args: string[]): Promise<void> {
     ok: writable,
     detail: dir,
     fix: `chmod u+w ${dir}`,
+    autoFixer: () => {
+      try {
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.chmodSync(dir, 0o700);
+      } catch (e) {}
+    }
   });
 
   // 3. runs dir
@@ -386,7 +397,18 @@ async function runDoctor(args: string[]): Promise<void> {
   } catch {
     runsOK = false;
   }
-  checks.push({ name: "runs dir writable", ok: runsOK, detail: rdir });
+  checks.push({ 
+    name: "runs dir writable", 
+    ok: runsOK, 
+    detail: rdir,
+    fix: `chmod u+w ${rdir}`,
+    autoFixer: () => {
+      try {
+        if (!fs.existsSync(rdir)) fs.mkdirSync(rdir, { recursive: true, mode: 0o700 });
+        fs.chmodSync(rdir, 0o700);
+      } catch (e) {}
+    }
+  });
 
   // 4. provider reachability (best effort — skip if no fetch)
   const defaultProvider = cfg.defaultProvider || "openrouter";
@@ -433,6 +455,20 @@ async function runDoctor(args: string[]): Promise<void> {
   const bad = checks.filter((c) => !c.ok).length;
   console.log();
   console.log(bad === 0 ? pc.green("All checks passed.") : pc.yellow(`${bad} check(s) failed.`));
+
+  if (bad !== 0 && autofix) {
+    console.log(pc.cyan("\nRunning autofix for failed checks..."));
+    for (const c of checks) {
+      if (!c.ok && c.autoFixer) {
+        await c.autoFixer();
+      }
+    }
+    console.log(pc.green("\nAutofix complete. Run `splash doctor` again to verify."));
+    process.exit(0);
+  } else if (bad !== 0 && !autofix) {
+    console.log(pc.dim(`\nRun \`${pc.cyan("splash doctor --fix")}\` to automatically resolve issues.`));
+  }
+
   if (bad !== 0) process.exit(1);
 }
 

packages/memory/package.json

@@ -9,6 +9,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
+    "@alpclaw/config": "workspace:*",
     "@alpclaw/utils": "workspace:*",
     "zod": "^3.23.0"
   }

packages/memory/src/episodic.ts

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { globalConfigDir } from "@alpclaw/config";
+
+export interface MessageEntry {
+  role: string;
+  content: string;
+  timestamp: string;
+  [key: string]: any;
+}
+
+export class EpisodicMemory {
+  private baseDir: string;
+
+  constructor() {
+    this.baseDir = path.join(globalConfigDir(), "memory", "sessions");
+    if (!fs.existsSync(this.baseDir)) {
+      fs.mkdirSync(this.baseDir, { recursive: true });
+    }
+  }
+
+  private getSessionFile(sessionId: string): string {
+    return path.join(this.baseDir, `${sessionId}.jsonl`);
+  }
+
+  public append(sessionId: string, message: MessageEntry): void {
+    const filePath = this.getSessionFile(sessionId);
+    const line = JSON.stringify(message) + "\n";
+    fs.appendFileSync(filePath, line, "utf8");
+  }
+
+  public async getLastNMessages(sessionId: string, n: number): Promise<MessageEntry[]> {
+    const filePath = this.getSessionFile(sessionId);
+    if (!fs.existsSync(filePath)) {
+      return [];
+    }
+
+    const lines: string[] = [];
+    const fileStream = fs.createReadStream(filePath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity,
+    });
+
+    for await (const line of rl) {
+      if (line.trim()) {
+        lines.push(line);
+      }
+    }
+
+    return lines.slice(-n).map((line) => JSON.parse(line));
+  }
+
+  public async search(query: string, maxResults: number = 10): Promise<{ sessionId: string, message: MessageEntry }[]> {
+    const results: { sessionId: string, message: MessageEntry }[] = [];
+    if (!fs.existsSync(this.baseDir)) return results;
+    
+    const files = fs.readdirSync(this.baseDir).filter((file) => file.endsWith(".jsonl"));
+    const regex = new RegExp(query, "i");
+
+    for (const file of files) {
+      const sessionId = path.basename(file, ".jsonl");
+      const filePath = path.join(this.baseDir, file);
+      const fileStream = fs.createReadStream(filePath);
+      const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity,
+      });
+
+      for await (const line of rl) {
+        if (line.trim() && regex.test(line)) {
+          try {
+            results.push({ sessionId, message: JSON.parse(line) });
+            if (results.length >= maxResults) {
+              return results;
+            }
+          } catch (e) {
+            // Ignore parse errors
+          }
+        }
+      }
+    }
+    
+    return results;
+  }
+}

packages/memory/src/expanded-memory.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { EpisodicMemory } from "./episodic.js";
+import { UserProfile } from "./profile.js";
+import { SkillMemory } from "./skill-memory.js";
+import { rm } from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as fs from "node:fs";
+
+// Use a temporary test directory instead of the real config dir
+const TEST_DIR = path.join(os.tmpdir(), "alpclaw-memory-test-" + Date.now());
+
+vi.mock("@alpclaw/config", () => ({
+  globalConfigDir: () => TEST_DIR
+}));
+
+describe("Hermes-Grade Memory Expansion", () => {
+  beforeEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("EpisodicMemory", () => {
+    it("should append and retrieve last N messages", async () => {
+      const memory = new EpisodicMemory();
+      memory.append("sess1", { role: "user", content: "hello", timestamp: "123" });
+      memory.append("sess1", { role: "bot", content: "hi", timestamp: "124" });
+      
+      const last1 = await memory.getLastNMessages("sess1", 1);
+      expect(last1).toHaveLength(1);
+      expect(last1[0]?.content).toBe("hi");
+
+      const last2 = await memory.getLastNMessages("sess1", 2);
+      expect(last2).toHaveLength(2);
+      expect(last2[0]?.content).toBe("hello");
+    });
+
+    it("should search messages across sessions", async () => {
+      const memory = new EpisodicMemory();
+      memory.append("sess1", { role: "user", content: "find this string", timestamp: "1" });
+      memory.append("sess2", { role: "user", content: "some other string", timestamp: "2" });
+      memory.append("sess2", { role: "bot", content: "find this too", timestamp: "3" });
+
+      const results = await memory.search("find this");
+      expect(results).toHaveLength(2);
+      expect(results.some(r => r.sessionId === "sess1" && r.message.content.includes("string"))).toBe(true);
+      expect(results.some(r => r.sessionId === "sess2" && r.message.content.includes("too"))).toBe(true);
+    });
+  });
+
+  describe("UserProfile", () => {
+    it("should read and update user profile", () => {
+      const profile = new UserProfile();
+      let data = profile.read();
+      expect(data).toEqual({});
+
+      profile.update({ name: "Alice", tone: "helpful" });
+      data = profile.read();
+      expect(data.name).toBe("Alice");
+      expect(data.tone).toBe("helpful");
+
+      profile.update({ timezone: "UTC" });
+      data = profile.read();
+      expect(data.name).toBe("Alice");
+      expect(data.timezone).toBe("UTC");
+    });
+  });
+
+  describe("SkillMemory", () => {
+    it("should record and retrieve skill stats", () => {
+      const skills = new SkillMemory();
+      skills.record("test-skill", true);
+      skills.record("test-skill", false);
+      skills.record("test-skill", true);
+
+      const stats = skills.getStats();
+      expect(stats["test-skill"]?.successCount).toBe(2);
+      expect(stats["test-skill"]?.failureCount).toBe(1);
+      expect(stats["test-skill"]?.lastUsed).toBeDefined();
+    });
+  });
+});

packages/memory/src/index.ts

@@ -1,3 +1,6 @@
 export type { MemoryStore } from "./store.js";
 export { FileMemoryStore } from "./file-store.js";
 export { MemoryManager } from "./manager.js";
+export { EpisodicMemory, type MessageEntry } from "./episodic.js";
+export { UserProfile, type UserProfileData } from "./profile.js";
+export { SkillMemory, type SkillStats } from "./skill-memory.js";