chainlesschain 0.162.130 → 0.162.132

package/src/repl/agent-repl.js

@@ -686,7 +686,9 @@ export async function startAgentRepl(options = {}) {
   // --system-prompt replaces the built-in prompt; --append-system-prompt
   // extends it (parity with the headless runners). The base is kept so an
   // output-style persona can be swapped in/out at runtime via /output-style.
-  const _replBaseSystem = composeSystemPrompt(
+  // `let` (not const): /add-dir rebuilds this mid-session to re-advertise the
+  // updated working roots; output-style swaps also read it live.
+  let _replBaseSystem = composeSystemPrompt(
     buildSystemPrompt(process.cwd(), { additionalDirectories }),
     {
       systemPrompt: options.systemPrompt,
@@ -1035,6 +1037,8 @@ export async function startAgentRepl(options = {}) {
     // so it follows `/cd` mid-session.
     // Keep in sync with the rl.on("line") handlers + /help below.
     slashCommands: [
+      "/add-dir",
+      "/agents",
       "/auto",
       "/cd",
       "/clear",
@@ -1048,7 +1052,9 @@ export async function startAgentRepl(options = {}) {
       "/exit",
       "/export",
       "/help",
+      "/hooks",
       "/ide",
+      "/init",
       "/mcp",
       "/memory",
       "/microcompact",
@@ -1056,10 +1062,12 @@ export async function startAgentRepl(options = {}) {
       "/output-style",
       "/permissions",
       "/plan",
+      "/pr-comments",
       "/profile",
       "/provider",
       "/quit",
       "/reindex",
+      "/release-notes",
       "/reload-skills",
       "/review",
       "/rewind",
@@ -1067,6 +1075,7 @@ export async function startAgentRepl(options = {}) {
       "/session",
       "/sessions",
       "/stats",
+      "/status",
       "/statusline",
       "/sub-agents",
       "/task",
@@ -1074,6 +1083,7 @@ export async function startAgentRepl(options = {}) {
       "/terminal-setup",
       "/theme",
       "/think",
+      "/todos",
       "/ultrathink",
       "/vim",
     ],
@@ -1526,9 +1536,18 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/doctor")}     Session health check (provider/key/IDE/MCP/hooks)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/status")}     Environment snapshot (version/model/session/cwd/roots/IDE·MCP·hooks)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/release-notes")} Running version + changelog links + how to upgrade`,
+      );
       logger.log(
         `  ${chalk.cyan("/memory")}     Project-memory files loaded (cc.md hierarchy + rules)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/init")}       Inventory this folder into a cc.md project-memory file (/init [--force])`,
+      );
       logger.log(
         `  ${chalk.cyan("/context")}    Live context-window usage by role`,
       );
@@ -1550,12 +1569,18 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/cd <dir>")}   Change working directory mid-session (completion/memory follow)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/add-dir")}    Add an extra working root (/add-dir <dir>; no arg lists roots)`,
+      );
       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("/pr-comments")} Fetch a GitHub PR's comments and address them (/pr-comments [<n>] [--repo o/r]; needs gh)`,
+      );
       logger.log(
         `  ${chalk.cyan("/compact")}    Smart compact (importance-based)`,
       );
@@ -1596,18 +1621,27 @@ export async function startAgentRepl(options = {}) {
         `  ${chalk.cyan("/plan approve")} Approve and execute the plan`,
       );
       logger.log(`  ${chalk.cyan("/plan reject")}  Reject the plan`);
+      logger.log(
+        `  ${chalk.cyan("/agents")}     Manage sub-agent definitions (/agents [show|new] <name>; cc agents)`,
+      );
       logger.log(
         `  ${chalk.cyan("/sub-agents")}  Show active/completed sub-agents`,
       );
       logger.log(
         `  ${chalk.cyan("/tasks")}      Show background shell tasks (kill <id> · kill-all)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/todos")}      Show the session TODO list (what the agent tracks with todo_write)`,
+      );
       logger.log(
         `  ${chalk.cyan("/ide")}        IDE bridge status (connected editor, tools, or why not)`,
       );
       logger.log(
         `  ${chalk.cyan("/mcp")}        MCP server status + tools (/mcp <name> for one server)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/hooks")}      Loaded .claude/settings.json hooks (cc hook for observe-only DB hooks)`,
+      );
       logger.log(chalk.bold("\nCapabilities:"));
       logger.log("  Read, write, and edit files");
       logger.log("  Run shell commands (git, npm, etc.)");
@@ -1671,6 +1705,192 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/todos` — the session's TODO list (what the agent tracks with the
+    // todo_write tool). Read-only view; the data lives in todo-manager keyed by
+    // sessionId (same store the tool writes). Claude-Code /todos parity.
+    if (trimmed === "/todos" || trimmed === "/todo") {
+      try {
+        const { getTodos } = await import("../lib/todo-manager.js");
+        const { formatTodos } = await import("./todos-status.js");
+        logger.log("\n" + formatTodos(getTodos(sessionId)) + "\n");
+      } catch (err) {
+        logger.error(chalk.red(`/todos failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/hooks` — the decision-capable .claude/settings.json `hooks` block loaded
+    // for this session (PreToolUse/PostToolUse/…). Observe-only DB hooks
+    // (`cc hook add`) are managed via the `cc hook` CLI. Claude-Code /hooks parity.
+    if (trimmed === "/hooks" || trimmed.startsWith("/hooks ")) {
+      try {
+        const { formatSettingsHooks } = await import("./hooks-status.js");
+        logger.log("\n" + formatSettingsHooks(_settingsHooks) + "\n");
+      } catch (err) {
+        logger.error(chalk.red(`/hooks failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/add-dir [dir]` — add an extra working root mid-session (or, with no
+    // arg, list the current roots). The new root is threaded into every
+    // subsequent turn's options.additionalDirectories (so read/search/edit span
+    // it) and re-advertised in the system prompt. Claude-Code /add-dir parity.
+    if (trimmed === "/add-dir" || trimmed.startsWith("/add-dir ")) {
+      const arg = trimmed.slice("/add-dir".length).trim();
+      try {
+        const { resolveAddDir, formatAddDirRoots } =
+          await import("./add-dir.js");
+        if (!arg) {
+          logger.log(
+            "\n" +
+              formatAddDirRoots(process.cwd(), additionalDirectories) +
+              "\n",
+          );
+        } else {
+          const res = resolveAddDir(arg, {
+            cwd: process.cwd(),
+            existing: additionalDirectories,
+          });
+          if (!res.ok) {
+            logger.log(chalk.yellow(`/add-dir: ${res.reason}`));
+          } else if (res.alreadyPresent) {
+            logger.log(chalk.dim(`Already a working root: ${res.dir}`));
+          } else {
+            additionalDirectories.push(res.dir);
+            // Re-advertise the updated roots in the system prompt; keep the
+            // active output-style body layered on top (same as /output-style).
+            _replBaseSystem = composeSystemPrompt(
+              buildSystemPrompt(process.cwd(), { additionalDirectories }),
+              {
+                systemPrompt: options.systemPrompt,
+                appendSystemPrompt: options.appendSystemPrompt,
+              },
+            );
+            messages[0].content = _activeOutputStyle
+              ? `${_replBaseSystem}\n\n${_activeOutputStyle.body}`
+              : _replBaseSystem;
+            logger.log(chalk.green(`Added working root: ${res.dir}`));
+          }
+        }
+      } catch (err) {
+        logger.error(chalk.red(`/add-dir failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/init [--force]` — inventory the current folder into a cc.md
+    // project-memory file (Claude-Code /init parity). Non-interactive: reuses
+    // the same offline census as `cc init`. Loaded as project context next
+    // session (or inspect with /memory).
+    if (trimmed === "/init" || trimmed.startsWith("/init ")) {
+      const force = /(^|\s)(--force|-f)(\s|$)/.test(trimmed);
+      try {
+        const { inventoryProject, renderMemoryFile } =
+          await import("../lib/project-inventory.js");
+        const initCwd = process.cwd();
+        const target = path.join(initCwd, "cc.md");
+        if (fs.existsSync(target) && !force) {
+          logger.log(
+            chalk.yellow(
+              `cc.md already exists at ${target} — /init --force to overwrite.`,
+            ),
+          );
+        } else {
+          const inv = inventoryProject(initCwd);
+          fs.writeFileSync(target, renderMemoryFile(inv), "utf-8");
+          logger.log(chalk.green(`Generated ${target}`));
+          const langs = (inv.languages || [])
+            .slice(0, 5)
+            .map(([l, n]) => `${l} (${n})`)
+            .join(", ");
+          if (langs) logger.log(chalk.dim(`  Languages: ${langs}`));
+          if (inv.packageManager)
+            logger.log(chalk.dim(`  Package manager: ${inv.packageManager}`));
+          if (inv.scripts && inv.scripts.length)
+            logger.log(
+              chalk.dim(`  Scripts documented: ${inv.scripts.length}`),
+            );
+          logger.log(
+            chalk.dim(
+              "  Loaded as project context next session (or /memory to inspect).",
+            ),
+          );
+        }
+      } catch (err) {
+        logger.error(chalk.red(`/init failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/agents [list|show <name>|new <name> …]` — manage sub-agent DEFINITIONS
+    // (.chainlesschain/agents/*.md / .claude/agents/*.md). Mirrors `cc agents`;
+    // distinct from /sub-agents (running instances). Claude-Code /agents parity.
+    if (trimmed === "/agents" || trimmed.startsWith("/agents ")) {
+      try {
+        const { parseAgentsCommand, formatAgentsList, formatAgentDetail } =
+          await import("./agents-status.js");
+        const { discoverAgents, getAgent, scaffoldAgent } =
+          await import("../lib/agents.js");
+        const { listSubAgentProfiles } =
+          await import("../lib/sub-agent-profiles.js");
+        const cmd = parseAgentsCommand(trimmed);
+        if (cmd.action === "help") {
+          logger.log(
+            "Usage: /agents [list] · /agents show <name> · /agents new <name> [--tools a,b] [--claude|--personal] [--description <text>]",
+          );
+        } else if (cmd.action === "list") {
+          logger.log(
+            "\n" +
+              formatAgentsList(
+                discoverAgents(process.cwd()),
+                listSubAgentProfiles(),
+              ) +
+              "\n",
+          );
+        } else if (cmd.action === "show") {
+          if (!cmd.name) {
+            logger.log(chalk.yellow("Usage: /agents show <name>"));
+          } else {
+            const a = getAgent(cmd.name, process.cwd());
+            if (!a) logger.log(chalk.yellow(`No such agent: ${cmd.name}`));
+            else logger.log("\n" + formatAgentDetail(a) + "\n");
+          }
+        } else if (cmd.action === "new") {
+          if (!cmd.name) {
+            logger.log(
+              chalk.yellow("Usage: /agents new <name> [--description <text>]"),
+            );
+          } else {
+            const res = scaffoldAgent({
+              name: cmd.name,
+              description: cmd.description,
+              tools: cmd.tools,
+              location: cmd.location,
+            });
+            if (!res.ok) {
+              logger.log(chalk.yellow(`/agents new: ${res.reason}`));
+            } else {
+              logger.log(chalk.green(`✓ created ${res.file}`));
+              logger.log(
+                chalk.dim(
+                  `  edit it, then spawn it from the agent or run: cc agents run ${res.name} "<task>"`,
+                ),
+              );
+            }
+          }
+        }
+      } catch (err) {
+        logger.error(chalk.red(`/agents failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
     if (trimmed === "/sub-agents" || trimmed === "/subagents") {
       try {
         const { SubAgentRegistry } =
@@ -3057,6 +3277,73 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/status` — concise environment snapshot (version / model / session / cwd
+    // / roots / IDE·MCP·hooks). Lighter than /doctor. Claude-Code /status parity
+    // (minus account/billing, which cc has no notion of).
+    if (trimmed === "/status" || trimmed.startsWith("/status ")) {
+      try {
+        const { VERSION } = await import("../constants.js");
+        const { readDiskVersion } = await import("../lib/version-skew.js");
+        const { ideToolNames } = await import("./ide-status.js");
+        const { formatStatus } = await import("./status-summary.js");
+        const mcpConnected = _adhocMcp?.connected;
+        const mcpCount = Array.isArray(mcpConnected)
+          ? mcpConnected.length
+          : typeof mcpConnected === "number"
+            ? mcpConnected
+            : mcpConnected
+              ? 1
+              : 0;
+        logger.log(
+          "\n" +
+            formatStatus({
+              version: VERSION,
+              installedVersion: readDiskVersion(),
+              node: process.version,
+              platform: `${process.platform}-${process.arch}`,
+              provider,
+              model: _curModel || model,
+              sessionId,
+              messageCount: messages.length,
+              cwd: process.cwd(),
+              extraRoots: additionalDirectories.length,
+              ideConnected: ideToolNames(_adhocMcp).length > 0,
+              mcpServers: mcpCount,
+              hookEvents: _settingsHooks
+                ? Object.keys(_settingsHooks).length
+                : 0,
+            }) +
+            "\n",
+        );
+      } catch (err) {
+        logger.error(chalk.red(`/status failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/release-notes` — running version + a pointer to the full changelog +
+    // how to upgrade. Claude-Code /release-notes parity.
+    if (trimmed === "/release-notes" || trimmed.startsWith("/release-notes ")) {
+      try {
+        const { VERSION } = await import("../constants.js");
+        const { readDiskVersion } = await import("../lib/version-skew.js");
+        const { formatReleaseNotes } = await import("./release-notes.js");
+        logger.log(
+          "\n" +
+            formatReleaseNotes({
+              version: VERSION,
+              installedVersion: readDiskVersion(),
+            }) +
+            "\n",
+        );
+      } catch (err) {
+        logger.error(chalk.red(`/release-notes failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
     // `/export [path]` — dump the live conversation to a Markdown transcript
     // (Claude-Code parity). Distinct from `cc export` (knowledge base). Captures
     // exactly what's in context now, persisted or not.
@@ -3275,6 +3562,29 @@ export async function startAgentRepl(options = {}) {
         return;
       }
     }
+
+    // `/pr-comments [<n>|<url>] [--repo owner/name]` (Claude-Code parity):
+    // fetch a GitHub PR's reviews + conversation + inline comments via `gh` and
+    // feed them as this turn's input so the agent can address the feedback.
+    if (promptText.startsWith("/pr-comments")) {
+      try {
+        const { expandPrComments } = await import("./pr-comments.js");
+        const res = await expandPrComments(promptText);
+        if (res != null) {
+          promptText = res.text;
+          logger.log(
+            chalk.gray(
+              `[pr] PR #${res.number}: ${res.count} comment(s) fetched`,
+            ),
+          );
+        }
+      } catch (err) {
+        logger.info(chalk.yellow(`[pr-comments] ${err.message}`));
+        prompt();
+        return;
+      }
+    }
+
     try {
       const macro = await resolveSlashMacro(trimmed, { cwd: process.cwd() });
       if (macro.matched) {

package/src/repl/agents-status.js

@@ -0,0 +1,122 @@
+/**
+ * `/agents` REPL command (Claude-Code parity) — manage user-defined sub-agent
+ * DEFINITIONS (`.chainlesschain/agents/*.md` / `.claude/agents/*.md`) from
+ * inside an interactive session: list / show / new. Mirrors the `cc agents`
+ * CLI; the discovery + scaffold live in lib/agents.js (single source of truth),
+ * this module is the pure arg-parse + render layer. Distinct from `/sub-agents`
+ * which shows running instances.
+ */
+
+function stripQuotes(s) {
+  const t = String(s || "").trim();
+  if (
+    (t.startsWith('"') && t.endsWith('"')) ||
+    (t.startsWith("'") && t.endsWith("'"))
+  ) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+
+/**
+ * Parse a `/agents …` line.
+ * Forms: `/agents [list]`, `/agents show <name>`, `/agents <name>` (= show),
+ *        `/agents new <name> [--tools a,b] [--claude|--personal] [--description <text>]`,
+ *        `/agents help`.
+ * @returns {{action:string, name?:string|null, description?:string|null,
+ *            tools?:string|null, location?:string}}
+ */
+export function parseAgentsCommand(line) {
+  let rest = String(line || "")
+    .trim()
+    .replace(/^\/agents\b/, "")
+    .trim();
+
+  let location = "project";
+  if (/(^|\s)--personal(\s|$)/.test(rest)) {
+    location = "personal";
+    rest = rest.replace(/(^|\s)--personal(\s|$)/, " ");
+  }
+  if (/(^|\s)--claude(\s|$)/.test(rest)) {
+    if (location !== "personal") location = "claude";
+    rest = rest.replace(/(^|\s)--claude(\s|$)/, " ");
+  }
+
+  let tools = null;
+  const tm = rest.match(/(^|\s)--tools\s+("[^"]*"|'[^']*'|\S+)/);
+  if (tm) {
+    tools = stripQuotes(tm[2]);
+    rest = rest.replace(tm[0], " ");
+  }
+
+  // --description takes the rest of the line (may contain spaces).
+  let description = null;
+  const dm = rest.match(/(^|\s)--description\s+(.*)$/);
+  if (dm) {
+    description = stripQuotes(dm[2].trim()) || null;
+    rest = rest.slice(0, dm.index).trim();
+  }
+
+  rest = rest.replace(/\s+/g, " ").trim();
+  const tokens = rest.length ? rest.split(" ") : [];
+  const first = tokens[0] || "";
+
+  if (!first || first === "list" || first === "ls") return { action: "list" };
+  if (first === "help") return { action: "help" };
+  if (first === "show") return { action: "show", name: tokens[1] || null };
+  if (first === "new") {
+    return {
+      action: "new",
+      name: tokens[1] || null,
+      description,
+      tools,
+      location,
+    };
+  }
+  // A bare token is treated as a name to show.
+  return { action: "show", name: first };
+}
+
+/** Render the list of agent definitions + built-in profiles. */
+export function formatAgentsList(agents, profiles) {
+  const list = Array.isArray(agents) ? agents : [];
+  const profs = Array.isArray(profiles) ? profiles : [];
+  const lines = [
+    `Agent definitions (${list.length}) — .chainlesschain/agents · .claude/agents · ~/.claude/agents:`,
+  ];
+  if (list.length === 0) {
+    lines.push("  (none — create one with /agents new <name>)");
+  } else {
+    for (const a of list) {
+      const tools = a.tools ? a.tools.join(",") : "(all)";
+      lines.push(`  ${a.name}  [${a.scope}]  ${a.description || ""}`.trimEnd());
+      lines.push(`    tools: ${tools}${a.model ? ` · model: ${a.model}` : ""}`);
+    }
+  }
+  if (profs.length) {
+    lines.push("", "Built-in profiles (spawn_sub_agent profile:):");
+    for (const p of profs) {
+      lines.push(`  ${p.name} — ${p.shortDescription || ""}`.trimEnd());
+    }
+  }
+  lines.push(
+    "",
+    'Manage: /agents show <name> · /agents new <name> · run via `cc agents run <name> "<task>"`',
+  );
+  return lines.join("\n");
+}
+
+/** Render one agent definition's metadata + system prompt. */
+export function formatAgentDetail(agent) {
+  if (!agent) return null;
+  const tools = agent.tools ? agent.tools.join(",") : "(all)";
+  const lines = [
+    `${agent.name}  [${agent.scope}]`,
+    agent.description ? `  ${agent.description}` : null,
+    `  tools: ${tools}${agent.model ? ` · model: ${agent.model}` : ""}`,
+    `  file: ${agent.file}`,
+    "",
+    agent.systemPrompt || "(empty system prompt)",
+  ].filter((l) => l != null);
+  return lines.join("\n");
+}

package/src/repl/hooks-status.js

@@ -0,0 +1,67 @@
+/**
+ * Pure renderer for the `/hooks` REPL command — a user-facing view of the
+ * decision-capable `.claude/settings.json` `hooks` block loaded for this
+ * session. The data comes from settings-hooks' loadHooks(); this module only
+ * formats it, so it stays deterministic and unit-testable.
+ *
+ * Mirrors Claude Code's /hooks view. The separate observe-only DB hooks
+ * (`cc hook add`) are not part of this block — a pointer to `cc hook list` is
+ * shown instead.
+ *
+ * Input shape (the settings.json `hooks` object):
+ *   { <Event>: [ { matcher, hooks: [ { type, command, timeout } ] } ], ... }
+ *   Event ∈ PreToolUse | PostToolUse | UserPromptSubmit | SessionStart |
+ *           SessionEnd | Stop | PreCompact | SubagentStop | Notification
+ */
+
+/** One hook command rendered to a single line. */
+function fmtHook(h) {
+  if (!h || typeof h !== "object") return "    (invalid hook)";
+  const cmd =
+    h.type === "command"
+      ? String(h.command || "").trim() || "(no command)"
+      : `(${h.type || "unknown"} hook)`;
+  const to =
+    h.timeout != null && Number.isFinite(Number(h.timeout))
+      ? ` [timeout ${Number(h.timeout)}s]`
+      : "";
+  return `      ${cmd}${to}`;
+}
+
+/**
+ * Render the loaded settings.json hooks block as a plain-text block.
+ * @param {object|null} hooks  the merged `hooks` object, or null when none
+ */
+export function formatSettingsHooks(hooks) {
+  const events = hooks && typeof hooks === "object" ? Object.keys(hooks) : [];
+  if (events.length === 0) {
+    return (
+      "No settings.json hooks loaded.\n" +
+      "  Define a `hooks` block in .claude/settings.json (PreToolUse / " +
+      "PostToolUse / UserPromptSubmit / SessionStart / Stop / PreCompact / …).\n" +
+      "  Observe-only DB hooks: cc hook list"
+    );
+  }
+  let total = 0;
+  const body = [];
+  for (const ev of events) {
+    const entries = Array.isArray(hooks[ev]) ? hooks[ev] : [];
+    body.push(`  ${ev}:`);
+    for (const entry of entries) {
+      const matcher = entry?.matcher ? String(entry.matcher) : "*";
+      body.push(`    matcher ${matcher}`);
+      const hs = Array.isArray(entry?.hooks) ? entry.hooks : [];
+      for (const h of hs) {
+        total += 1;
+        body.push(fmtHook(h));
+      }
+    }
+  }
+  const header = `settings.json hooks (decision-capable, ${total} command(s) across ${events.length} event(s)):`;
+  return (
+    header +
+    "\n" +
+    body.join("\n") +
+    "\n  Test a hook: cc hook test <event> <tool> --run · observe-only DB hooks: cc hook list"
+  );
+}