deepseek-cli-mode 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 1.2.0 — live slash-command menu
+
+- Typing `/` at the prompt now opens a live command menu (like Claude Code): matching commands and descriptions,
+  `↑`/`↓` to move, `Tab` to complete, `Enter` to run the highlighted command.
+- New raw-mode line editor (`runner/line-editor.js`) for TTY sessions: cursor movement, history, bracketed paste,
+  Ctrl+A/E, and a menu that filters as you type.
+- Piped/non-TTY input keeps the existing readline path; one-shot mode is unchanged.
+- Security: the editor strips C0/C1 control characters from inserted text and renders command names/descriptions
+  through the sanitizer; it never executes anything itself.
+- The launcher now copies every runner module into the profile (previously only `runner.js`).
+
 ## 1.1.0 — Claude-Code-style terminal UI
 
 - New welcome panel: rounded box with version, model, cwd, and first-run hints.

package/README.md

@@ -134,6 +134,16 @@ deepseek "review @src/app.ts and tell me what is risky"
 
 ### Inside a session
 
+Typing `/` opens a live command menu, like Claude Code:
+
+```
+> /se
+  ❯ /session    Print the current session id
+    /sessions   List recent sessions in this directory
+```
+
+`↑`/`↓` moves the selection, `Tab` completes it, `Enter` runs it. The menu filters as you type.
+
 | Command | What it does |
 |---|---|
 | `/help` | command list, including the live Harness command registry |

package/bin/deepseek.js

@@ -9,7 +9,7 @@
 // The profile keeps ONE live Agent for the whole session, so tools, approvals,
 // session persistence, and the model's request prefix stay warm between turns.
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { dirname, delimiter, join, resolve } from "node:path";
@@ -198,11 +198,14 @@ function ensureProfile() {
     if (!existsSync(target) || stampVersion !== VERSION) writeFileSync(target, content);
   }
 
-  // Keep the runner exactly in sync with this package.
-  const runnerSrc = join(root, "runner", "runner.js");
-  const runnerDst = join(profileDir, "runner.js");
-  const src = readFileSync(runnerSrc, "utf8");
-  if (!existsSync(runnerDst) || readFileSync(runnerDst, "utf8") !== src) writeFileSync(runnerDst, src);
+  // Keep every runner file exactly in sync with this package.
+  const runnerSrcDir = join(root, "runner");
+  for (const entry of readdirSync(runnerSrcDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !/\.(?:js|mjs|cjs)$/.test(entry.name)) continue;
+    const src = readFileSync(join(runnerSrcDir, entry.name), "utf8");
+    const dst = join(profileDir, entry.name);
+    if (!existsSync(dst) || readFileSync(dst, "utf8") !== src) writeFileSync(dst, src);
+  }
 
   writeFileSync(stamp, VERSION + "\n");
   return profileDir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepseek-cli-mode",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Terminal (CLI) mode for DeepSeek Harness — an interactive, Claude Code-style coding agent for your shell.",
   "type": "module",
   "main": "index.js",

package/runner/line-editor.js

@@ -0,0 +1,354 @@
+// Minimal terminal line editor with a live slash-command menu, in the style of
+// Claude Code. No dependencies. Attaches to a TTY in raw mode and renders one
+// input line plus an optional suggestion list below it.
+//
+// Security: every string this module prints as user content is stripped of
+// C0/C1 control characters (except newline/tab handled by the caller). The
+// editor never executes anything; it only returns the submitted line.
+
+const CONTROL_CHARS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g;
+const ANSI = /\x1b\[[0-9;?]*[A-Za-z]/g;
+
+/** Visible width of a prompt that may contain ANSI escapes. */
+function visibleWidth(text) {
+  return String(text).replace(ANSI, "").length;
+}
+
+/** Strip terminal control characters from untrusted text. */
+function clean(text) {
+  return String(text).replace(CONTROL_CHARS, "");
+}
+
+export class LineEditor {
+  /**
+   * @param {object} options
+   * @param {NodeJS.ReadStream} options.input
+   * @param {NodeJS.WriteStream} options.output
+   * @param {() => number} [options.columns]
+   * @param {() => void} [options.onInterrupt] called for Ctrl+C while no question is pending
+   * @param {() => void} [options.onEnd] called when stdin ends
+   */
+  constructor({ input, output, columns, onInterrupt, onEnd }) {
+    this.input = input;
+    this.output = output;
+    this.columns = columns ?? (() => this.output.columns || 80);
+    this.onInterrupt = onInterrupt ?? (() => {});
+    this.onEnd = onEnd ?? (() => {});
+    this.commands = [];
+    this.buffer = "";
+    this.cursor = 0;
+    this.history = [];
+    this.historyIndex = -1;
+    this.draft = "";
+    this.menu = [];
+    this.menuIndex = 0;
+    this.active = false;
+    this.menuEnabled = false;
+    this.prompt = "";
+    this.resolve = null;
+    this.renderedRows = 0;
+    this.paste = false;
+    this.escape = null;
+    this.started = false;
+    this._onData = (chunk) => this.handleData(chunk);
+    this._onEnd = () => {
+      this.onEnd();
+      this.settle(null, false);
+    };
+  }
+
+  start() {
+    if (this.started) return;
+    this.started = true;
+    this.input.setRawMode?.(true);
+    this.input.setEncoding?.("utf8");
+    this.input.resume?.();
+    this.input.on("data", this._onData);
+    this.input.on("end", this._onEnd);
+    this.output.write("\x1b[?2004h");
+  }
+
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    this.input.off?.("data", this._onData);
+    this.input.off?.("end", this._onEnd);
+    this.output.write("\x1b[?2004l");
+    this.input.setRawMode?.(false);
+    this.input.pause?.();
+  }
+
+  /** Replace the suggestion list (name + description objects). */
+  setCommands(commands) {
+    this.commands = Array.isArray(commands) ? commands : [];
+  }
+
+  /** Enable/disable input while a turn runs (Ctrl+C still interrupts). */
+  setActive(active) {
+    if (this.active === active) return;
+    this.active = active;
+    if (!active) this.clearRender();
+  }
+
+  /**
+   * Ask one line.
+   * @param {string} prompt prompt string (may contain ANSI)
+   * @param {boolean} menuEnabled show slash-command suggestions
+   * @returns {Promise<string|null>} line, or null on Ctrl+C / EOF
+   */
+  ask(prompt, menuEnabled = false) {
+    this.prompt = prompt;
+    this.menuEnabled = menuEnabled;
+    this.buffer = "";
+    this.cursor = 0;
+    this.menu = [];
+    this.menuIndex = 0;
+    this.historyIndex = -1;
+    this.draft = "";
+    this.active = true;
+    this.renderedRows = 0;
+    this.render();
+    return new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+
+  // ---- input --------------------------------------------------------------
+  handleData(chunk) {
+    for (const char of String(chunk)) {
+      if (this.escape !== null) {
+        this.escape += char;
+        if (/[A-Za-z~]$/.test(char)) {
+          const sequence = this.escape;
+          this.escape = null;
+          this.handleEscape(sequence);
+        }
+        continue;
+      }
+      if (char === "\x1b") {
+        this.escape = "\x1b";
+        continue;
+      }
+      if (!this.active) {
+        if (char === "\x03") this.onInterrupt();
+        continue;
+      }
+      this.handleChar(char);
+    }
+    if (this.active) this.render();
+  }
+
+  handleChar(char) {
+    if (this.paste) {
+      if (char === "\x1b") this.escape = "\x1b";
+      else this.insert(char === "\n" ? " " : char);
+      return;
+    }
+    switch (char) {
+      case "\r":
+      case "\n":
+        this.submit();
+        return;
+      case "\x03": // Ctrl+C
+        this.settle(null);
+        return;
+      case "\x04": // Ctrl+D
+        this.settle(null);
+        return;
+      case "\x7f":
+      case "\b":
+        this.backspace();
+        return;
+      case "\t":
+        this.complete();
+        return;
+      case "\x01": // Ctrl+A
+        this.cursor = 0;
+        return;
+      case "\x05": // Ctrl+E
+        this.cursor = this.buffer.length;
+        return;
+      default:
+        if (char >= " ") this.insert(char);
+    }
+  }
+
+  handleEscape(sequence) {
+    if (sequence === "\x1b[200~") {
+      this.paste = true;
+      return;
+    }
+    if (sequence === "\x1b[201~") {
+      this.paste = false;
+      return;
+    }
+    if (this.paste) return;
+    switch (sequence) {
+      case "\x1b[A":
+        this.up();
+        break;
+      case "\x1b[B":
+        this.down();
+        break;
+      case "\x1b[C":
+        this.cursor = Math.min(this.cursor + 1, this.buffer.length);
+        break;
+      case "\x1b[D":
+        this.cursor = Math.max(this.cursor - 1, 0);
+        break;
+      case "\x1b[H":
+      case "\x1b[1~":
+        this.cursor = 0;
+        break;
+      case "\x1b[F":
+      case "\x1b[4~":
+        this.cursor = this.buffer.length;
+        break;
+      case "\x1b[3~":
+        this.deleteForward();
+        break;
+      default:
+        break;
+    }
+  }
+
+  insert(text) {
+    const safe = clean(text);
+    this.buffer = this.buffer.slice(0, this.cursor) + safe + this.buffer.slice(this.cursor);
+    this.cursor += safe.length;
+    this.historyIndex = -1;
+    this.menuIndex = 0;
+  }
+
+  backspace() {
+    if (this.cursor === 0) return;
+    this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+    this.cursor -= 1;
+    this.historyIndex = -1;
+  }
+
+  deleteForward() {
+    if (this.cursor >= this.buffer.length) return;
+    this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+    this.historyIndex = -1;
+  }
+
+  up() {
+    if (this.menu.length > 0) {
+      this.menuIndex = (this.menuIndex - 1 + this.menu.length) % this.menu.length;
+      return;
+    }
+    if (this.history.length === 0) return;
+    if (this.historyIndex === -1) {
+      this.draft = this.buffer;
+      this.historyIndex = this.history.length - 1;
+    } else if (this.historyIndex > 0) {
+      this.historyIndex -= 1;
+    }
+    this.buffer = this.history[this.historyIndex];
+    this.cursor = this.buffer.length;
+  }
+
+  down() {
+    if (this.menu.length > 0) {
+      this.menuIndex = (this.menuIndex + 1) % this.menu.length;
+      return;
+    }
+    if (this.historyIndex === -1) return;
+    if (this.historyIndex < this.history.length - 1) {
+      this.historyIndex += 1;
+      this.buffer = this.history[this.historyIndex];
+    } else {
+      this.historyIndex = -1;
+      this.buffer = this.draft;
+    }
+    this.cursor = this.buffer.length;
+  }
+
+  complete() {
+    const item = this.menu[this.menuIndex];
+    if (item === undefined) return;
+    this.buffer = "/" + item.name;
+    this.cursor = this.buffer.length;
+    this.menu = [];
+    this.menuIndex = 0;
+  }
+
+  submit() {
+    const item = this.menu[this.menuIndex];
+    if (item !== undefined && this.buffer.trim() !== "/" + item.name) {
+      this.buffer = "/" + item.name;
+      this.cursor = this.buffer.length;
+    }
+    const line = this.buffer;
+    if (line.trim() !== "" && this.history[this.history.length - 1] !== line) {
+      this.history.push(line);
+      if (this.history.length > 200) this.history.shift();
+    }
+    this.settle(line);
+  }
+
+  settle(value, echo = true) {
+    if (this.resolve === null) return;
+    const resolve = this.resolve;
+    this.resolve = null;
+    this.active = false;
+    this.clearRender();
+    this.menu = [];
+    if (echo) this.output.write("\n");
+    resolve(value);
+  }
+
+  // ---- rendering ----------------------------------------------------------
+  computeMenu() {
+    if (!this.menuEnabled) return [];
+    if (!this.buffer.startsWith("/")) return [];
+    if (/\s/.test(this.buffer)) return [];
+    const query = this.buffer.slice(1).toLowerCase();
+    const items = this.commands.filter((command) => command.name.toLowerCase().startsWith(query));
+    return items.slice(0, 8);
+  }
+
+  clearRender() {
+    if (this.renderedRows > 0) {
+      this.output.write(`\x1b[${this.renderedRows}B`);
+      this.output.write("\r\x1b[0J");
+      this.output.write(`\x1b[${this.renderedRows}A`);
+    }
+    this.output.write("\r\x1b[2K");
+    this.renderedRows = 0;
+  }
+
+  render() {
+    if (!this.active) return;
+    this.clearRender();
+    const columns = Math.max(40, this.columns() || 80);
+    const prompt = this.prompt;
+    const promptWidth = visibleWidth(prompt);
+    const available = Math.max(8, columns - promptWidth - 1);
+    let offset = 0;
+    if (this.buffer.length > available) offset = Math.max(0, this.cursor - available + 1);
+    const visible = this.buffer.slice(offset, offset + available);
+    const column = promptWidth + (this.cursor - offset);
+    this.output.write(prompt + visible);
+
+    this.menu = this.computeMenu();
+    if (this.menuIndex >= this.menu.length) this.menuIndex = 0;
+    const rows = this.menu.length;
+    if (rows > 0) {
+      const nameWidth = Math.min(18, Math.max(...this.menu.map((item) => item.name.length)) + 1);
+      for (let index = 0; index < rows; index += 1) {
+        const item = this.menu[index];
+        const selected = index === this.menuIndex;
+        const marker = selected ? "❯" : " ";
+        const name = ("/" + clean(item.name)).padEnd(nameWidth + 1);
+        const description = clean(item.description ?? "").slice(0, Math.max(10, columns - nameWidth - 8));
+        const line = `  ${marker} ${selected ? `\x1b[36m${name}\x1b[39m` : name} ${description}`;
+        this.output.write("\n" + line);
+      }
+      this.output.write(`\x1b[${rows}A`);
+    }
+    this.renderedRows = rows;
+    this.output.write(`\x1b[${column + 1}G`);
+  }
+}

package/runner/runner.js

@@ -23,6 +23,7 @@ import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { installModelSelection } from "@deepseek-ai/dsh-agent";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { LineEditor } from "./line-editor.js";
 
 /** Stable Cordis plugin name. */
 export const name = "cli-runner";
@@ -493,6 +494,41 @@ function printBanner(model) {
   out(paint(ansi.dim, "  Type a task, or /help. Ctrl+C interrupts; twice exits.") + "\n\n");
 }
 
+// Slash-command suggestions for the live menu (native Harness commands are
+// merged in at runtime).
+const BUILTIN_COMMANDS = [
+  { name: "clear", description: "Clear the screen" },
+  { name: "exit", description: "Leave the session" },
+  { name: "export", description: "Write this run's transcript as markdown" },
+  { name: "help", description: "Show commands" },
+  { name: "image", description: "Attach an image to the next message" },
+  { name: "jobs", description: "List this session's background jobs" },
+  { name: "model", description: "Show or switch the model" },
+  { name: "new", description: "Start a fresh session" },
+  { name: "permissions", description: "Show or switch the permission preset" },
+  { name: "quit", description: "Leave the session" },
+  { name: "reasoning", description: "Show or set the reasoning effort" },
+  { name: "resume", description: "Switch to another session" },
+  { name: "session", description: "Print the current session id" },
+  { name: "sessions", description: "List recent sessions in this directory" },
+  { name: "skills", description: "List discovered skills" },
+  { name: "status", description: "Session, model, cwd, token pressure" },
+  { name: "thinking", description: "Show the last turn's reasoning" },
+  { name: "todos", description: "Show the current todo list" },
+];
+
+/** Built-ins plus whatever commands the Harness profile registers. */
+function commandMenu(agent, commands) {
+  const merged = new Map();
+  for (const command of BUILTIN_COMMANDS) merged.set(command.name, command);
+  try {
+    for (const native of commands?.list(agent) ?? []) {
+      if (!merged.has(native.name)) merged.set(native.name, { name: native.name, description: native.description });
+    }
+  } catch {}
+  return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
 function printHelp(write = out) {
   write(`deepseek ${VERSION} — DeepSeek Harness in your terminal.
 
@@ -631,17 +667,31 @@ async function run(ctx, options, exit) {
   const write = (text) => process.stdout.write(text);
 
   // ---- line input ---------------------------------------------------------
-  // One-shot mode must not own stdin: a piped/closed stdin would deliver EOF
-  // and tear the runtime down before the task runs.
-  const rlInterface = interactive
-    ? createInterface({
+  // TTY: a raw-mode line editor with a live slash-command menu (Claude style).
+  // Non-TTY: readline over the piped stream. One-shot: no input owner at all.
+  const useEditor = interactive && process.stdin.isTTY === true;
+  const editor = useEditor
+    ? new LineEditor({
         input: process.stdin,
         output: process.stdout,
-        terminal: process.stdin.isTTY,
-        historySize: 200,
-        removeHistoryDuplicates: true,
+        columns: () => process.stdout.columns || 80,
+        onInterrupt: () => handleInterrupt(),
+        onEnd: () => {
+          stdinClosed = true;
+          if (ready && !busy) shutdown(0);
+        },
       })
     : null;
+  const rlInterface =
+    interactive && !useEditor
+      ? createInterface({
+          input: process.stdin,
+          output: process.stdout,
+          terminal: false,
+          historySize: 200,
+          removeHistoryDuplicates: true,
+        })
+      : null;
   // Hold the input until the first agent is ready: buffered piped lines must
   // not be consumed (and dropped) while the profile is still starting.
   if (rlInterface) {
@@ -650,8 +700,14 @@ async function run(ctx, options, exit) {
       paused = true;
     } catch {}
   }
+  editor?.start();
+  editor?.setActive(false);
 
   function setPaused(value) {
+    if (editor) {
+      editor.setActive(!value);
+      return;
+    }
     if (!rlInterface || paused === value) return;
     paused = value;
     try {
@@ -672,12 +728,16 @@ async function run(ctx, options, exit) {
 
   /**
    * Ask one line. Resolves null when the question is interrupted (Ctrl+C) or
-   * stdin closes. A permanent listener queues ahead-of-time lines (piped input,
-   * or typing while the model works), so no line is ever dropped.
+   * stdin closes. On a TTY the editor renders a live command menu.
    * @param {string} prompt
+   * @param {boolean} [menu]
    * @returns {Promise<string | null>}
    */
-  function ask(prompt) {
+  function ask(prompt, menu = false) {
+    if (editor) {
+      setPaused(false);
+      return editor.ask(prompt, menu);
+    }
     return new Promise((resolve) => {
       if (!rlInterface) {
         resolve(null);
@@ -711,6 +771,7 @@ async function run(ctx, options, exit) {
 
   function closeInput() {
     try {
+      editor?.stop();
       rlInterface?.close();
     } catch {}
   }
@@ -1150,7 +1211,8 @@ async function run(ctx, options, exit) {
   }
 
   while (!quitting) {
-    const line = await ask(paint(ansi.bold, "> "));
+    if (editor) editor.setCommands(commandMenu(agent, commands));
+    const line = await ask(paint(ansi.bold, "> "), true);
     if (line === null) break;
     const text = line.trim();
     if (text === "") continue;