wispy-cli 2.3.0 → 2.4.0

package/bin/wispy.mjs

@@ -312,13 +312,63 @@ ${_bold("Usage:")}
 // ── completion sub-command ────────────────────────────────────────────────────
 if (args[0] === "completion") {
   const shell = args[1] ?? "bash";
-  const cmds = ["ws", "trust", "where", "handoff", "skill", "teach", "improve", "dry",
-    "deploy", "server", "node", "channel", "cron", "audit", "sync", "setup", "update",
-    "tui", "migrate", "version", "doctor", "help", "completion", "status",
-    "connect", "disconnect", "log"];
+
+  // Commands with descriptions for rich completions
+  const cmdSpecs = [
+    { cmd: "ws",         desc: "Workstream management (list/new/switch/archive/delete/status/search)" },
+    { cmd: "trust",      desc: "Trust level & security policies (careful/balanced/yolo)" },
+    { cmd: "where",      desc: "Show current mode & context" },
+    { cmd: "handoff",    desc: "Generate handoff summary & sync" },
+    { cmd: "skill",      desc: "Skill management (list/show)" },
+    { cmd: "teach",      desc: "Create skill from current conversation" },
+    { cmd: "improve",    desc: "Improve an existing skill" },
+    { cmd: "dry",        desc: "Run next command in dry-run (preview-only) mode" },
+    { cmd: "deploy",     desc: "Deployment helpers (Dockerfile/compose/systemd/vps/…)" },
+    { cmd: "server",     desc: "Start the Wispy API server" },
+    { cmd: "node",       desc: "Multi-machine node management (pair/connect/list/status)" },
+    { cmd: "channel",    desc: "Messaging channel setup (telegram/discord/slack/email/…)" },
+    { cmd: "cron",       desc: "Scheduled tasks (list/add/remove/run/history/start)" },
+    { cmd: "audit",      desc: "View audit log & replay sessions" },
+    { cmd: "log",        desc: "Alias for audit" },
+    { cmd: "sync",       desc: "Sync with remote server (push/pull/status/auto)" },
+    { cmd: "setup",      desc: "Interactive setup wizard" },
+    { cmd: "init",       desc: "Alias for setup" },
+    { cmd: "update",     desc: "Update wispy-cli to latest version" },
+    { cmd: "tui",        desc: "Launch the workspace TUI" },
+    { cmd: "migrate",    desc: "Import from OpenClaw or other sources" },
+    { cmd: "version",    desc: "Show version" },
+    { cmd: "doctor",     desc: "Check system health & API keys" },
+    { cmd: "help",       desc: "Show help (optionally for a specific command)" },
+    { cmd: "completion", desc: "Print shell completion script (bash/zsh/fish)" },
+    { cmd: "status",     desc: "Show wispy status & remote connection info" },
+    { cmd: "connect",    desc: "Connect to a remote Wispy server" },
+    { cmd: "disconnect", desc: "Disconnect from remote server (go back to local)" },
+  ];
+
+  // Sub-command completions for nested commands
+  const subCmds = {
+    ws:         ["new", "switch", "archive", "delete", "status", "search"],
+    trust:      ["careful", "balanced", "yolo", "log"],
+    skill:      ["list", "show"],
+    deploy:     ["init", "dockerfile", "compose", "systemd", "railway", "fly", "render", "modal", "daytona", "vps", "status"],
+    cron:       ["list", "add", "remove", "run", "history", "start"],
+    audit:      ["replay", "export", "--today", "--session", "--tool", "--limit"],
+    channel:    ["setup", "list", "test"],
+    node:       ["pair", "connect", "list", "status", "remove"],
+    sync:       ["push", "pull", "status", "auto"],
+    server:     ["start", "stop", "status"],
+    completion: ["bash", "zsh", "fish"],
+    help:       cmdSpecs.map(c => c.cmd),
+  };
+
+  const cmds = cmdSpecs.map(c => c.cmd);
   const flags = ["--help", "--version", "--debug", "--serve", "--telegram", "--discord", "--slack"];
 
   if (shell === "bash") {
+    const subCmdsStr = Object.entries(subCmds)
+      .map(([k, v]) => `        ${k}) COMPREPLY=( $(compgen -W "${v.join(' ')}" -- "\${cur}") ) ;;`)
+      .join('\n');
+
     console.log(`# wispy bash completion
 # Add to ~/.bashrc: eval "$(wispy completion bash)"
 _wispy_completion() {
@@ -331,30 +381,69 @@ _wispy_completion() {
 
   if [[ \${COMP_CWORD} -eq 1 ]]; then
     COMPREPLY=( $(compgen -W "\${commands} \${flags}" -- "\${cur}") )
+  elif [[ \${COMP_CWORD} -eq 2 ]]; then
+    case "\${prev}" in
+${subCmdsStr}
+    esac
   fi
 }
 complete -F _wispy_completion wispy`);
+
   } else if (shell === "zsh") {
+    const cmdDescLines = cmdSpecs.map(c => `    '${c.cmd}:${c.desc.replace(/'/g, "''")}'`).join('\n');
+    const subCmdLines = Object.entries(subCmds)
+      .map(([k, v]) => `      (${k}) _values '${k} commands' ${v.map(s => `'${s}'`).join(' ')} ;;`)
+      .join('\n');
+
     console.log(`# wispy zsh completion
 # Add to ~/.zshrc: eval "$(wispy completion zsh)"
+# Or for permanent use: wispy completion zsh > /usr/local/share/zsh/site-functions/_wispy
 _wispy() {
+  local context state state_descr line
+  typeset -A opt_args
+
   local -a commands
   commands=(
-    ${cmds.map(c => `'${c}'`).join("\n    ")}
+${cmdDescLines}
   )
-  local -a flags
-  flags=(${flags.map(f => `'${f}'`).join(" ")})
+
   _arguments -C \\
-    '1:command:->cmds' \\
+    '(- *)'{-h,--help}'[Show help]' \\
+    '(- *)'{-v,--version}'[Show version]' \\
+    '--debug[Enable verbose logs]' \\
+    '--serve[Start all channel bots]' \\
+    '--telegram[Start Telegram bot]' \\
+    '--discord[Start Discord bot]' \\
+    '--slack[Start Slack bot]' \\
+    '1:command:->cmd' \\
     '*::arg:->args'
+
   case $state in
-    cmds) _describe 'wispy commands' commands ;;
+    cmd)
+      _describe 'wispy commands' commands
+      ;;
+    args)
+      case $line[1] in
+${subCmdLines}
+      esac
+      ;;
   esac
 }
 compdef _wispy wispy`);
+
   } else if (shell === "fish") {
-    const completions = cmds.map(c => `complete -c wispy -f -n '__fish_use_subcommand' -a '${c}'`).join("\n");
-    console.log(`# wispy fish completion\n# Save to ~/.config/fish/completions/wispy.fish\n${completions}`);
+    const mainComps = cmdSpecs
+      .map(c => `complete -c wispy -f -n '__fish_use_subcommand' -a '${c.cmd}' -d '${c.desc.replace(/'/g, "\\'")}'`)
+      .join("\n");
+    const subComps = Object.entries(subCmds)
+      .flatMap(([k, v]) => v.map(s => `complete -c wispy -f -n '__fish_seen_subcommand_from ${k}' -a '${s}'`))
+      .join("\n");
+
+    console.log(`# wispy fish completion
+# Save to ~/.config/fish/completions/wispy.fish
+${mainComps}
+${subComps}`);
+
   } else {
     console.error(_red(`❌ Unknown shell: ${shell}. Use: bash, zsh, or fish`));
     process.exit(2);
@@ -635,6 +724,13 @@ if (args[0] === "setup" || args[0] === "init") {
       await wizard.run();
     }
   } catch (e) { friendlyError(e); }
+
+  // Shell completion tip
+  console.log(_dim(`
+💡 Tip: Enable tab completion in your shell:
+   eval "$(wispy completion zsh)"    # zsh — add to ~/.zshrc for permanent
+   eval "$(wispy completion bash)"   # bash — add to ~/.bashrc for permanent
+`));
   process.exit(0);
 }
 

package/core/migrate.mjs

@@ -71,6 +71,7 @@ export class OpenClawMigrator {
       await this._migrateWorkspaceFiles(dryRun);
       await this._migrateCronJobs(dryRun);
       await this._migrateChannels(dryRun);
+      await this._migrateApiKeys(dryRun);
     }
 
     return {
@@ -274,9 +275,11 @@ export class OpenClawMigrator {
         } catch { /* empty */ }
 
         // Extract Telegram config
-        const telegramToken = config.telegram?.token
+        const telegramToken = config.channels?.telegram?.botToken
+          ?? config.telegram?.token
           ?? config.channels?.telegram?.token
-          ?? config.plugins?.telegram?.token;
+          ?? config.plugins?.telegram?.token
+          ?? config.plugins?.entries?.telegram?.config?.botToken;
 
         if (telegramToken && !wispyChannels.telegram) {
           wispyChannels.telegram = { token: telegramToken };
@@ -302,6 +305,83 @@ export class OpenClawMigrator {
     }
   }
 
+  // ── API keys migration ───────────────────────────────────────────────────────
+
+  async _migrateApiKeys(dryRun) {
+    // Read API keys from environment (same as OpenClaw uses)
+    const keyMap = {
+      google:    { env: ["GOOGLE_AI_KEY", "GOOGLE_GENERATIVE_AI_KEY", "GEMINI_API_KEY"], model: "gemini-2.5-flash" },
+      anthropic: { env: ["ANTHROPIC_API_KEY"], model: "claude-sonnet-4-20250514" },
+      openai:    { env: ["OPENAI_API_KEY"], model: "gpt-4o" },
+      groq:      { env: ["GROQ_API_KEY"], model: "llama-3.3-70b-versatile" },
+      deepseek:  { env: ["DEEPSEEK_API_KEY"], model: "deepseek-chat" },
+      openrouter:{ env: ["OPENROUTER_API_KEY"], model: "anthropic/claude-sonnet-4-20250514" },
+    };
+
+    // Also check macOS keychain
+    const { execSync } = await import("node:child_process");
+    function keychainGet(service, account) {
+      try {
+        return execSync(`security find-generic-password -s "${service}" -a "${account}" -w 2>/dev/null`, { encoding: "utf8" }).trim();
+      } catch { return null; }
+    }
+
+    const keychainMap = {
+      google:    { service: "google-ai-key", account: "poropo" },
+      anthropic: { service: "anthropic-api-key", account: "poropo" },
+      openai:    { service: "openai-api-key", account: "poropo" },
+    };
+
+    const configPath = join(this.wispyDir, "config.json");
+    let config = {};
+    try { config = JSON.parse(await readFile(configPath, "utf8")); } catch { /* empty */ }
+    if (!config.providers) config.providers = {};
+
+    let found = 0;
+    for (const [provider, info] of Object.entries(keyMap)) {
+      if (config.providers[provider]?.apiKey) continue; // already configured
+
+      // Check env vars
+      let key = null;
+      for (const envName of info.env) {
+        if (process.env[envName]) { key = process.env[envName]; break; }
+      }
+
+      // Check keychain (macOS)
+      if (!key && keychainMap[provider]) {
+        key = keychainGet(keychainMap[provider].service, keychainMap[provider].account);
+      }
+
+      // Check ~/.zshenv for exports
+      if (!key) {
+        try {
+          const zshenv = await readFile(join(homedir(), ".zshenv"), "utf8");
+          for (const envName of info.env) {
+            const match = zshenv.match(new RegExp(`export\\s+${envName}=["']?([^"'\\n]+)`));
+            if (match) { key = match[1]; break; }
+          }
+        } catch { /* no zshenv */ }
+      }
+
+      if (key) {
+        found++;
+        this.report.apiKeys = this.report.apiKeys || [];
+        this.report.apiKeys.push({ provider, masked: key.slice(0, 6) + "..." + key.slice(-4) });
+
+        if (!dryRun) {
+          config.providers[provider] = { apiKey: key, model: info.model };
+          if (!config.defaultProvider) config.defaultProvider = provider;
+        }
+      }
+    }
+
+    if (found > 0 && !dryRun) {
+      config.onboarded = true;
+      await mkdir(this.wispyDir, { recursive: true });
+      await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    }
+  }
+
   // ── Report formatting ─────────────────────────────────────────────────────────
 
   formatReport() {
@@ -345,6 +425,13 @@ export class OpenClawMigrator {
       }
     }
 
+    if (r.apiKeys?.length > 0) {
+      lines.push(`🔑 API Keys (${r.apiKeys.length}):`);
+      for (const k of r.apiKeys) {
+        lines.push(`  import: ${k.provider} (${k.masked})`);
+      }
+    }
+
     if (r.errors.length > 0) {
       lines.push(`⚠️ Errors (${r.errors.length}):`);
       for (const e of r.errors) {

package/lib/command-registry.mjs

@@ -0,0 +1,112 @@
+/**
+ * command-registry.mjs — Shared command registry for Wispy
+ *
+ * Used by REPL completer, TUI CommandPalette, and shell completion.
+ * Keep this file in sync whenever new slash commands are added.
+ */
+
+export const COMMANDS = [
+  // ── Workstream ──────────────────────────────────────────────────────────────
+  { cmd: '/ws', desc: 'List workstreams', category: 'Workstream' },
+  { cmd: '/ws new <name>', desc: 'Create workstream', category: 'Workstream' },
+  { cmd: '/ws <name>', desc: 'Switch workstream', category: 'Workstream' },
+  { cmd: '/ws status', desc: 'All workstreams overview', category: 'Workstream' },
+  { cmd: '/ws search <query>', desc: 'Search across workstreams', category: 'Workstream' },
+  { cmd: '/ws archive <name>', desc: 'Archive workstream', category: 'Workstream' },
+  { cmd: '/ws delete <name>', desc: 'Delete workstream', category: 'Workstream' },
+
+  // ── Trust ───────────────────────────────────────────────────────────────────
+  { cmd: '/trust', desc: 'Security level & policies', category: 'Trust' },
+  { cmd: '/trust <level>', desc: 'Set level (careful/balanced/yolo)', category: 'Trust' },
+  { cmd: '/trust log', desc: 'Audit log', category: 'Trust' },
+  { cmd: '/dry', desc: 'Toggle dry-run mode', category: 'Trust' },
+  { cmd: '/receipt', desc: 'Last execution receipt', category: 'Trust' },
+  { cmd: '/replay', desc: 'Replay current session', category: 'Trust' },
+
+  // ── Continuity ──────────────────────────────────────────────────────────────
+  { cmd: '/where', desc: 'Show current mode', category: 'Continuity' },
+  { cmd: '/handoff', desc: 'Sync + context summary', category: 'Continuity' },
+  { cmd: '/sync', desc: 'Sync with remote', category: 'Continuity' },
+
+  // ── Skills ──────────────────────────────────────────────────────────────────
+  { cmd: '/skills', desc: 'List learned skills', category: 'Skills' },
+  { cmd: '/teach <name>', desc: 'Create skill from conversation', category: 'Skills' },
+  { cmd: '/improve <name>', desc: 'Improve a skill', category: 'Skills' },
+
+  // ── Session ─────────────────────────────────────────────────────────────────
+  { cmd: '/clear', desc: 'Reset conversation', category: 'Session' },
+  { cmd: '/model', desc: 'Show/change model', category: 'Session' },
+  { cmd: '/cost', desc: 'Token usage & cost', category: 'Session' },
+  { cmd: '/compact', desc: 'Compress conversation', category: 'Session' },
+  { cmd: '/sessions', desc: 'List all sessions', category: 'Session' },
+  { cmd: '/history', desc: 'Show conversation length', category: 'Session' },
+
+  // ── Memory ──────────────────────────────────────────────────────────────────
+  { cmd: '/remember <text>', desc: 'Save to memory', category: 'Memory' },
+  { cmd: '/recall <query>', desc: 'Search memories', category: 'Memory' },
+  { cmd: '/memories', desc: 'List all memories', category: 'Memory' },
+  { cmd: '/forget <key>', desc: 'Delete memory', category: 'Memory' },
+
+  // ── Agents ──────────────────────────────────────────────────────────────────
+  { cmd: '/agents', desc: 'List sub-agents', category: 'Agents' },
+  { cmd: '/agent <id>', desc: 'Agent details', category: 'Agents' },
+  { cmd: '/kill <id>', desc: 'Kill sub-agent', category: 'Agents' },
+
+  // ── MCP ─────────────────────────────────────────────────────────────────────
+  { cmd: '/mcp', desc: 'MCP server management', category: 'MCP' },
+  { cmd: '/mcp list', desc: 'List MCP servers', category: 'MCP' },
+  { cmd: '/mcp connect', desc: 'Connect MCP server', category: 'MCP' },
+  { cmd: '/mcp disconnect', desc: 'Disconnect MCP server', category: 'MCP' },
+  { cmd: '/mcp reload', desc: 'Reload MCP servers', category: 'MCP' },
+  { cmd: '/mcp config', desc: 'Show MCP config', category: 'MCP' },
+
+  // ── Permissions & Audit ─────────────────────────────────────────────────────
+  { cmd: '/permissions', desc: 'Show permission policies', category: 'Trust' },
+  { cmd: '/permit <tool> <level>', desc: 'Change tool policy (auto|notify|approve)', category: 'Trust' },
+  { cmd: '/audit', desc: 'Show recent audit events', category: 'Trust' },
+
+  // ── Quick aliases ───────────────────────────────────────────────────────────
+  { cmd: '/o', desc: 'Overview (alias for /ws status)', category: 'Quick' },
+  { cmd: '/w', desc: 'Workstreams list (alias)', category: 'Quick' },
+  { cmd: '/a', desc: 'Agents list (alias)', category: 'Quick' },
+  { cmd: '/m', desc: 'Memories (alias)', category: 'Quick' },
+  { cmd: '/t', desc: 'Timeline / recent actions (alias)', category: 'Quick' },
+  { cmd: '/s', desc: 'Sync status (alias)', category: 'Quick' },
+  { cmd: '/d', desc: 'Dry-run toggle (alias)', category: 'Quick' },
+
+  // ── Meta ─────────────────────────────────────────────────────────────────────
+  { cmd: '/help', desc: 'Show all commands', category: 'Meta' },
+  { cmd: '/quit', desc: 'Exit wispy', category: 'Meta' },
+  { cmd: '/exit', desc: 'Exit wispy (alias)', category: 'Meta' },
+  { cmd: '/provider', desc: 'Show current provider & model', category: 'Meta' },
+  { cmd: '/overview', desc: 'Director view of all workstreams', category: 'Meta' },
+  { cmd: '/search <keyword>', desc: 'Search across workstreams', category: 'Meta' },
+];
+
+/**
+ * Returns COMMANDS merged with dynamically loaded skills.
+ * skillManager is optional — if null, returns base COMMANDS.
+ */
+export function getCommandsWithSkills(skillManager) {
+  const skills = skillManager?.list?.() ?? [];
+  return [
+    ...COMMANDS,
+    ...skills.map(s => ({
+      cmd: `/${s.name}`,
+      desc: s.description ?? 'Learned skill',
+      category: 'Skill',
+    })),
+  ];
+}
+
+/**
+ * Filter commands that start with the given prefix.
+ * Returns up to `limit` results.
+ */
+export function filterCommands(prefix, commands = COMMANDS, limit = 10) {
+  if (!prefix) return [];
+  const lower = prefix.toLowerCase();
+  return commands
+    .filter(c => c.cmd.toLowerCase().startsWith(lower))
+    .slice(0, limit);
+}

package/lib/wispy-repl.mjs

@@ -13,11 +13,13 @@
 import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline";
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile, writeFile, readdir, stat } from "node:fs/promises";
 import { spawn as spawnProcess } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { statSync } from "node:fs";
 
+import { COMMANDS, getCommandsWithSkills, filterCommands } from "./command-registry.mjs";
+
 import {
   WispyEngine,
   loadConfig,
@@ -1084,6 +1086,136 @@ ${bold("Permissions & Audit (v1.1):")}
 // Interactive REPL
 // ---------------------------------------------------------------------------
 
+// ---------------------------------------------------------------------------
+// REPL autocomplete helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a combined command list for the completer.
+ * Synchronous-safe: uses cached skills list if engine is available.
+ */
+let _cachedCommands = null;
+function getCachedCommands(engine) {
+  if (_cachedCommands) return _cachedCommands;
+  try {
+    const skills = engine?.skills?.listSync?.() ?? [];
+    _cachedCommands = getCommandsWithSkills({ list: () => skills });
+  } catch {
+    _cachedCommands = COMMANDS;
+  }
+  return _cachedCommands;
+}
+
+/**
+ * Path completer: expands file-system paths starting with / ~ or ./
+ */
+async function pathCompleter(partial) {
+  try {
+    let dir, prefix;
+    if (partial === '' || partial === '.') {
+      dir = process.cwd(); prefix = partial;
+    } else if (partial.startsWith('~/')) {
+      const expanded = path.join(os.homedir(), partial.slice(2));
+      dir = path.dirname(expanded);
+      prefix = partial;
+    } else {
+      dir = path.dirname(partial) || '.';
+      if (dir === '.') dir = process.cwd();
+      prefix = partial;
+    }
+    const base = path.basename(partial);
+    const entries = await readdir(dir).catch(() => []);
+    const hits = entries
+      .filter(e => e.startsWith(base))
+      .map(e => {
+        const full = path.join(dir, e);
+        try {
+          const s = statSync(full);
+          return s.isDirectory() ? full + '/' : full;
+        } catch { return full; }
+      });
+    return [hits, partial];
+  } catch {
+    return [[], partial];
+  }
+}
+
+/**
+ * Main readline completer: slash commands + path expansion
+ */
+function makeCompleter(engine) {
+  return function completer(line, callback) {
+    // Slash command completion
+    if (line.startsWith('/')) {
+      const commands = getCachedCommands(engine);
+      const hits = filterCommands(line, commands, 15);
+      const completions = hits.map(c => c.cmd);
+      // If no hits, return empty
+      callback(null, [completions.length ? completions : [], line]);
+      return;
+    }
+
+    // Path completion (starts with /, ~/, ./, or contains a /)
+    const lastWord = line.split(' ').pop() ?? '';
+    if (lastWord.startsWith('/') || lastWord.startsWith('~/') || lastWord.startsWith('./') || lastWord.startsWith('../')) {
+      pathCompleter(lastWord).then(([hits, orig]) => {
+        callback(null, [hits, orig]);
+      }).catch(() => callback(null, [[], line]));
+      return;
+    }
+
+    // No completion
+    callback(null, [[], line]);
+  };
+}
+
+/**
+ * Print a preview hint below the current line using ANSI escape sequences.
+ * Clears previous hint before printing new one.
+ */
+let _lastHintLines = 0;
+function showCommandHint(line, engine) {
+  if (!process.stdout.isTTY) return;
+  // Clear previous hint
+  if (_lastHintLines > 0) {
+    process.stdout.write(`\x1b[${_lastHintLines}B`); // move down past hints
+    for (let i = 0; i < _lastHintLines; i++) {
+      process.stdout.write('\x1b[2K\x1b[A'); // clear line, move up
+    }
+    _lastHintLines = 0;
+  }
+
+  if (!line.startsWith('/') || line.length < 2) return;
+
+  const commands = getCachedCommands(engine);
+  const matches = filterCommands(line, commands, 5);
+  if (matches.length === 0) return;
+
+  const hints = matches.map(c => {
+    const cmdPart = c.cmd.padEnd(30);
+    return `  \x1b[2m${cmdPart} — ${c.desc}\x1b[0m`;
+  });
+
+  // Save cursor, move to next line, print hints, restore cursor
+  process.stdout.write('\x1b[s'); // save cursor
+  process.stdout.write('\n');
+  for (const h of hints) {
+    process.stdout.write(`\x1b[2K${h}\n`);
+  }
+  process.stdout.write('\x1b[u'); // restore cursor
+  _lastHintLines = hints.length;
+}
+
+function clearCommandHint() {
+  if (!process.stdout.isTTY || _lastHintLines === 0) return;
+  process.stdout.write('\x1b[s');
+  for (let i = 0; i < _lastHintLines; i++) {
+    process.stdout.write('\n\x1b[2K');
+  }
+  process.stdout.write('\x1b[u');
+  _lastHintLines = 0;
+}
+
 async function runRepl(engine) {
   // Initialize dry-run from env flag (set by `wispy dry "..."`)
   if (process.env.WISPY_DRY_RUN === "1") {
@@ -1104,8 +1236,26 @@ async function runRepl(engine) {
     output: process.stdout,
     prompt: green("› "),
     historySize: 100,
+    completer: makeCompleter(engine),
   });
 
+  // Show inline hints as user types
+  rl.on('line', () => { clearCommandHint(); });
+  if (process.stdin.isTTY) {
+    process.stdin.on('keypress', (_ch, key) => {
+      if (!key) return;
+      // Slight delay to let readline update its line buffer
+      setImmediate(() => {
+        const line = rl.line ?? '';
+        if (line.startsWith('/')) {
+          showCommandHint(line, engine);
+        } else {
+          clearCommandHint();
+        }
+      });
+    });
+  }
+
   // Dynamic prompt — shows workstream and dry-run status
   function updatePrompt() {
     const ws = ACTIVE_WORKSTREAM !== "default" ? `${cyan(ACTIVE_WORKSTREAM)} ` : "";

package/lib/wispy-tui.mjs

@@ -14,6 +14,8 @@ import { render, Box, Text, useApp, Newline, useInput, useStdout } from "ink";
 import Spinner from "ink-spinner";
 import TextInput from "ink-text-input";
 
+import { COMMANDS, filterCommands } from "./command-registry.mjs";
+
 import os from "node:os";
 import path from "node:path";
 import { readFile, writeFile, readdir, stat, mkdir } from "node:fs/promises";
@@ -661,6 +663,71 @@ function HelpOverlay({ onClose }) {
   );
 }
 
+// ─── Command Palette (autocomplete dropdown) ──────────────────────────────────
+
+function CommandPalette({ query, onSelect, onDismiss }) {
+  const [selectedIdx, setSelectedIdx] = useState(0);
+
+  const matches = filterCommands(query, COMMANDS, 8);
+
+  // Reset selection when query changes
+  useEffect(() => { setSelectedIdx(0); }, [query]);
+
+  useInput((input, key) => {
+    if (matches.length === 0) return;
+    if (key.upArrow) {
+      setSelectedIdx(i => Math.max(0, i - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIdx(i => Math.min(matches.length - 1, i + 1));
+      return;
+    }
+    if (key.return) {
+      onSelect?.(matches[selectedIdx]?.cmd ?? query);
+      return;
+    }
+    if (key.escape || (key.ctrl && input === 'c')) {
+      onDismiss?.();
+      return;
+    }
+  });
+
+  if (matches.length === 0) return null;
+
+  const maxCmdLen = Math.max(...matches.map(m => m.cmd.length));
+  const width = Math.min(60, maxCmdLen + 30);
+
+  return React.createElement(
+    Box, {
+      flexDirection: 'column',
+      borderStyle: 'single',
+      borderColor: 'cyan',
+      paddingX: 1,
+      marginBottom: 0,
+    },
+    React.createElement(
+      Box, { paddingX: 1 },
+      React.createElement(Text, { bold: true, color: 'cyan' }, '─ Commands '),
+      React.createElement(Text, { dimColor: true }, '↑↓ navigate · Enter select · Esc dismiss'),
+    ),
+    ...matches.map((cmd, i) => {
+      const isActive = i === selectedIdx;
+      const cmdStr = cmd.cmd.padEnd(maxCmdLen);
+      return React.createElement(
+        Box, { key: cmd.cmd },
+        isActive
+          ? React.createElement(Text, { color: 'black', backgroundColor: 'cyan' },
+              ` ${cmdStr}  ${cmd.desc} `)
+          : React.createElement(Box, {},
+              React.createElement(Text, { color: 'cyan' }, ` ${cmd.cmd}`),
+              React.createElement(Text, { dimColor: true }, ' '.repeat(Math.max(1, maxCmdLen - cmd.cmd.length + 2)) + cmd.desc),
+            ),
+      );
+    }),
+  );
+}
+
 // ─── Input Area ───────────────────────────────────────────────────────────────
 
 function InputArea({ value, onChange, onSubmit, loading, workstream, view }) {
@@ -817,6 +884,9 @@ function WispyWorkspaceApp({ engine, initialWorkstream }) {
   const [inputValue, setInputValue] = useState("");
   const [loading, setLoading] = useState(false);
 
+  // Command palette (autocomplete)
+  const [showPalette, setShowPalette] = useState(false);
+
   // Engine stats
   const [model, setModel] = useState(engine.model ?? "?");
   const [provider, setProvider] = useState(engine.provider ?? "?");
@@ -1063,12 +1133,34 @@ function WispyWorkspaceApp({ engine, initialWorkstream }) {
     }
   }, [pendingApproval]);
 
+  // ── Palette visibility: show when typing slash commands ──
+  const handleInputChange = useCallback((val) => {
+    setInputValue(val);
+    if (val.startsWith('/') && val.length >= 2) {
+      setShowPalette(true);
+    } else {
+      setShowPalette(false);
+    }
+  }, []);
+
+  const handlePaletteSelect = useCallback((cmd) => {
+    // Fill in base command (strip template args like <name>)
+    const base = cmd.replace(/<[^>]+>/g, '').trimEnd();
+    setInputValue(base);
+    setShowPalette(false);
+  }, []);
+
+  const handlePaletteDismiss = useCallback(() => {
+    setShowPalette(false);
+  }, []);
+
   // ── Message submit ──
   const handleSubmit = useCallback(async (value) => {
     if (pendingApproval) return;
     const input = value.trim();
     if (!input || loading) return;
     setInputValue("");
+    setShowPalette(false);
 
     // Switch to chat if not there
     if (view !== "chat") setView("chat");
@@ -1261,11 +1353,20 @@ function WispyWorkspaceApp({ engine, initialWorkstream }) {
       ? React.createElement(TimelineBar, { events: timeline })
       : null,
 
+    // Command palette (autocomplete) — shown above input when typing /command
+    !showHelp && showPalette && inputValue.startsWith('/')
+      ? React.createElement(CommandPalette, {
+          query: inputValue,
+          onSelect: handlePaletteSelect,
+          onDismiss: handlePaletteDismiss,
+        })
+      : null,
+
     // Input area (always at bottom; hidden when help shown)
     !showHelp
       ? React.createElement(InputArea, {
           value: inputValue,
-          onChange: setInputValue,
+          onChange: handleInputChange,
           onSubmit: handleSubmit,
           loading,
           workstream: activeWorkstream,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wispy-cli",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "🌿 Wispy — AI workspace assistant with trustworthy execution (harness, receipts, approvals, diffs)",
   "license": "MIT",
   "author": "Minseo & Poropo",