deepseek-cli-mode 1.2.0 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 1.4.0 — reasoning effort levels in the model picker
+
+- `/model` now asks for the reasoning effort after you pick a model, listing the adapter's real levels
+  (`low`, `medium`, `high`, `max`) plus `default`, with the current value preselected.
+- `/reasoning` lists the same adapter-provided levels (falling back to `low`/`medium`/`high`/`max` when the
+  adapter exposes no metadata).
+- The footer and banner show the active model **and** effort, e.g. `deepseek-flash · high`.
+- Direct arguments still work: `/reasoning low`, `/model deepseek-v4-pro`.
+
+## 1.3.0 — pickers, Shift+Tab permission cycling, permanent mode footer
+
+- `/model`, `/reasoning`, `/permissions`, and `/resume` now open an interactive picker (`↑`/`↓`, `Enter`,
+  `Ctrl+C` to cancel) instead of requiring an argument. `/model` lists the models discovered from the provider.
+- **Shift+Tab** cycles the permission mode (read-only → workspace-write → danger-full-access) without losing the
+  typed line, with a transient hint.
+- A permanent dim footer above the prompt shows the active permission mode, model, and the Shift+Tab hint:
+  `⏵⏵ workspace-write · deepseek-official/deepseek-chat · shift+tab to cycle`.
+- Direct arguments still work (`/model <id>`, `/reasoning high`, `/permissions read-only`, `/resume <id>`).
+- Security: picker labels/descriptions and the footer pass through the sanitizer; permission changes still require a
+  user keystroke (the model cannot trigger them).
+
 ## 1.2.0 — live slash-command menu
 
 - Typing `/` at the prompt now opens a live command menu (like Claude Code): matching commands and descriptions,

package/README.md

@@ -144,6 +144,14 @@ Typing `/` opens a live command menu, like Claude Code:
 
 `↑`/`↓` moves the selection, `Tab` completes it, `Enter` runs it. The menu filters as you type.
 
+`/model`, `/reasoning`, `/permissions`, and `/resume` open the same kind of picker when called without an argument.
+**Shift+Tab** cycles the permission mode, and a dim footer above the prompt always shows the active one:
+
+```
+  ⏵⏵ workspace-write · deepseek-official/deepseek-chat · shift+tab to cycle
+> 
+```
+
 | Command | What it does |
 |---|---|
 | `/help` | command list, including the live Harness command registry |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepseek-cli-mode",
-  "version": "1.2.0",
+  "version": "1.4.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

@@ -28,12 +28,13 @@ export class LineEditor {
    * @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 }) {
+  constructor({ input, output, columns, onInterrupt, onEnd, onShiftTab }) {
     this.input = input;
     this.output = output;
     this.columns = columns ?? (() => this.output.columns || 80);
     this.onInterrupt = onInterrupt ?? (() => {});
     this.onEnd = onEnd ?? (() => {});
+    this.onShiftTab = onShiftTab ?? (() => undefined);
     this.commands = [];
     this.buffer = "";
     this.cursor = 0;
@@ -50,6 +51,10 @@ export class LineEditor {
     this.paste = false;
     this.escape = null;
     this.started = false;
+    this.selectMode = false;
+    this.selectOptions = [];
+    this.selectIndex = 0;
+    this.hint = "";
     this._onData = (chunk) => this.handleData(chunk);
     this._onEnd = () => {
       this.onEnd();
@@ -113,10 +118,60 @@ export class LineEditor {
     });
   }
 
+  /**
+   * Ask the user to pick one option from a list.
+   * @param {string} title prompt line
+   * @param {{label: string, description?: string, value: string}[]} options
+   * @param {number} [initial]
+   * @returns {Promise<string|null>}
+   */
+  askSelect(title, options, initial = 0) {
+    this.selectMode = true;
+    this.selectOptions = Array.isArray(options) ? options : [];
+    this.selectIndex = Math.max(0, Math.min(initial, this.selectOptions.length - 1));
+    this.prompt = title;
+    this.menuEnabled = false;
+    this.hint = "";
+    this.buffer = "";
+    this.cursor = 0;
+    this.active = true;
+    this.renderedRows = 0;
+    this.output.write("\x1b[?25l");
+    this.render();
+    return new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+
+  chooseSelect() {
+    const option = this.selectOptions[this.selectIndex];
+    this.selectMode = false;
+    this.selectOptions = [];
+    this.settle(option === undefined ? null : option.value);
+  }
+
+  cancelSelect() {
+    if (!this.selectMode) return;
+    this.selectMode = false;
+    this.selectOptions = [];
+    this.settle(null);
+  }
+
   // ---- input --------------------------------------------------------------
   handleData(chunk) {
     for (const char of String(chunk)) {
       if (this.escape !== null) {
+        if (this.escape === "\x1b" && char !== "[" && char !== "O") {
+          // Lone Esc (not a CSI/SS3 sequence).
+          this.escape = null;
+          if (this.selectMode) this.cancelSelect();
+          else if (this.active) {
+            this.hint = "";
+            this.menu = [];
+            this.render();
+          }
+          continue;
+        }
         this.escape += char;
         if (/[A-Za-z~]$/.test(char)) {
           const sequence = this.escape;
@@ -139,11 +194,17 @@ export class LineEditor {
   }
 
   handleChar(char) {
+    if (this.selectMode) {
+      if (char === "\r" || char === "\n") this.chooseSelect();
+      else if (char === "\x03" || char === "\x04") this.cancelSelect();
+      return;
+    }
     if (this.paste) {
       if (char === "\x1b") this.escape = "\x1b";
       else this.insert(char === "\n" ? " " : char);
       return;
     }
+    this.hint = "";
     switch (char) {
       case "\r":
       case "\n":
@@ -183,6 +244,20 @@ export class LineEditor {
       return;
     }
     if (this.paste) return;
+    if (sequence === "\x1b[Z") {
+      // Shift+Tab: cycle a mode (permission preset) while keeping the line.
+      if (this.selectMode) return;
+      this.hint = this.onShiftTab?.() ?? "";
+      return;
+    }
+    if (this.selectMode) {
+      if (sequence === "\x1b[A") {
+        this.selectIndex = (this.selectIndex - 1 + this.selectOptions.length) % Math.max(1, this.selectOptions.length);
+      } else if (sequence === "\x1b[B") {
+        this.selectIndex = (this.selectIndex + 1) % Math.max(1, this.selectOptions.length);
+      }
+      return;
+    }
     switch (sequence) {
       case "\x1b[A":
         this.up();
@@ -293,8 +368,12 @@ export class LineEditor {
     const resolve = this.resolve;
     this.resolve = null;
     this.active = false;
+    this.selectMode = false;
+    this.selectOptions = [];
+    this.hint = "";
     this.clearRender();
     this.menu = [];
+    this.output.write("\x1b[?25h");
     if (echo) this.output.write("\n");
     resolve(value);
   }
@@ -321,6 +400,10 @@ export class LineEditor {
 
   render() {
     if (!this.active) return;
+    if (this.selectMode) {
+      this.renderSelect();
+      return;
+    }
     this.clearRender();
     const columns = Math.max(40, this.columns() || 80);
     const prompt = this.prompt;
@@ -334,10 +417,10 @@ export class LineEditor {
 
     this.menu = this.computeMenu();
     if (this.menuIndex >= this.menu.length) this.menuIndex = 0;
-    const rows = this.menu.length;
-    if (rows > 0) {
+    let rows = 0;
+    if (this.menu.length > 0) {
       const nameWidth = Math.min(18, Math.max(...this.menu.map((item) => item.name.length)) + 1);
-      for (let index = 0; index < rows; index += 1) {
+      for (let index = 0; index < this.menu.length; index += 1) {
         const item = this.menu[index];
         const selected = index === this.menuIndex;
         const marker = selected ? "❯" : " ";
@@ -346,9 +429,34 @@ export class LineEditor {
         const line = `  ${marker} ${selected ? `\x1b[36m${name}\x1b[39m` : name} ${description}`;
         this.output.write("\n" + line);
       }
-      this.output.write(`\x1b[${rows}A`);
+      rows = this.menu.length;
+    }
+    if (this.hint !== "") {
+      this.output.write(`\n  \x1b[2m${clean(this.hint)}\x1b[22m`);
+      rows += 1;
     }
+    if (rows > 0) this.output.write(`\x1b[${rows}A`);
     this.renderedRows = rows;
     this.output.write(`\x1b[${column + 1}G`);
   }
+
+  renderSelect() {
+    this.clearRender();
+    const columns = Math.max(40, this.columns() || 80);
+    this.output.write(this.prompt);
+    const options = this.selectOptions;
+    const rows = options.length;
+    for (let index = 0; index < rows; index += 1) {
+      const option = options[index];
+      const selected = index === this.selectIndex;
+      const marker = selected ? "❯" : " ";
+      const label = clean(option.label ?? option.value ?? "");
+      const description = option.description ? `  \x1b[2m${clean(option.description)}\x1b[22m` : "";
+      const line = `  ${marker} ${selected ? `\x1b[36m${label}\x1b[39m` : label}${description}`;
+      this.output.write("\n" + line.slice(0, columns + 16));
+    }
+    if (rows > 0) this.output.write(`\x1b[${rows}A`);
+    this.renderedRows = rows;
+    this.output.write(`\x1b[${visibleWidth(this.prompt) + 1}G`);
+  }
 }

package/runner/runner.js

@@ -547,9 +547,9 @@ Interactive commands:
   /new               start a fresh session
   /sessions          list recent sessions in this directory
   /resume <id>       switch to another session
-  /model [id]        show or switch the model (e.g. /model deepseek-v4-pro)
-  /reasoning [off|high|max]   show or set the reasoning effort
-  /permissions [p]   show or switch the permission preset (native: /permission)
+  /model [id]        pick a model and its reasoning effort (low/medium/high/max)
+  /reasoning [off|high|max]   pick a reasoning effort
+  /permissions [p]   pick a permission mode (native: /permission; Shift+Tab cycles)
   /skills            list the skills discovered in this workspace
   /jobs              list this session's background jobs
   /todos             show the current todo list
@@ -564,6 +564,12 @@ Interactive commands:
 Harness commands (shared with the Web and Desktop apps):
   /compact, /goal, /plan, and any command a plugin registers.
   Type /help inside a session to see the live list.
+
+Keyboard:
+  Shift+Tab          cycle the permission mode (workspace-write, read-only, …)
+  Ctrl+C             interrupt a running turn; twice exits
+  ↑/↓                history (or move in the / command menu)
+  Tab                complete the highlighted / command
 `);
 }
 
@@ -637,6 +643,7 @@ async function run(ctx, options, exit) {
   const permissionPresets = ctx.get("permissionPresets");
   const attachments = ctx.get("attachments");
   const tokenMeter = ctx.get("tokenMeter");
+  const llm = ctx.get("llm");
 
   if (options.list) {
     printSessionList(listSessions());
@@ -652,6 +659,7 @@ async function run(ctx, options, exit) {
   const autoYes = options.yes || process.env.DSH_CLI_YES === "1";
 
   let handle = null;
+  let activeAgent = null;
   let busy = false;
   let quitting = false;
   let cancelSent = false;
@@ -676,6 +684,7 @@ async function run(ctx, options, exit) {
         output: process.stdout,
         columns: () => process.stdout.columns || 80,
         onInterrupt: () => handleInterrupt(),
+        onShiftTab: () => cyclePermission(),
         onEnd: () => {
           stdinClosed = true;
           if (ready && !busy) shutdown(0);
@@ -949,6 +958,7 @@ async function run(ctx, options, exit) {
           setup,
         });
     handle = created;
+    activeAgent = created.agent;
     wire(created.agent);
     await created.agent.whenIdle();
     return created.agent;
@@ -996,6 +1006,100 @@ async function run(ctx, options, exit) {
     return `${current.provider}/${current.model}${current.reasoningEffort ? ` · ${current.reasoningEffort}` : ""}`;
   };
 
+  // ---- permission state, pickers, status bar ------------------------------
+  function currentPermission() {
+    try {
+      if (permissionPresets !== undefined && activeAgent !== null) return permissionPresets.current(activeAgent.session);
+    } catch {}
+    return "workspace-write";
+  }
+
+  /** Shift+Tab: cycle the sandbox/approval preset and return a hint label. */
+  function cyclePermission() {
+    try {
+      if (permissionPresets === undefined || activeAgent === null) return "";
+      const options = permissionPresets.catalog().options.map((option) => option.value);
+      if (options.length === 0) return "";
+      const current = currentPermission();
+      const next = options[(Math.max(0, options.indexOf(current)) + 1) % options.length];
+      permissionPresets.set(activeAgent.session, next);
+      return `⏵⏵ ${next} (shift+tab to cycle)`;
+    } catch {
+      return "";
+    }
+  }
+
+  /** Permanent one-line footer above the prompt. */
+  function printStatusBar() {
+    if (!tty || !interactive) return;
+    out(paint(ansi.dim, `  ⏵⏵ ${sanitize(currentPermission())} · ${sanitize(modelDesc())} · shift+tab to cycle`) + "\n");
+  }
+
+  /** One list picker shared by /model, /reasoning, /permissions, /resume. */
+  async function selectOption(title, options, initial = 0) {
+    if (options.length === 0) return null;
+    if (editor) {
+      printStatusBar();
+      return editor.askSelect(paint(ansi.bold, `  ${title}`), options, initial);
+    }
+    out(`\n  ${sanitize(title)}\n`);
+    options.forEach((option, index) => {
+      out(`   ${index + 1}) ${sanitize(option.label)}${option.description ? paint(ansi.dim, ` — ${sanitize(option.description)}`) : ""}\n`);
+    });
+    const answer = await ask(paint(ansi.green, "  choose: "));
+    const index = Number.parseInt(answer ?? "", 10) - 1;
+    return options[index]?.value ?? null;
+  }
+
+  /** Adapter-owned reasoning levels for the selected model, when exposed. */
+  async function reasoningInfo() {
+    try {
+      if (llm === undefined) return null;
+      const resolved = await llm.resolveModel(selectionRef.current.provider, selectionRef.current.model);
+      return resolved.reasoning ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  async function applyModelSelection(modelId, pickEffort = true) {
+    const next = { ...selectionRef.current, model: modelId };
+    try {
+      await defaultModel.saveSelection(next);
+      selectionRef.current = next;
+      out(paint(ansi.green, `  ✓ model set: ${sanitize(next.provider)}/${sanitize(next.model)} (next message)\n`));
+    } catch (error) {
+      out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
+      return;
+    }
+    if (!pickEffort) return;
+    const info = await reasoningInfo();
+    const effortOptions =
+      info !== null && info.efforts.length > 0
+        ? info.efforts.map((effort) => ({ label: effort.name, description: effort.id, value: effort.id }))
+        : ["low", "medium", "high", "max"].map((effort) => ({ label: effort, description: `effort: ${effort}`, value: effort }));
+    const options = [...effortOptions, { label: "default", description: "provider default", value: "default" }];
+    const defaultEffort = info !== null && info.defaultEffort !== undefined ? info.defaultEffort : "default";
+    // Offer the effort choice for the newly selected model, keeping the current
+    // value when it is still valid.
+    const currentEffort = selectionRef.current.reasoningEffort ?? "default";
+    const preferred = options.some((option) => option.value === currentEffort) ? currentEffort : defaultEffort;
+    const initial = Math.max(0, options.findIndex((option) => option.value === preferred));
+    const chosen = await selectOption(`Reasoning effort for ${modelId}`, options, initial);
+    if (chosen !== null) await applyReasoningSelection(chosen);
+  }
+
+  async function applyReasoningSelection(effort) {
+    const next = { ...selectionRef.current, reasoningEffort: effort === "default" ? undefined : effort };
+    try {
+      await defaultModel.saveSelection(next);
+      selectionRef.current = next;
+      out(paint(ansi.green, `  ✓ reasoning set: ${sanitize(effort)} (next message)\n`));
+    } catch (error) {
+      out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
+    }
+  }
+
   // ---- parity helpers -----------------------------------------------------
   const transcript = [];
   const pendingImages = [];
@@ -1211,6 +1315,7 @@ async function run(ctx, options, exit) {
   }
 
   while (!quitting) {
+    printStatusBar();
     if (editor) editor.setCommands(commandMenu(agent, commands));
     const line = await ask(paint(ansi.bold, "> "), true);
     if (line === null) break;
@@ -1243,13 +1348,27 @@ async function run(ctx, options, exit) {
           printSessionList(listSessions(), write);
           continue;
         case "/resume": {
-          if (argument === "") {
-            out(paint(ansi.yellow, "  usage: /resume <session-id> (see /sessions)\n"));
-            continue;
+          let target = argument;
+          if (target === "") {
+            const sessions = listSessions();
+            if (sessions.length === 0) {
+              out(paint(ansi.yellow, "  no sessions in this directory yet\n"));
+              continue;
+            }
+            target = await selectOption(
+              "Resume session",
+              sessions.slice(0, 10).map((session) => ({
+                label: session.id,
+                description: timeAgo(session.mtime) + (session.openTurn ? " · running" : ""),
+                value: session.id,
+              })),
+              0
+            );
+            if (target === null) continue;
           }
           try {
-            out(paint(ansi.dim, `  ↻ resuming ${argument}\n`));
-            agent = await startAgent(undefined, argument);
+            out(paint(ansi.dim, `  ↻ resuming ${sanitize(target)}\n`));
+            agent = await startAgent(undefined, target);
           } catch (error) {
             out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
           }
@@ -1273,33 +1392,50 @@ async function run(ctx, options, exit) {
           continue;
         }
         case "/model": {
-          if (argument === "") {
-            out(paint(ansi.dim, `  model: ${modelDesc()}\n`));
+          if (argument !== "") {
+            await applyModelSelection(argument);
             continue;
           }
-          const next = { ...selectionRef.current, model: argument };
+          let models = [];
           try {
-            await defaultModel.saveSelection(next);
-            selectionRef.current = next;
-            out(paint(ansi.green, `  ✓ model set: ${next.provider}/${next.model} (next message)\n`));
-          } catch (error) {
-            out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
+            models = llm === undefined ? [] : await llm.listModels(selectionRef.current.provider);
+          } catch {}
+          if (models.length === 0) {
+            out(paint(ansi.dim, `  model: ${sanitize(modelDesc())}`) + "\n");
+            out(paint(ansi.dim, "  no model list is discoverable here — use /model <id>\n"));
+            continue;
           }
+          const currentIndex = Math.max(0, models.findIndex((model) => model.id === selectionRef.current.model));
+          const chosen = await selectOption(
+            "Select model",
+            models.map((model) => ({ label: model.name || model.id, description: model.id, value: model.id })),
+            currentIndex
+          );
+          if (chosen !== null) await applyModelSelection(chosen);
           continue;
         }
         case "/reasoning": {
-          if (argument === "") {
-            out(paint(ansi.dim, `  reasoning: ${selectionRef.current.reasoningEffort ?? "default"}\n`));
+          if (argument !== "") {
+            await applyReasoningSelection(argument);
             continue;
           }
-          const next = { ...selectionRef.current, reasoningEffort: argument === "default" ? undefined : argument };
-          try {
-            await defaultModel.saveSelection(next);
-            selectionRef.current = next;
-            out(paint(ansi.green, `  ✓ reasoning set: ${argument} (next message)\n`));
-          } catch (error) {
-            out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
-          }
+          const info = await reasoningInfo();
+          const efforts =
+            info !== null && info.efforts.length > 0
+              ? info.efforts.map((effort) => ({
+                  label: effort.name,
+                  description: effort.description ?? effort.id,
+                  value: effort.id,
+                }))
+              : ["low", "medium", "high", "max"].map((effort) => ({
+                  label: effort,
+                  description: `effort: ${effort}`,
+                  value: effort,
+                }));
+          efforts.push({ label: "default", description: "provider default", value: "default" });
+          const current = selectionRef.current.reasoningEffort ?? "default";
+          const chosen = await selectOption("Select reasoning effort", efforts, Math.max(0, efforts.findIndex((option) => option.value === current)));
+          if (chosen !== null) await applyReasoningSelection(chosen);
           continue;
         }
         case "/thinking": {
@@ -1381,19 +1517,25 @@ async function run(ctx, options, exit) {
             continue;
           }
           try {
-            const catalog = permissionPresets.catalog();
-            if (argument === "") {
-              out(paint(ansi.bold, "Permission presets:") + "\n");
-              for (const option of catalog.options) {
-                out(`  ${paint(ansi.cyan, option.value.padEnd(18))} ${option.name}${option.description ? paint(ansi.dim, ` — ${option.description}`) : ""}\n`);
-              }
-              out(paint(ansi.dim, `  default: ${catalog.defaultPreset}`) + "\n");
-            } else {
+            if (argument !== "") {
               permissionPresets.set(agent.session, argument);
-              out(paint(ansi.green, `  ✓ permissions: ${argument} (applies to the next tool call)\n`));
+              out(paint(ansi.green, `  ✓ permission mode: ${sanitize(argument)}\n`));
+              continue;
+            }
+            const catalog = permissionPresets.catalog();
+            const options = catalog.options.map((option) => ({
+              label: option.value === catalog.defaultPreset ? `${option.value} (default)` : option.value,
+              description: option.description || option.name,
+              value: option.value,
+            }));
+            const initial = Math.max(0, options.findIndex((option) => option.value === currentPermission()));
+            const chosen = await selectOption("Permission mode", options, initial);
+            if (chosen !== null) {
+              permissionPresets.set(agent.session, chosen);
+              out(paint(ansi.green, `  ✓ permission mode: ${sanitize(chosen)}\n`));
             }
           } catch (error) {
-            out(paint(ansi.red, `  ✘ ${describeError(error)}\n`));
+            out(paint(ansi.red, `  ✘ ${sanitize(describeError(error))}\n`));
           }
           continue;
         }