chainlesschain 0.162.67 → 0.162.68

package/src/repl/agent-repl.js

@@ -778,6 +778,34 @@ export async function startAgentRepl(options = {}) {
     options.vimMode === true || process.env.CC_VIM === "1" ? true : false;
   let _vim = null;
 
+  // Color theme (Claude-Code `/theme` parity). Capture chalk's auto-detected
+  // level BEFORE any theme touches it so `mono`→level 0 stays reversible, then
+  // apply the persisted theme (config `cli.theme`). `mono` strips all color;
+  // `light` uses a blue prompt accent. Switchable at runtime via `/theme`.
+  const {
+    DEFAULT_THEME,
+    resolveTheme,
+    promptAccent,
+    applyThemeChalk,
+    renderThemeList,
+    listThemeNames,
+  } = await import("./repl-theme.js");
+  const _chalkBaselineLevel = chalk.level;
+  let _theme = DEFAULT_THEME;
+  try {
+    const { getConfigValue } = await import("../lib/config-manager.js");
+    _theme = resolveTheme(getConfigValue("cli.theme")) || DEFAULT_THEME;
+  } catch (_e) {
+    /* config optional — keep default */
+  }
+  applyThemeChalk(_theme, chalk, _chalkBaselineLevel);
+  const themedPrompt = (text) => {
+    const a = promptAccent(_theme);
+    if (a === "blue") return chalk.blue(text);
+    if (a === "green") return chalk.green(text);
+    return text;
+  };
+
   const getPrompt = () => {
     // Mode indicator first so it survives the plan-mode prompt variants.
     const vim = _vimEnabled
@@ -793,7 +821,7 @@ export async function startAgentRepl(options = {}) {
       }
       return vim + chalk.yellow("[plan] > ");
     }
-    return vim + chalk.green("> ");
+    return vim + themedPrompt("> ");
   };
 
   // `@` tab-completion (Claude-Code @-mention parity): filesystem paths +
@@ -810,6 +838,7 @@ export async function startAgentRepl(options = {}) {
       "/compact",
       "/config",
       "/context",
+      "/copy",
       "/cost",
       "/cowork",
       "/doctor",
@@ -828,6 +857,7 @@ export async function startAgentRepl(options = {}) {
       "/quit",
       "/reindex",
       "/reload-skills",
+      "/review",
       "/rewind",
       "/search",
       "/session",
@@ -838,6 +868,7 @@ export async function startAgentRepl(options = {}) {
       "/task",
       "/tasks",
       "/terminal-setup",
+      "/theme",
       "/vim",
     ],
     getIdeOpenFiles: async () => {
@@ -1187,6 +1218,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/statusline")} Context-usage line on/off (/statusline [on|off])`,
       );
+      logger.log(
+        `  ${chalk.cyan("/theme")}      Color theme (/theme <auto|dark|light|mono>; mono = no color)`,
+      );
       logger.log(
         `  ${chalk.cyan("/config")}     Effective config (provider/model, keys masked)`,
       );
@@ -1199,6 +1233,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/context")}    Live context-window usage by role`,
       );
+      logger.log(
+        `  ${chalk.cyan("/copy")}       Copy last response to clipboard (/copy code → last code block)`,
+      );
       logger.log(
         `  ${chalk.cyan("/cost")}       Session token spend + estimated $ (per model & category)`,
       );
@@ -1217,6 +1254,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/reload-skills")} Re-scan skill layers without restarting`,
       );
+      logger.log(
+        `  ${chalk.cyan("/review")}     Diff-first code review (/review [high] [--security|--simplify] [--fix])`,
+      );
       logger.log(
         `  ${chalk.cyan("/compact")}    Smart compact (importance-based)`,
       );
@@ -1439,6 +1479,39 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/theme` — color theme (Claude-Code parity). `mono` strips all color;
+    // `light` uses a blue prompt accent. Persisted to config `cli.theme`.
+    if (trimmed === "/theme" || trimmed.startsWith("/theme ")) {
+      const arg = trimmed.slice("/theme".length).trim();
+      if (!arg) {
+        logger.log("\n" + renderThemeList(_theme) + "\n");
+        prompt();
+        return;
+      }
+      const next = resolveTheme(arg);
+      if (!next) {
+        logger.error(
+          chalk.red(
+            `Unknown theme "${arg}". Available: ${listThemeNames().join(", ")}`,
+          ),
+        );
+        prompt();
+        return;
+      }
+      _theme = next;
+      applyThemeChalk(_theme, chalk, _chalkBaselineLevel);
+      try {
+        const { setConfigValue } = await import("../lib/config-manager.js");
+        setConfigValue("cli.theme", _theme);
+      } catch (_e) {
+        /* persistence is best-effort */
+      }
+      rl.setPrompt(getPrompt());
+      logger.log(chalk.gray(`Theme set to ${_theme}.`));
+      prompt();
+      return;
+    }
+
     if (trimmed === "/vim" || trimmed.startsWith("/vim ")) {
       const arg = trimmed.slice("/vim".length).trim().toLowerCase();
       const turnOn = arg === "on" || (arg === "" && !_vimEnabled);
@@ -1793,6 +1866,50 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/review` — diff-first code review of your changes (Claude-Code
+    // /code-review parity). Reuses the `cc review` machinery: collects the git
+    // diff and runs ONE focused agent turn. Read-only by default; `--fix`
+    // applies reversible (auto-checkpointed) edits. Runs against the current
+    // cwd so it follows `/cd`, using this session's provider/model.
+    if (trimmed === "/review" || trimmed.startsWith("/review ")) {
+      const rest = trimmed.slice("/review".length).trim();
+      const { parseReviewReplArgs, describeReviewArgs } =
+        await import("./review-args.js");
+      const { opts: reviewOpts, errors } = parseReviewReplArgs(rest);
+      if (errors.length) {
+        for (const e of errors) logger.error(chalk.red(`/review: ${e}`));
+        logger.log(
+          chalk.gray(
+            "Usage: /review [low|medium|high] [--security|--simplify] " +
+              "[--fix] [--staged|--base <ref>|--range <A..B>]",
+          ),
+        );
+        prompt();
+        return;
+      }
+      try {
+        const { runReview } = await import("../commands/review.js");
+        logger.info(chalk.gray(`Reviewing ${describeReviewArgs(reviewOpts)}`));
+        const result = await runReview(
+          {
+            ...reviewOpts,
+            provider,
+            model,
+            cwd: process.cwd(),
+            outputFormat: "text",
+          },
+          {},
+        );
+        if (result && result.empty) {
+          logger.log(chalk.gray("No changes to review."));
+        }
+      } catch (err) {
+        logger.error(chalk.red(`/review failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
     if (trimmed === "/reindex") {
       if (contextEngine) {
         contextEngine.reindexNotes();
@@ -2573,6 +2690,55 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/copy` — copy the last assistant response to the system clipboard
+    // (Claude-Code /copy parity). `/copy code` copies the last fenced code block.
+    if (trimmed === "/copy" || trimmed.startsWith("/copy ")) {
+      const arg = trimmed.slice("/copy".length).trim().toLowerCase();
+      const { lastAssistantText, lastCodeBlock, copyToClipboard } =
+        await import("./clipboard-copy.js");
+      const full = lastAssistantText(messages);
+      if (!full) {
+        logger.log(
+          chalk.gray(
+            "Nothing to copy yet — no assistant response in this session.",
+          ),
+        );
+        prompt();
+        return;
+      }
+      let payload = full;
+      let what = "last response";
+      if (arg === "code") {
+        const block = lastCodeBlock(full);
+        if (!block) {
+          logger.log(
+            chalk.gray("No fenced code block in the last response."),
+          );
+          prompt();
+          return;
+        }
+        payload = block;
+        what = "last code block";
+      }
+      const res = copyToClipboard(payload);
+      if (res.ok) {
+        logger.log(
+          chalk.gray(
+            `Copied ${what} to clipboard (${payload.length} chars, ${res.tool}).`,
+          ),
+        );
+      } else {
+        logger.error(chalk.red(`/copy failed: ${res.error}`));
+        logger.log(
+          chalk.gray(
+            "Install a clipboard tool (Linux: wl-copy / xclip / xsel).",
+          ),
+        );
+      }
+      prompt();
+      return;
+    }
+
     // `/ide` — IDE bridge connection status (Claude-Code parity): which editor
     // is connected, its tools, or why discovery came up empty.
     if (trimmed === "/ide" || trimmed === "/ide ") {

package/src/repl/clipboard-copy.js

@@ -0,0 +1,119 @@
+/**
+ * REPL `/copy` — copy the last assistant response to the system clipboard
+ * (Claude-Code `/copy` parity). Pure text extraction + a thin, cross-platform
+ * spawn wrapper. The pure parts are unit-tested; real clipboard I/O is
+ * environment-dependent and exercised through an injected spawnSync.
+ */
+import { spawnSync as _spawnSync } from "node:child_process";
+
+/** Flatten a message's content (string | content-parts[]) to plain text. Pure. */
+export function messageText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((p) => (p && typeof p.text === "string" ? p.text : ""))
+      .join("");
+  }
+  return "";
+}
+
+/**
+ * Find the last assistant message that has non-empty text. Pure.
+ * @returns {string|null}
+ */
+export function lastAssistantText(messages) {
+  if (!Array.isArray(messages)) return null;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (!m || m.role !== "assistant") continue;
+    const t = messageText(m.content).trim();
+    if (t) return t;
+  }
+  return null;
+}
+
+/**
+ * Extract the body of the LAST fenced code block in markdown text. Pure.
+ * @returns {string|null}
+ */
+export function lastCodeBlock(text) {
+  if (!text) return null;
+  const re = /```[^\n]*\n([\s\S]*?)```/g;
+  let m;
+  let last = null;
+  while ((m = re.exec(text)) !== null) last = m[1];
+  return last != null ? last.replace(/\n$/, "") : null;
+}
+
+/**
+ * Ordered list of clipboard-write commands to try for a platform. Pure.
+ * All read the payload from stdin. On Windows we force UTF-8 input decoding so
+ * non-ASCII content is not mangled by the console code page (clip.exe is the
+ * ASCII-safe fallback).
+ * @returns {{cmd:string,args:string[]}[]}
+ */
+export function clipboardCommands(platform = process.platform) {
+  if (platform === "win32") {
+    return [
+      {
+        cmd: "powershell",
+        args: [
+          "-NoProfile",
+          "-Command",
+          "[Console]::InputEncoding=[Text.Encoding]::UTF8; " +
+            "Set-Clipboard -Value ([Console]::In.ReadToEnd())",
+        ],
+      },
+      { cmd: "clip", args: [] },
+    ];
+  }
+  if (platform === "darwin") {
+    return [{ cmd: "pbcopy", args: [] }];
+  }
+  // Linux / other Unix — Wayland first, then X selections.
+  return [
+    { cmd: "wl-copy", args: [] },
+    { cmd: "xclip", args: ["-selection", "clipboard"] },
+    { cmd: "xsel", args: ["--clipboard", "--input"] },
+  ];
+}
+
+const _deps = { spawnSync: _spawnSync };
+
+/**
+ * Write text to the system clipboard, trying each platform candidate in order
+ * until one succeeds. Deps injected for tests.
+ * @returns {{ok:boolean, tool?:string, error?:string}}
+ */
+export function copyToClipboard(text, { platform, spawnSync } = {}) {
+  const spawn = spawnSync || _deps.spawnSync;
+  const cmds = clipboardCommands(platform || process.platform);
+  let lastErr = "no clipboard tool available";
+  for (const { cmd, args } of cmds) {
+    let res;
+    try {
+      res = spawn(cmd, args, {
+        input: text,
+        encoding: "utf-8",
+        windowsHide: true,
+      });
+    } catch (e) {
+      lastErr = e.message;
+      continue;
+    }
+    if (!res) {
+      lastErr = `${cmd}: no result`;
+      continue;
+    }
+    if (res.error) {
+      lastErr = res.error.message;
+      continue;
+    }
+    if (res.status === 0) return { ok: true, tool: cmd };
+    lastErr =
+      (res.stderr || "").toString().trim() || `${cmd} exited ${res.status}`;
+  }
+  return { ok: false, error: lastErr };
+}
+
+export { _deps };

package/src/repl/repl-theme.js

@@ -0,0 +1,77 @@
+/**
+ * REPL `/theme` — color theme selection for the agent REPL (Claude-Code
+ * `/theme` parity). cc's REPL paints with chalk directly rather than a
+ * full-screen TUI, so a theme controls two observable things:
+ *   (a) whether color is emitted at all — `mono` strips ALL color by dropping
+ *       chalk's level to 0 (useful on terminals where the palette is unreadable
+ *       or when capturing plain output);
+ *   (b) the accent color of the prompt — `light` uses blue (green is hard to
+ *       read on light backgrounds), `dark`/`auto` use green.
+ *
+ * Pure helpers (theme table, resolver, renderer, accent lookup) + a thin chalk
+ * applier that mutates the injected chalk instance's level. Persistence is the
+ * caller's job (config `cli.theme`).
+ */
+
+export const THEMES = Object.freeze({
+  auto: {
+    color: true,
+    prompt: "green",
+    desc: "terminal-detected color, green prompt (default)",
+  },
+  dark: { color: true, prompt: "green", desc: "for dark terminals" },
+  light: {
+    color: true,
+    prompt: "blue",
+    desc: "for light terminals (blue prompt accent)",
+  },
+  mono: { color: false, prompt: "none", desc: "no color — plain text" },
+});
+
+export const DEFAULT_THEME = "auto";
+
+/** Available theme names, in display order. Pure. */
+export function listThemeNames() {
+  return Object.keys(THEMES);
+}
+
+/** Normalize/validate a theme name; returns the canonical name or null. Pure. */
+export function resolveTheme(name) {
+  const n = String(name || "")
+    .toLowerCase()
+    .trim();
+  return Object.prototype.hasOwnProperty.call(THEMES, n) ? n : null;
+}
+
+/** The prompt accent style for a theme: "green" | "blue" | "none". Pure. */
+export function promptAccent(themeName) {
+  const t = THEMES[themeName] || THEMES[DEFAULT_THEME];
+  return t.prompt;
+}
+
+/**
+ * Apply a theme's color level to a chalk instance (side effect on `chalk`).
+ * `baseline` is chalk's auto-detected level captured before any theme was
+ * applied, so switching back to a colored theme restores real color depth.
+ * @returns {number} the resulting chalk level
+ */
+export function applyThemeChalk(themeName, chalk, baseline) {
+  const t = THEMES[themeName] || THEMES[DEFAULT_THEME];
+  if (!t.color) {
+    chalk.level = 0;
+  } else if (baseline != null) {
+    chalk.level = baseline;
+  }
+  return chalk.level;
+}
+
+/** Render the theme list with the active one marked. Pure. */
+export function renderThemeList(active) {
+  const lines = ["Themes:"];
+  for (const [name, t] of Object.entries(THEMES)) {
+    const mark = name === active ? "*" : " ";
+    lines.push(`  ${mark} ${name.padEnd(6)} ${t.desc}`);
+  }
+  lines.push("Usage: /theme <auto|dark|light|mono>");
+  return lines.join("\n");
+}

package/src/repl/review-args.js

@@ -0,0 +1,90 @@
+/**
+ * Parse the inline arguments of the REPL `/review` slash command into the
+ * option shape that `runReview` (commands/review.js) expects. Pure — no I/O —
+ * so it is fully unit-testable.
+ *
+ * Supported forms (a small, useful subset of `cc review`):
+ *   /review                     working tree vs HEAD, bugs + cleanup, medium
+ *   /review high | low | medium effort tier
+ *   /review --security          security-focused lens (/security-review)
+ *   /review --simplify          cleanup-only lens (no bug hunt)
+ *   /review --fix               apply fixes (auto-checkpointed, reversible)
+ *   /review --staged            review staged changes (git diff --cached)
+ *   /review --base <ref>        review this branch vs <ref> (<ref>...HEAD)
+ *   /review --range <A..B>      review an explicit revision range
+ *
+ * @param {string} rest the text after "/review"
+ * @returns {{ opts: object, errors: string[] }}
+ */
+export function parseReviewReplArgs(rest) {
+  const tokens = String(rest || "")
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean);
+
+  const opts = {
+    effort: undefined,
+    security: false,
+    simplify: false,
+    fix: false,
+    staged: false,
+    base: null,
+    range: null,
+  };
+  const errors = [];
+
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    const lower = t.toLowerCase();
+    if (lower === "low" || lower === "medium" || lower === "high") {
+      opts.effort = lower;
+    } else if (t === "--security") {
+      opts.security = true;
+    } else if (t === "--simplify") {
+      opts.simplify = true;
+    } else if (t === "--fix") {
+      opts.fix = true;
+    } else if (t === "--staged") {
+      opts.staged = true;
+    } else if (t === "--base") {
+      const v = tokens[++i];
+      if (!v) errors.push("--base needs a ref (e.g. /review --base main)");
+      else opts.base = v;
+    } else if (t === "--range") {
+      const v = tokens[++i];
+      if (!v) errors.push("--range needs a range (e.g. /review --range A..B)");
+      else opts.range = v;
+    } else if (t === "-e" || t === "--effort") {
+      const v = tokens[++i];
+      const vl = v ? v.toLowerCase() : "";
+      if (vl === "low" || vl === "medium" || vl === "high") opts.effort = vl;
+      else errors.push(`invalid effort "${v}" (expected low|medium|high)`);
+    } else {
+      errors.push(`unknown argument "${t}"`);
+    }
+  }
+
+  if (opts.security && opts.simplify) {
+    errors.push("--security and --simplify are mutually exclusive");
+  }
+
+  return { opts, errors };
+}
+
+/** Short one-line description of the configured review, for a status line. Pure. */
+export function describeReviewArgs(opts = {}) {
+  const lens = opts.security
+    ? "security"
+    : opts.simplify
+      ? "cleanup-only"
+      : "bugs + cleanup";
+  const scope = opts.range
+    ? `range ${opts.range}`
+    : opts.base
+      ? `${opts.base}...HEAD`
+      : opts.staged
+        ? "staged changes"
+        : "working tree vs HEAD";
+  const action = opts.fix ? "applying fixes" : "read-only";
+  return `${scope} · ${opts.effort || "medium"} effort · ${lens} · ${action}`;
+}

package/src/assets/web-panel/assets/devWarning-yudSIew_.js

@@ -1 +0,0 @@
-import{O as r}from"./index-mJP_zO6_.js";const o=((n,a,e)=>{r(n,`[ant-design-vue: ${a}] ${e}`)});export{o as d};

package/src/assets/web-panel/assets/index-BsuHZ7he.js

@@ -1 +0,0 @@
-import{C as o}from"./Col-DTaHrzPc.js";import{U as t}from"./index-mJP_zO6_.js";import"./vendor-BvqAck49.js";import"./index-C-104k0S.js";import"./icons-DP3uiYxy.js";const s=t(o);export{s as default};

package/src/assets/web-panel/assets/index-C5yXj1wd.js

@@ -1 +0,0 @@
-import{A as o}from"./Row-B9q6bn8K.js";import{U as t}from"./index-mJP_zO6_.js";import"./vendor-BvqAck49.js";import"./responsiveObserve-CjuJL75b.js";import"./useFlexGapSupport-DheJEFqe.js";import"./styleChecker-BQGZefM3.js";import"./index-C-104k0S.js";import"./icons-DP3uiYxy.js";const l=t(o);export{l as default};