chainlesschain 0.165.5 → 0.165.8

package/src/repl/agent-repl.js

@@ -119,6 +119,7 @@ import {
 } from "../lib/task-model-selector.js";
 import { runnableTaskModel, hasUsableKey } from "../lib/runnable-provider.js";
 import { CLIPermanentMemory } from "../lib/permanent-memory.js";
+import { resolveClaudeProjectAutoMemory } from "../lib/claude-project-auto-memory.js";
 import { CLIAutonomousAgent, GoalStatus } from "../lib/autonomous-agent.js";
 import {
   estimateMessagesTokens,
@@ -185,6 +186,11 @@ import {
   createPromptInteractionSurface,
   mergeClipboardImageChips,
 } from "./prompt-interactions.js";
+import {
+  isReadlineWordRuboutKey,
+  readlineWordRubout,
+  resolveReplKeybindingFlavor,
+} from "./repl-keybindings.js";
 import { createSystemClipboardImageBinding } from "./clipboard-image.js";
 import {
   buildPermissionPrompt,
@@ -2760,15 +2766,11 @@ export async function runReplStartupBoundary(options, startupDependencies) {
         "CC_REPL_STARTUP_DEPENDENCY_INVALID",
       );
     }
-    const root = openBudgetRoot(
-      leaseSessionId,
-      options.sessionBudgetRoot,
-      {
-        persist: true,
-        signal: combineReplSignals(options.signal, leaseScope.lease.signal),
-        table: options.sessionBudgetRoot.table,
-      },
-    );
+    const root = openBudgetRoot(leaseSessionId, options.sessionBudgetRoot, {
+      persist: true,
+      signal: combineReplSignals(options.signal, leaseScope.lease.signal),
+      table: options.sessionBudgetRoot.table,
+    });
     if (
       root?.enabled !== true ||
       !root.budget ||
@@ -2824,10 +2826,7 @@ export function startReplJsonlSession(
       ...meta,
       ...(observabilityScope != null ? { observabilityScope } : {}),
     });
-    if (
-      requireDurable &&
-      (typeof sessionId !== "string" || !sessionId)
-    ) {
+    if (requireDurable && (typeof sessionId !== "string" || !sessionId)) {
       throw new Error("JSONL session creation returned no durable session id");
     }
     return sessionId || null;
@@ -2847,6 +2846,46 @@ export function startReplJsonlSession(
   }
 }
 
+/**
+ * Resolve the automatic-memory location at the same lifecycle boundary that
+ * opens the durable REPL session. This is intentionally exported as a narrow
+ * test seam; startAgentReplInWorkspaceOwned consumes it below rather than
+ * letting a standalone helper drift away from real session behavior.
+ */
+export function resolveReplAutomaticMemoryPlan(
+  options = {},
+  cwd = process.cwd(),
+) {
+  return resolveClaudeProjectAutoMemory({
+    cwd,
+    launchEnv: options.claudeStorageLaunchEnv || undefined,
+  });
+}
+
+/**
+ * Resolve the concrete permanent-memory backend used by the live REPL. Claude
+ * project mode is deliberately file-only: the legacy bootstrap SQLite DB is
+ * process/global state and would otherwise let project A retrieve facts that
+ * project B summarized. Legacy mode retains its historical DB behavior.
+ */
+export function resolveReplPermanentMemoryStorage(
+  options = {},
+  db = null,
+  cwd = process.cwd(),
+) {
+  const automaticMemory = resolveReplAutomaticMemoryPlan(options, cwd);
+  if (!automaticMemory.enabled) return null;
+  const dataDir = process.env.CHAINLESSCHAIN_DATA_DIR || cwd;
+  return Object.freeze({
+    db: automaticMemory.mode === "project" ? null : db,
+    memoryDir:
+      automaticMemory.mode === "project"
+        ? automaticMemory.memoryDir
+        : path.join(dataDir, "memory"),
+    automaticMemory,
+  });
+}
+
 /** Start the agentic REPL with non-overridable production bindings. */
 export async function startAgentRepl(options = {}) {
   const sessionHostLeaseScope = { lease: null };
@@ -3187,6 +3226,7 @@ async function startAgentReplInWorkspaceOwned(
   let _visionModel;
   let _promptInteractionConfig = {};
   let _persistPromptSuggestionsEnabled = null;
+  let _keybindingFlavor = "classic";
   // Hard stream inactivity timeout override (config.llm.streamStallTimeoutMs,
   // ms): a stream silent that long is aborted + retried instead of hanging.
   // Unset → agent-core's 180s default (matches cc chat/ask). Set to 0 to
@@ -3218,6 +3258,23 @@ async function startAgentReplInWorkspaceOwned(
   } catch {
     /* optional — resolveVisionLlm falls back to DEFAULT_VISION_MODEL */
   }
+  try {
+    const { readStringSetting } = await import("../lib/settings-loader.cjs");
+    const configuredFlavor = readStringSetting("keybindingFlavor", {
+      cwd: process.cwd(),
+      settingsFile: options.settingsFile || null,
+      managedSettingsFile: options.managedSettingsFile || null,
+      onWarn: (message) => logger.warn(message),
+    });
+    const resolvedFlavor = resolveReplKeybindingFlavor(configuredFlavor);
+    _keybindingFlavor = resolvedFlavor.flavor;
+    if (resolvedFlavor.error) {
+      logger.warn(`settings: ${resolvedFlavor.error}; using classic`);
+    }
+  } catch (error) {
+    if (error?.code === "CC_MANAGED_SETTINGS_INVALID") throw error;
+    logger.warn(`settings: could not load keybindingFlavor (${error.message})`);
+  }
   // Extra workspace roots (--add-dir): advertised in the system prompt and
   // spanned by search_files.
   const additionalDirectories = Array.isArray(options.additionalDirectories)
@@ -3328,10 +3385,15 @@ async function startAgentReplInWorkspaceOwned(
   // Initialize permanent memory
   let permanentMemory = null;
   try {
-    const dataDir = process.env.CHAINLESSCHAIN_DATA_DIR || process.cwd();
-    const memoryDir = path.join(dataDir, "memory");
-    permanentMemory = new CLIPermanentMemory({ db, memoryDir });
-    permanentMemory.initialize();
+    const permanentMemoryStorage = resolveReplPermanentMemoryStorage(
+      options,
+      db,
+      process.cwd(),
+    );
+    if (permanentMemoryStorage) {
+      permanentMemory = new CLIPermanentMemory(permanentMemoryStorage);
+      permanentMemory.initialize();
+    }
   } catch (_err) {
     // Non-critical
   }
@@ -3767,7 +3829,13 @@ async function startAgentReplInWorkspaceOwned(
   try {
     const { getSessionManager } =
       await import("../lib/session-core-singletons.js");
-    _sessionMgr = getSessionManager();
+    // Keep durable lifecycle sidecars on the same launch-authoritative Claude
+    // project bucket as the JSONL transcript. Project settings may not switch
+    // this map/path after the REPL has admitted its launch environment.
+    _sessionMgr = getSessionManager({
+      launchEnv: options.claudeStorageLaunchEnv || undefined,
+      cwd: process.cwd(),
+    });
     if (sessionId) {
       if (options.sessionId && !_sessionMgr.has(sessionId)) {
         // Try unparking; no-op if nothing parked with that id
@@ -3815,6 +3883,8 @@ async function startAgentReplInWorkspaceOwned(
       agentSessionId:
         sessionId || `repl-${process.pid}-${Date.now().toString(36)}`,
       isText: false, // the REPL prints its own pairing lines below
+      allowLan: options.remoteControlAllowLan === true,
+      env: process.env,
     });
     _remoteApproval = {
       bridge: started.bridge,
@@ -5201,6 +5271,25 @@ async function startAgentReplInWorkspaceOwned(
         return;
       }
 
+      // 1.875) The opt-in readline flavor makes Ctrl+W a whitespace-delimited
+      // unix-word-rubout. Classic stays byte-identical and lets Node readline
+      // own the chord; Vim NORMAL mode continues to use the existing engine.
+      if (
+        !_turnAbort &&
+        (!_vimEnabled || !_vim) &&
+        _keybindingFlavor === "readline" &&
+        isReadlineWordRuboutKey(_str, k)
+      ) {
+        _consumeReadlineKeypress(key);
+        const next = readlineWordRubout(rl.line, rl.cursor);
+        if (next.changed) {
+          rl.line = next.line;
+          rl.cursor = next.cursor;
+          rl._refreshLine?.();
+        }
+        return;
+      }
+
       // 2) Vim mode: modal editing on the current input line.
       if (_vimEnabled && !_turnAbort) {
         if (!_vim) {
@@ -5625,7 +5714,7 @@ async function startAgentReplInWorkspaceOwned(
         `  ${chalk.cyan("/voice")}      Speech dictation — local-first STT (/voice hold|tap|off)`,
       );
       logger.log(
-        `  ${chalk.cyan("/output-style")} Response persona (/output-style <name|list>; explanatory/learning built-in)`,
+        `  ${chalk.cyan("/output-style")} Response persona (/output-style <name|list>; concise/explanatory/learning built-in)`,
       );
       logger.log(
         `  ${chalk.cyan("/editor")}     Edit a draft prompt in an external editor`,
@@ -6275,6 +6364,73 @@ async function startAgentReplInWorkspaceOwned(
       return;
     }
 
+    // `/spellcheck` uses an installed local dictionary only. It never sends
+    // prompt text to a provider, and fenced code is suppressed by the adapter
+    // before the executable receives it.
+    {
+      const {
+        parseSpellcheckCommand,
+        resolveSpellcheckEnabled,
+        spellcheckText,
+      } = await import("../lib/spellcheck.js");
+      const spellcheck = parseSpellcheckCommand(trimmed);
+      if (spellcheck) {
+        let configured;
+        try {
+          const { getConfigValue } = await import("../lib/config-manager.js");
+          configured = getConfigValue("cli.spellcheck");
+        } catch {
+          configured = undefined;
+        }
+        if (spellcheck.action === "on" || spellcheck.action === "off") {
+          try {
+            const { setConfigValue } = await import("../lib/config-manager.js");
+            setConfigValue("cli.spellcheck", spellcheck.action === "on");
+          } catch {
+            // The current-session diagnostic remains useful if config storage
+            // is unavailable; don't turn a local optional feature into a
+            // REPL failure.
+          }
+          logger.info(
+            `Spellcheck: ${spellcheck.action === "on" ? "enabled" : "disabled"}.`,
+          );
+        } else if (spellcheck.action === "status") {
+          logger.info(
+            `Spellcheck: ${
+              resolveSpellcheckEnabled({
+                config: { cli: { spellcheck: configured } },
+              })
+                ? "enabled"
+                : "disabled"
+            }. ` + "Use /spellcheck <text> to check local prose.",
+          );
+        } else {
+          try {
+            const result = spellcheckText(spellcheck.text, {
+              config: { cli: { spellcheck: configured } },
+            });
+            if (!result.enabled) {
+              logger.info("Spellcheck is disabled.");
+            } else if (!result.available) {
+              logger.info(
+                "No local spellchecker found (aspell, hunspell, or ispell).",
+              );
+            } else if (result.words.length === 0) {
+              logger.info("Spellcheck: no unknown prose words.");
+            } else {
+              logger.info(
+                `Spellcheck (${result.adapter}): ${result.words.join(", ")}`,
+              );
+            }
+          } catch (error) {
+            logger.error(`/spellcheck failed: ${error.message}`);
+          }
+        }
+        prompt();
+        return;
+      }
+    }
+
     // `/tui` — fullscreen no-flicker view (Claude-Code parity). `fullscreen`
     // enters the alternate screen buffer; `default` returns to streaming
     // scrollback. No arg prints the current mode. Persisted to `cli.tuiMode`.

package/src/repl/permission-prompt.js

@@ -14,15 +14,36 @@
  *
  * @returns {string} the prompt header (no styling, no trailing "Proceed?")
  */
+import { normalizePermissionRequest } from "../lib/permission-request.js";
+import { redactSecrets } from "../lib/secret-scan.js";
+
+export function visualizePermissionText(value) {
+  return String(value ?? "").replace(
+    /[\u0000-\u001f\u007f-\u009f\u00ad\u034f\u061c\u115f\u1160\u17b4\u17b5\u180b-\u180f\u200b-\u200f\u202a-\u202e\u2060-\u206f\u3164\ufeff\uffa0]/gu,
+    (character) => {
+      if (character === "\t") return "<TAB>";
+      if (character === "\n") return "<LF>";
+      if (character === "\r") return "<CR>";
+      return `<U+${character.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}>`;
+    },
+  );
+}
+
 export function buildPermissionPrompt({ tool, args, rule, reason } = {}) {
-  const detail = args?.command
-    ? ` ${args.command}`
-    : args?.path
-      ? ` ${args.path}`
-      : "";
-  if (rule) return `[Permission] rule "${rule}" asks before ${tool}:${detail}`;
-  if (reason) return `[Permission] ${reason}`;
-  return `[Permission] confirm ${tool}:${detail}`;
+  const request = normalizePermissionRequest({ tool, args });
+  const visibleTool = visualizePermissionText(request.tool);
+  const rawDetail = request.detail;
+  const visibleDetail = visualizePermissionText(redactSecrets(rawDetail));
+  const detail = rawDetail ? ` ${visibleDetail}` : "";
+  if (rule) {
+    return `[Permission] rule "${visualizePermissionText(redactSecrets(String(rule)))}" asks before ${visibleTool}:${detail}`;
+  }
+  if (reason) {
+    const reasonText = String(reason);
+    const missingTarget = rawDetail && !reasonText.includes(String(rawDetail));
+    return `[Permission] ${visualizePermissionText(redactSecrets(reasonText))}${missingTarget ? `:${detail}` : ""}`;
+  }
+  return `[Permission] confirm ${visibleTool}:${detail}`;
 }
 
 /**

package/src/repl/repl-keybindings.js

@@ -1,5 +1,60 @@
 /** Declarative, validated keybindings for interactive prompt actions. */
 
+export const DEFAULT_REPL_KEYBINDING_FLAVOR = "classic";
+export const REPL_KEYBINDING_FLAVORS = Object.freeze([
+  DEFAULT_REPL_KEYBINDING_FLAVOR,
+  "readline",
+]);
+
+/**
+ * Resolve the prompt editing flavor. Unknown values stay on the compatible
+ * classic behavior and include a diagnostic for the caller to surface.
+ */
+export function resolveReplKeybindingFlavor(value) {
+  if (value == null || String(value).trim() === "") {
+    return { flavor: DEFAULT_REPL_KEYBINDING_FLAVOR, error: null };
+  }
+  const flavor = String(value).trim().toLowerCase();
+  if (REPL_KEYBINDING_FLAVORS.includes(flavor)) {
+    return { flavor, error: null };
+  }
+  return {
+    flavor: DEFAULT_REPL_KEYBINDING_FLAVOR,
+    error: `keybindingFlavor must be classic or readline (got "${String(value)}")`,
+  };
+}
+
+/** True for the terminal Ctrl+W chord used by readline's unix-word-rubout. */
+export function isReadlineWordRuboutKey(input, key = {}) {
+  if (key.meta || key.alt || key.shift) return false;
+  const name = String(key.name || "").toLowerCase();
+  return (
+    key.ctrl === true &&
+    (name === "w" || input === "\u0017" || key.sequence === "\u0017")
+  );
+}
+
+/**
+ * Delete the token immediately left of the cursor using whitespace-only word
+ * boundaries. This intentionally treats a full path as one token, unlike the
+ * classic path-segment behavior. Text right of the cursor is preserved.
+ */
+export function readlineWordRubout(line, cursor) {
+  const text = String(line || "");
+  const point = Math.max(
+    0,
+    Math.min(Number.isInteger(cursor) ? cursor : text.length, text.length),
+  );
+  let start = point;
+  while (start > 0 && /\s/u.test(text[start - 1])) start -= 1;
+  while (start > 0 && !/\s/u.test(text[start - 1])) start -= 1;
+  return {
+    line: text.slice(0, start) + text.slice(point),
+    cursor: start,
+    changed: start !== point,
+  };
+}
+
 export const REPL_KEYBINDING_ACTIONS = Object.freeze([
   "prompt.edit",
   "prompt.stash",