chainlesschain 0.162.32 → 0.162.34

package/src/lib/slash-commands.js

@@ -0,0 +1,197 @@
+/**
+ * slash-commands — user-defined command templates (Claude-Code parity).
+ *
+ * Markdown files under `.claude/commands/` (project) or `~/.claude/commands/`
+ * (personal) become reusable command macros. Distinct from skills (skills are
+ * AI-invoked capability bundles; these are user-authored prompt macros you run
+ * explicitly). A file `git/commit.md` is the command `git:commit`.
+ *
+ * Frontmatter (all optional): `description`, `argument-hint`, `allowed-tools`,
+ * `model`. Body is the prompt template, with substitutions applied at run time:
+ *   $ARGUMENTS   → all args joined by space
+ *   $1 $2 … $9   → positional args (missing → empty string)
+ *   !`<cmd>`     → run <cmd> in a shell, splice in its stdout (bang exec)
+ *   @path        → splice in file/dir contents (via file-ref-expander)
+ *
+ * Project scope shadows personal scope on a name clash. Discovery + parse +
+ * expand are pure (inject fs/exec/cwd) so the whole thing is unit-testable.
+ */
+
+import fsDefault from "node:fs";
+import pathDefault from "node:path";
+import { homedir } from "node:os";
+import { execSync as execSyncDefault } from "node:child_process";
+import yaml from "js-yaml";
+import { expandFileRefs } from "../runtime/file-ref-expander.js";
+
+const _deps = { fs: fsDefault, path: pathDefault, execSync: execSyncDefault };
+
+/**
+ * Split `--- ... ---` YAML frontmatter from the body and camelCase the keys
+ * (so `argument-hint` → `argumentHint`). Self-contained (no skill-loader, whose
+ * import chain drags in heavy native deps). Returns `{ data, body }`.
+ */
+function parseFrontmatter(content) {
+  const text = String(content || "");
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!m) return { data: {}, body: text.trim() };
+  let raw = {};
+  try {
+    raw = yaml.load(m[1]) || {};
+  } catch {
+    raw = {};
+  }
+  const data = {};
+  for (const [k, v] of Object.entries(raw)) {
+    const camel = k.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    data[camel] = v;
+  }
+  return { data, body: (m[2] || "").trim() };
+}
+
+/** Default shell timeout for `!`cmd`` bang execution. */
+export const BANG_TIMEOUT_MS = 10_000;
+
+/**
+ * The directories scanned for command files, project first (it shadows personal
+ * on a name clash). `opts.home` overrides the personal root for tests.
+ */
+export function commandDirs(cwd = process.cwd(), opts = {}) {
+  const path = opts.deps?.path || _deps.path;
+  const home = opts.home || homedir();
+  return [
+    { dir: path.join(cwd, ".claude", "commands"), scope: "project" },
+    { dir: path.join(home, ".claude", "commands"), scope: "personal" },
+  ];
+}
+
+/** Recursively collect `*.md` files under `dir` as `{file, rel}` (rel uses /). */
+function walkMd(dir, { fs, path }, base = dir, acc = []) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return acc;
+  }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      walkMd(full, { fs, path }, base, acc);
+    } else if (e.isFile() && e.name.endsWith(".md")) {
+      const rel = path.relative(base, full).replace(/\\/g, "/");
+      acc.push({ file: full, rel });
+    }
+  }
+  return acc;
+}
+
+/** Command name from a relative path: `git/commit.md` → `git:commit`. */
+function nameFromRel(rel) {
+  return rel.replace(/\.md$/, "").replace(/\//g, ":");
+}
+
+/** Parse one command file into its metadata + body (no expansion yet). */
+export function parseCommandFile(file, scope, opts = {}) {
+  const fs = opts.deps?.fs || _deps.fs;
+  let content;
+  try {
+    content = fs.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+  const { data, body } = parseFrontmatter(content);
+  return {
+    file,
+    scope,
+    description: data.description || "",
+    argumentHint: data.argumentHint || "",
+    allowedTools: data.allowedTools || null,
+    model: data.model || null,
+    body: body || "",
+  };
+}
+
+/**
+ * Discover all commands across both scopes. Project shadows personal by name.
+ * @returns {Array<{name, scope, file, description, argumentHint, allowedTools, model}>}
+ */
+export function discoverCommands(cwd = process.cwd(), opts = {}) {
+  const fs = opts.deps?.fs || _deps.fs;
+  const path = opts.deps?.path || _deps.path;
+  const byName = new Map();
+  // Personal first, then project — so project overwrites on clash.
+  const dirs = commandDirs(cwd, opts).reverse();
+  for (const { dir, scope } of dirs) {
+    for (const { file, rel } of walkMd(dir, { fs, path })) {
+      const meta = parseCommandFile(file, scope, opts);
+      if (!meta) continue;
+      const name = nameFromRel(rel);
+      byName.set(name, { name, ...meta });
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** Look up one command by name (accepts `git:commit` or `git/commit`). */
+export function getCommand(name, cwd = process.cwd(), opts = {}) {
+  const wanted = String(name || "")
+    .replace(/^\//, "")
+    .replace(/\//g, ":");
+  return discoverCommands(cwd, opts).find((c) => c.name === wanted) || null;
+}
+
+/** Substitute $ARGUMENTS and $1..$9 in `text`. */
+export function substituteArgs(text, args = []) {
+  const list = Array.isArray(args) ? args : [];
+  let out = text.replace(/\$ARGUMENTS/g, list.join(" "));
+  out = out.replace(/\$([1-9])/g, (_, d) => list[Number(d) - 1] ?? "");
+  return out;
+}
+
+/** Run every `!`cmd`` and replace it with the command's stdout (best-effort). */
+function runBangs(text, { cwd, execSync }) {
+  return text.replace(/!`([^`]+)`/g, (_, cmd) => {
+    try {
+      const out = execSync(cmd, {
+        cwd,
+        encoding: "utf-8",
+        timeout: BANG_TIMEOUT_MS,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      return String(out).trim();
+    } catch (err) {
+      return `[command failed: ${cmd} — ${err.message?.split("\n")[0] || err}]`;
+    }
+  });
+}
+
+/**
+ * Expand a command into a final prompt string.
+ *   1. $ARGUMENTS / $1..$9 substitution
+ *   2. !`cmd` bang execution (skipped when opts.allowBang === false)
+ *   3. @path file references (via file-ref-expander)
+ *
+ * @param {object} command  output of getCommand/parseCommandFile (needs .body)
+ * @param {string[]} args
+ * @param {object} [opts] { cwd, allowBang, deps:{ execSync } }
+ * @returns {{ prompt:string, warnings:string[] }}
+ */
+export function expandCommand(command, args = [], opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const execSync = opts.deps?.execSync || _deps.execSync;
+  const warnings = [];
+
+  let text = substituteArgs(command.body || "", args);
+
+  if (opts.allowBang !== false) {
+    text = runBangs(text, { cwd, execSync });
+  }
+
+  // @file expansion appends a <referenced-files> block when anything resolves.
+  const expanded = expandFileRefs(text, { cwd });
+  for (const w of expanded.warnings) warnings.push(w);
+
+  return { prompt: expanded.prompt, warnings };
+}
+
+export { _deps };

package/src/repl/agent-repl.js

@@ -58,6 +58,7 @@ import {
 } from "../lib/session-hooks.js";
 import { HookEvents } from "../lib/hook-manager.js";
 import { IterationBudget } from "../lib/iteration-budget.js";
+import { loadMcpConfig } from "../runtime/mcp-config.js";
 import {
   AGENT_TOOLS,
   buildSystemPrompt,
@@ -354,6 +355,10 @@ export async function startAgentRepl(options = {}) {
   // and applies bundle manifest metadata (model/provider override, agentId).
   let _bundleResolved = null;
   let _bundleMcpClient = null;
+  // --mcp-config (interactive parity with headless): ad-hoc MCP servers loaded
+  // for this session via the shared mcp-config engine. Holds {mcpClient,
+  // extraToolDefinitions, externalToolExecutors, externalToolDescriptors}.
+  let _adhocMcp = null;
   if (options.bundlePath) {
     try {
       const { loadBundle } =
@@ -446,6 +451,28 @@ export async function startAgentRepl(options = {}) {
     }
   }
 
+  // --mcp-config: connect ad-hoc MCP servers for this interactive session and
+  // expose their tools to the LLM (Claude-Code parity with headless). Reuses the
+  // shared engine, so tools surface as mcp__<server>__<tool>. Best-effort: a bad
+  // config is reported but never aborts the REPL.
+  if (options.mcpConfig) {
+    try {
+      _adhocMcp = await loadMcpConfig(options.mcpConfig, {
+        writeErr: (s) => process.stderr.write(s),
+      });
+      const toolCount = _adhocMcp.extraToolDefinitions.length;
+      logger.log(
+        chalk.gray(
+          `MCP: ${_adhocMcp.connected.length} server(s), ${toolCount} tool(s) ` +
+            `(mcp__<server>__<tool>)`,
+        ),
+      );
+    } catch (mcpErr) {
+      logger.log(chalk.yellow(`MCP: --mcp-config failed — ${mcpErr.message}`));
+      _adhocMcp = null;
+    }
+  }
+
   // Apply bundle approval policy to this session (after both gate and sessionId are ready)
   if (_bundleResolved?.approvalPolicy?.default && _approvalGate && sessionId) {
     try {
@@ -1567,7 +1594,12 @@ export async function startAgentRepl(options = {}) {
         checkpointSession: sessionId,
         prepareCall,
         approvalGate: _approvalGate,
-        mcpClient: _bundleMcpClient || undefined,
+        // MCP: --mcp-config (ad-hoc) wins; bundle MCP is the fallback. The 3
+        // tool channels expose --mcp-config servers' tools to the LLM directly.
+        mcpClient: _adhocMcp?.mcpClient || _bundleMcpClient || undefined,
+        extraToolDefinitions: _adhocMcp?.extraToolDefinitions,
+        externalToolExecutors: _adhocMcp?.externalToolExecutors,
+        externalToolDescriptors: _adhocMcp?.externalToolDescriptors,
         chatFn: _fallbackChatFn,
       });
 
@@ -1778,6 +1810,15 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
+    // Disconnect ad-hoc (--mcp-config) MCP servers
+    if (_adhocMcp?.mcpClient) {
+      try {
+        await _adhocMcp.mcpClient.disconnectAll();
+      } catch (_e) {
+        // Non-critical
+      }
+    }
+
     // Shutdown runtime
     try {
       await shutdown();

package/src/runtime/agent-core.js

@@ -1729,6 +1729,19 @@ export async function chatWithTools(rawMessages, options) {
         ? baseUrl
         : "https://api.anthropic.com/v1";
 
+    // Real token streaming (--include-partial-messages): stream the SSE response
+    // and forward text deltas live, assembling tool_use blocks back into the
+    // same {message, usage} shape the non-streaming path returns.
+    if (typeof options.onToken === "function") {
+      return await _chatAnthropicStreaming(
+        `${url}/messages`,
+        { ...body, stream: true },
+        { "x-api-key": key, "anthropic-version": "2023-06-01" },
+        options.onToken,
+        signal,
+      );
+    }
+
     const response = await fetch(`${url}/messages`, {
       method: "POST",
       headers: {
@@ -1798,6 +1811,27 @@ export async function chatWithTools(rawMessages, options) {
     volcengine: "doubao-seed-1-6-251015",
   };
 
+  // Real token streaming (--include-partial-messages) for every OpenAI-compatible
+  // provider (openai / deepseek / dashscope / mistral / gemini / volcengine):
+  // stream the SSE response, forward content deltas live, and reassemble the
+  // delta-fragmented tool_calls into the standard {message, usage} shape.
+  if (typeof options.onToken === "function") {
+    return await _chatOpenAIStreaming(
+      `${url}/chat/completions`,
+      {
+        model: model || defaultModels[provider] || "gpt-4o-mini",
+        messages,
+        tools,
+        stream: true,
+        stream_options: { include_usage: true },
+      },
+      key,
+      options.onToken,
+      signal,
+      provider,
+    );
+  }
+
   const response = await fetch(`${url}/chat/completions`, {
     method: "POST",
     headers: {
@@ -1934,6 +1968,225 @@ async function _chatOllamaStreaming(apiUrl, body, onToken, signal) {
   return _ollamaFinalize(state);
 }
 
+// ─── Anthropic streaming (SSE → {message, usage}, tool_use reassembled) ──────
+//
+// Anthropic /messages with stream:true emits SSE: message_start (input usage),
+// content_block_start (text or tool_use header), content_block_delta
+// (text_delta → onToken, or input_json_delta accumulating a tool's JSON args),
+// message_delta (output usage). We reduce per `data:` line and finalize into
+// the same shape chatWithTools returns non-streamed.
+
+function _anthropicInitState() {
+  return { text: "", blocks: {}, inputTokens: 0, outputTokens: 0 };
+}
+
+function _anthropicReduceLine(state, raw, onToken) {
+  const line = (raw || "").trim();
+  if (!line.startsWith("data:")) return state;
+  const payload = line.slice(5).trim();
+  if (!payload) return state;
+  let obj;
+  try {
+    obj = JSON.parse(payload);
+  } catch {
+    return state;
+  }
+  if (obj.type === "message_start") {
+    state.inputTokens =
+      Number(obj.message?.usage?.input_tokens) || state.inputTokens;
+  } else if (obj.type === "content_block_start") {
+    const cb = obj.content_block || {};
+    state.blocks[obj.index] =
+      cb.type === "tool_use"
+        ? { type: "tool_use", id: cb.id, name: cb.name, json: "" }
+        : { type: "text" };
+  } else if (obj.type === "content_block_delta") {
+    const d = obj.delta || {};
+    if (d.type === "text_delta" && d.text) {
+      state.text += d.text;
+      if (typeof onToken === "function") {
+        try {
+          onToken(d.text);
+        } catch {
+          // a failing UI hook must never break the run
+        }
+      }
+    } else if (d.type === "input_json_delta" && state.blocks[obj.index]) {
+      state.blocks[obj.index].json += d.partial_json || "";
+    }
+  } else if (obj.type === "message_delta") {
+    state.outputTokens = Number(obj.usage?.output_tokens) || state.outputTokens;
+  }
+  return state;
+}
+
+function _anthropicFinalize(state) {
+  const toolCalls = [];
+  for (const k of Object.keys(state.blocks)) {
+    const b = state.blocks[k];
+    if (b.type === "tool_use") {
+      let input = {};
+      try {
+        input = b.json ? JSON.parse(b.json) : {};
+      } catch {
+        input = {};
+      }
+      toolCalls.push({
+        id: b.id,
+        type: "function",
+        function: { name: b.name, arguments: JSON.stringify(input) },
+      });
+    }
+  }
+  const message = { role: "assistant", content: state.text };
+  if (toolCalls.length) message.tool_calls = toolCalls;
+  const out = { message };
+  if (state.inputTokens || state.outputTokens) {
+    out.usage = {
+      input_tokens: state.inputTokens,
+      output_tokens: state.outputTokens,
+    };
+  }
+  return out;
+}
+
+/** Pure reducer over Anthropic SSE lines — exported for tests (no HTTP). */
+export function _accumulateAnthropicStream(lines, onToken) {
+  const state = _anthropicInitState();
+  for (const line of lines) _anthropicReduceLine(state, line, onToken);
+  return _anthropicFinalize(state);
+}
+
+async function _chatAnthropicStreaming(apiUrl, body, extraHeaders, onToken, signal) {
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...extraHeaders },
+    signal,
+    body: JSON.stringify(body),
+  });
+  if (!response.ok) {
+    throw new Error(`Anthropic error: ${response.status}`);
+  }
+  const state = _anthropicInitState();
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    const lines = buf.split("\n");
+    buf = lines.pop() || "";
+    for (const line of lines) _anthropicReduceLine(state, line, onToken);
+  }
+  if (buf.trim()) _anthropicReduceLine(state, buf, onToken);
+  return _anthropicFinalize(state);
+}
+
+// ─── OpenAI-compatible streaming (SSE → {message, usage}) ────────────────────
+//
+// `data:` lines carry choices[0].delta.{content, tool_calls[]}; tool_calls
+// arrive fragmented and keyed by `index` (name in the first chunk, arguments
+// concatenated across chunks). usage rides the terminal chunk when
+// stream_options.include_usage was requested. Terminator: `data: [DONE]`.
+
+function _openaiInitState() {
+  return { text: "", tools: [], inputTokens: 0, outputTokens: 0 };
+}
+
+function _openaiReduceLine(state, raw, onToken) {
+  const line = (raw || "").trim();
+  if (!line.startsWith("data:")) return state;
+  const payload = line.slice(5).trim();
+  if (!payload || payload === "[DONE]") return state;
+  let obj;
+  try {
+    obj = JSON.parse(payload);
+  } catch {
+    return state;
+  }
+  const delta = obj.choices?.[0]?.delta;
+  if (delta?.content) {
+    state.text += delta.content;
+    if (typeof onToken === "function") {
+      try {
+        onToken(delta.content);
+      } catch {
+        // a failing UI hook must never break the run
+      }
+    }
+  }
+  if (Array.isArray(delta?.tool_calls)) {
+    for (const tc of delta.tool_calls) {
+      const idx = tc.index ?? 0;
+      if (!state.tools[idx]) state.tools[idx] = { id: undefined, name: "", args: "" };
+      if (tc.id) state.tools[idx].id = tc.id;
+      if (tc.function?.name) state.tools[idx].name = tc.function.name;
+      if (tc.function?.arguments) state.tools[idx].args += tc.function.arguments;
+    }
+  }
+  if (obj.usage) {
+    state.inputTokens = Number(obj.usage.prompt_tokens) || state.inputTokens;
+    state.outputTokens =
+      Number(obj.usage.completion_tokens) || state.outputTokens;
+  }
+  return state;
+}
+
+function _openaiFinalize(state) {
+  const toolCalls = state.tools.filter(Boolean).map((t) => ({
+    id: t.id || `call_${t.name || "tool"}`,
+    type: "function",
+    function: { name: t.name, arguments: t.args || "{}" },
+  }));
+  const message = { role: "assistant", content: state.text };
+  if (toolCalls.length) message.tool_calls = toolCalls;
+  const out = { message };
+  if (state.inputTokens || state.outputTokens) {
+    out.usage = {
+      input_tokens: state.inputTokens,
+      output_tokens: state.outputTokens,
+    };
+  }
+  return out;
+}
+
+/** Pure reducer over OpenAI-compatible SSE lines — exported for tests. */
+export function _accumulateOpenAIStream(lines, onToken) {
+  const state = _openaiInitState();
+  for (const line of lines) _openaiReduceLine(state, line, onToken);
+  return _openaiFinalize(state);
+}
+
+async function _chatOpenAIStreaming(apiUrl, body, apiKey, onToken, signal, provider) {
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    signal,
+    body: JSON.stringify(body),
+  });
+  if (!response.ok) {
+    throw new Error(`${provider} API error: ${response.status}`);
+  }
+  const state = _openaiInitState();
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    const lines = buf.split("\n");
+    buf = lines.pop() || "";
+    for (const line of lines) _openaiReduceLine(state, line, onToken);
+  }
+  if (buf.trim()) _openaiReduceLine(state, buf, onToken);
+  return _openaiFinalize(state);
+}
+
 function _normalizeAnthropicResponse(data) {
   const content = data.content || [];
   const textBlocks = content.filter((b) => b.type === "text");
@@ -2198,12 +2451,34 @@ export async function* agentLoop(messages, options) {
           );
           if (stats.saved > 0 && compacted.length < messages.length) {
             messages.splice(0, messages.length, ...compacted);
+            // Persist the compaction so a later --resume rebuilds from the
+            // shortened history. An explicit `onCompaction` hook (if a caller
+            // provides one) takes precedence; otherwise self-persist a `compact`
+            // event — but only when the session is already being persisted to
+            // disk (the JSONL file exists), so a one-shot `cc agent -p` (which
+            // never creates a session file) writes nothing. Opt out with
+            // `persistCompaction: false`. Best-effort throughout.
             if (typeof options.onCompaction === "function") {
               try {
                 options.onCompaction(stats, compacted);
               } catch {
                 // persistence is best-effort
               }
+            } else if (
+              options.sessionId &&
+              options.persistCompaction !== false
+            ) {
+              try {
+                const store = await import("../harness/jsonl-session-store.js");
+                if (store.sessionExists(options.sessionId)) {
+                  store.appendCompactEvent(options.sessionId, {
+                    ...stats,
+                    messages: compacted,
+                  });
+                }
+              } catch {
+                // self-persist is best-effort
+              }
             }
             yield { type: "compaction", stats, runId };
           }