chainlesschain 0.162.37 → 0.162.39

package/src/repl/mcp-prompt.js

@@ -0,0 +1,122 @@
+/**
+ * MCP prompt + resource surfacing for the agent REPL (Claude-Code parity).
+ *
+ * MCP servers can expose "prompts" — server-defined, parameterized prompt
+ * templates — which Claude Code surfaces as slash commands of the form
+ * `/mcp__<server>__<prompt>`. This module is the pure, unit-testable core:
+ * it parses such a command, fetches the rendered prompt from the connected
+ * MCP client, and flattens it into plain text to use as the user's turn.
+ *
+ * It also renders a `/mcp` overview of every connected server's resources and
+ * prompts. The REPL (agent-repl.js) wires these in; all the logic lives here so
+ * it can be tested without spinning up a readline session.
+ */
+
+/**
+ * Parse a `/mcp__<server>__<prompt> [args]` line. Returns `{ server, name,
+ * args }` or `null` when the line is not an MCP prompt invocation.
+ *
+ * `args` is parsed from a trailing JSON object when present; a non-JSON tail is
+ * passed as `{ input: "<tail>" }` so simple one-arg prompts stay ergonomic.
+ */
+export function parseMcpPromptCommand(line) {
+  const trimmed = (line || "").trim();
+  if (!trimmed.startsWith("/mcp__")) return null;
+
+  const sp = trimmed.search(/\s/);
+  const token = sp === -1 ? trimmed : trimmed.slice(0, sp);
+  const rest = sp === -1 ? "" : trimmed.slice(sp + 1).trim();
+
+  const full = token.slice(1); // drop leading "/"
+  const parts = full.split("__"); // ["mcp", "<server>", "<prompt...>"]
+  if (parts.length < 3 || parts[0] !== "mcp") return null;
+  const server = parts[1];
+  const name = parts.slice(2).join("__");
+  if (!server || !name) return null;
+
+  let args = {};
+  if (rest) {
+    try {
+      const parsed = JSON.parse(rest);
+      args =
+        parsed && typeof parsed === "object" && !Array.isArray(parsed)
+          ? parsed
+          : { input: rest };
+    } catch {
+      args = { input: rest };
+    }
+  }
+  return { server, name, args };
+}
+
+/**
+ * Flatten an MCP `prompts/get` result (`{ messages: [...] }`) into plain text.
+ * Handles text blocks and embedded text resources; ignores binary blocks.
+ */
+export function renderPromptMessages(result) {
+  const messages = Array.isArray(result?.messages) ? result.messages : [];
+  const out = [];
+  for (const msg of messages) {
+    const blocks = Array.isArray(msg?.content) ? msg.content : [msg?.content];
+    for (const b of blocks) {
+      if (!b) continue;
+      if (b.type === "text" && typeof b.text === "string") {
+        out.push(b.text);
+      } else if (
+        b.type === "resource" &&
+        b.resource &&
+        typeof b.resource.text === "string"
+      ) {
+        out.push(b.resource.text);
+      }
+    }
+  }
+  return out.join("\n\n");
+}
+
+/**
+ * Expand a `/mcp__server__prompt` line into prompt text by calling the MCP
+ * client. Returns the rendered text, or `null` when the line is not an MCP
+ * prompt command. Throws if the underlying `getPrompt` fails (caller decides
+ * whether to surface or swallow).
+ */
+export async function expandMcpPrompt(line, mcpClient) {
+  const cmd = parseMcpPromptCommand(line);
+  if (!cmd) return null;
+  if (!mcpClient || typeof mcpClient.getPrompt !== "function") {
+    throw new Error("No MCP servers are connected this session.");
+  }
+  const result = await mcpClient.getPrompt(cmd.server, cmd.name, cmd.args);
+  return renderPromptMessages(result);
+}
+
+/**
+ * Render a human overview of all connected MCP resources + prompts for `/mcp`.
+ */
+export function renderMcpSurface(mcpClient) {
+  if (!mcpClient) return "No MCP servers are connected this session.";
+  const resources =
+    typeof mcpClient.listResources === "function"
+      ? mcpClient.listResources()
+      : [];
+  const prompts =
+    typeof mcpClient.listPrompts === "function" ? mcpClient.listPrompts() : [];
+
+  const lines = [];
+  lines.push(`MCP resources (${resources.length}):`);
+  for (const r of resources) {
+    lines.push(`  ${r.uri} [${r.server}]${r.name ? " — " + r.name : ""}`);
+  }
+  lines.push("");
+  lines.push(`MCP prompts (${prompts.length}):`);
+  for (const p of prompts) {
+    lines.push(
+      `  /mcp__${p.server}__${p.name}${p.description ? " — " + p.description : ""}`,
+    );
+  }
+  if (resources.length === 0 && prompts.length === 0) {
+    lines.push("");
+    lines.push("(connected servers expose no resources or prompts)");
+  }
+  return lines.join("\n");
+}

package/src/runtime/agent-core.js

@@ -222,7 +222,10 @@ async function runSettingsPreToolUseHooks(name, args, context, cwd) {
     cwd,
     session_id: context.sessionId || null,
   };
-  const outcome = runCommandHooks(matched, payload, { cwd, event: "PreToolUse" });
+  const outcome = runCommandHooks(matched, payload, {
+    cwd,
+    event: "PreToolUse",
+  });
   if (outcome.decision === "block") {
     return { blocked: true, reason: outcome.reason, hook: outcome.hook };
   }
@@ -234,8 +237,7 @@ async function runSettingsPreToolUseHooks(name, args, context, cwd) {
             tool: name,
             args,
             rule: `hook:${outcome.hook}`,
-            reason:
-              outcome.reason || "a PreToolUse hook requests confirmation",
+            reason: outcome.reason || "a PreToolUse hook requests confirmation",
           })
         : false;
     return ok
@@ -730,7 +732,11 @@ export async function executeTool(name, args, context = {}) {
     if (!ok) {
       return {
         error: `[Permission] Tool "${name}" requires confirmation (settings rule: ${settingsVerdict.rule}) — denied.`,
-        policy: { decision: "ask", rule: settingsVerdict.rule, via: "settings" },
+        policy: {
+          decision: "ask",
+          rule: settingsVerdict.rule,
+          via: "settings",
+        },
       };
     }
     ruleAllowed = true; // confirmed → treat like allow downstream
@@ -889,6 +895,74 @@ export async function executeTool(name, args, context = {}) {
     }
   }
 
+  // settings.json SubagentStop hooks: fire when a `spawn_sub_agent` tool call
+  // finishes (Claude-Code SubagentStop parity). The subagent has already
+  // returned its summary, so this is observe + feedback rather than force-
+  // continue: a `block` reason is surfaced to the PARENT agent as hookFeedback
+  // so it can react (e.g. re-spawn or adjust), mirroring PostToolUse.
+  if (
+    name === "spawn_sub_agent" &&
+    context.settingsHooks &&
+    toolResult &&
+    typeof toolResult === "object"
+  ) {
+    try {
+      const outcome = runObserveHooks(
+        context.settingsHooks,
+        "SubagentStop",
+        {
+          stop_hook_active: false,
+          session_id: context.sessionId || null,
+          subagent_response:
+            typeof toolResult === "object"
+              ? JSON.stringify(toolResult).substring(0, 2000)
+              : String(toolResult).substring(0, 2000),
+        },
+        { cwd },
+      );
+      if (outcome.decision === "block" && outcome.reason) {
+        toolResult.hookFeedback = toolResult.hookFeedback
+          ? `${toolResult.hookFeedback}\n${outcome.reason}`
+          : outcome.reason;
+      }
+    } catch (_err) {
+      // SubagentStop hooks are best-effort
+    }
+  }
+
+  // IDE post-edit diagnostics (Claude-Code parity): after a successful file
+  // mutation with an IDE bridge connected, pull the editor's fresh
+  // error/warning diagnostics for that file into the tool result so the model
+  // can fix what it just broke in the same loop. Best-effort, bounded;
+  // CC_IDE_CONTEXT=0 disables alongside prompt-time context.
+  if (
+    (name === "write_file" ||
+      name === "edit_file" ||
+      name === "edit_file_hashed") &&
+    toolResult &&
+    typeof toolResult === "object" &&
+    !toolResult.error &&
+    args?.path &&
+    context.mcpClient &&
+    context.externalToolExecutors
+  ) {
+    try {
+      const { collectIdeDiagnostics, formatIdeDiagnostics } =
+        await import("../lib/ide-context.js");
+      const diags = await collectIdeDiagnostics(
+        {
+          mcpClient: context.mcpClient,
+          externalToolExecutors: context.externalToolExecutors,
+        },
+        path.resolve(cwd, args.path),
+      );
+      const feedback = formatIdeDiagnostics(diags);
+      if (feedback) toolResult.ideDiagnostics = feedback;
+    } catch (_err) {
+      // diagnostics feedback is optional polish — never fail the tool
+    }
+  }
+
   return toolResult;
 }
 
@@ -1240,12 +1314,8 @@ async function executeToolInner(
         ...(task.error ? { error: task.error } : {}),
         stdout: out.text.substring(0, 30000),
         stderr: err.text.substring(0, 30000),
-        ...(out.droppedGap
-          ? { stdout_dropped_bytes: out.droppedGap }
-          : {}),
-        ...(err.droppedGap
-          ? { stderr_dropped_bytes: err.droppedGap }
-          : {}),
+        ...(out.droppedGap ? { stdout_dropped_bytes: out.droppedGap } : {}),
+        ...(err.droppedGap ? { stderr_dropped_bytes: err.droppedGap } : {}),
         ...(killed ? { killed: true } : {}),
         startedAt: task.startedAt,
         endedAt: task.endedAt,
@@ -1635,6 +1705,50 @@ async function executeToolInner(
     }
 
     default:
+      if (localToolExecutor?.kind === "mcp-resource") {
+        if (!mcpClient) {
+          return attachDescriptor({
+            error: `MCP client is unavailable for tool: ${name}`,
+          });
+        }
+        try {
+          if (localToolExecutor.op === "list") {
+            const resources =
+              typeof mcpClient.listResources === "function"
+                ? mcpClient.listResources(args?.server || undefined)
+                : [];
+            return attachDescriptor({ count: resources.length, resources });
+          }
+          // op === "read"
+          const uri = args?.uri;
+          if (!uri || typeof uri !== "string") {
+            return attachDescriptor({
+              error: "read_mcp_resource requires a string 'uri' argument.",
+            });
+          }
+          let server = args?.server;
+          if (!server && typeof mcpClient.listResources === "function") {
+            const match = mcpClient
+              .listResources()
+              .find((r) => r && r.uri === uri);
+            server = match?.server;
+          }
+          if (!server) {
+            return attachDescriptor({
+              error: `Could not resolve which MCP server owns resource "${uri}". Pass 'server' explicitly.`,
+            });
+          }
+          const result = await mcpClient.readResource(server, uri);
+          return attachDescriptor(
+            result && typeof result === "object" ? result : { result },
+          );
+        } catch (err) {
+          return attachDescriptor({
+            error: `MCP resource access failed: ${err.message}`,
+          });
+        }
+      }
+
       if (localToolExecutor?.kind === "mcp") {
         if (!mcpClient || typeof mcpClient.callTool !== "function") {
           return attachDescriptor({
@@ -2601,7 +2715,13 @@ export function _accumulateAnthropicStream(lines, onToken) {
   return _anthropicFinalize(state);
 }
 
-async function _chatAnthropicStreaming(apiUrl, body, extraHeaders, onToken, signal) {
+async function _chatAnthropicStreaming(
+  apiUrl,
+  body,
+  extraHeaders,
+  onToken,
+  signal,
+) {
   const response = await fetch(apiUrl, {
     method: "POST",
     headers: { "Content-Type": "application/json", ...extraHeaders },
@@ -2663,10 +2783,12 @@ function _openaiReduceLine(state, raw, onToken) {
   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 (!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 (tc.function?.arguments)
+        state.tools[idx].args += tc.function.arguments;
     }
   }
   if (obj.usage) {
@@ -2702,7 +2824,14 @@ export function _accumulateOpenAIStream(lines, onToken) {
   return _openaiFinalize(state);
 }
 
-async function _chatOpenAIStreaming(apiUrl, body, apiKey, onToken, signal, provider) {
+async function _chatOpenAIStreaming(
+  apiUrl,
+  body,
+  apiKey,
+  onToken,
+  signal,
+  provider,
+) {
   const response = await fetch(apiUrl, {
     method: "POST",
     headers: {
@@ -2843,7 +2972,11 @@ function _intensityToEffort(want) {
  * RUNTIME-UNVERIFIED — no Anthropic key to validate the wire shape live.
  * Exported for tests.
  */
-export function _anthropicThinkingParams(model, options = {}, maxTokens = 8192) {
+export function _anthropicThinkingParams(
+  model,
+  options = {},
+  maxTokens = 8192,
+) {
   const want = options?.thinking;
   if (!want) return null; // off by default → request unchanged
   const m = String(model || "").toLowerCase();
@@ -3181,7 +3314,11 @@ export async function* agentLoop(messages, options) {
             }
           }
           if (preCompactBlocked) {
-            yield { type: "compaction-skipped", runId, reason: preCompactReason };
+            yield {
+              type: "compaction-skipped",
+              runId,
+              reason: preCompactReason,
+            };
           }
           const { messages: compacted, stats } = preCompactBlocked
             ? { messages, stats: { saved: 0 } }
@@ -3400,7 +3537,9 @@ export function formatToolArgs(name, args) {
     case "edit_file_hashed":
       return `${args.path} @${args.anchor_hash}`;
     case "run_shell":
-      return args.run_in_background ? `${args.command} (background)` : args.command;
+      return args.run_in_background
+        ? `${args.command} (background)`
+        : args.command;
     case "check_shell":
       return args.task_id
         ? `${args.task_id}${args.kill ? " (kill)" : ""}`

package/src/runtime/headless-runner.js

@@ -176,6 +176,34 @@ export function resolveHeadlessSession(options = {}, store = {}, fallbackId) {
   return { sessionId: id, resumeId, persist, wantLatest };
 }
 
+/**
+ * Apply `--fork-session`: when a session has been resolved (resume/continue) and
+ * a fork is requested, branch its JSONL transcript into a NEW id so the original
+ * stays untouched (Claude-Code `--fork-session` parity). The copy carries the
+ * full prior history, so a later `--resume <newId>` replays the whole branch.
+ *
+ * Returns the id to use downstream + the source (`forkedFrom`), or the original
+ * id unchanged with `missing:true` when there is no transcript to fork. Pure
+ * apart from the injected store's side effect; both `sessionExists`/`forkSession`
+ * are injection seams so this is unit-testable without disk.
+ *
+ * @param {{forkSession?:boolean, sessionId?:string|null}} opts
+ * @param {{sessionExists?:Function, forkSession?:Function}} store
+ * @returns {{ sessionId:string|null, forkedFrom:string|null, missing:boolean }}
+ */
+export function applyForkSession(opts = {}, store = {}) {
+  const want = opts.forkSession === true;
+  const id = opts.sessionId || null;
+  if (!want || !id) return { sessionId: id, forkedFrom: null, missing: false };
+  if (typeof store.sessionExists === "function" && !store.sessionExists(id)) {
+    return { sessionId: id, forkedFrom: null, missing: true };
+  }
+  const newId =
+    typeof store.forkSession === "function" ? store.forkSession(id) : null;
+  if (!newId) return { sessionId: id, forkedFrom: null, missing: false };
+  return { sessionId: newId, forkedFrom: id, missing: false };
+}
+
 /**
  * Run a single headless agentic turn.
  *
@@ -404,9 +432,8 @@ export async function runAgentHeadless(options = {}, deps = {}) {
   // settings.json UserPromptSubmit hooks. block → abort the run; context → inject.
   if (settingsHooks) {
     try {
-      const { runUserPromptSubmitHooks } = await import(
-        "../lib/settings-hook-events.cjs"
-      );
+      const { runUserPromptSubmitHooks } =
+        await import("../lib/settings-hook-events.cjs");
       const ups = runUserPromptSubmitHooks(settingsHooks, {
         prompt: userContent,
         cwd,
@@ -434,9 +461,8 @@ export async function runAgentHeadless(options = {}, deps = {}) {
   let sessionStartContext = null;
   if (settingsHooks) {
     try {
-      const { runSessionStartHooks } = await import(
-        "../lib/settings-hook-events.cjs"
-      );
+      const { runSessionStartHooks } =
+        await import("../lib/settings-hook-events.cjs");
       sessionStartContext = runSessionStartHooks(settingsHooks, {
         source: resumeId ? "resume" : "startup",
         cwd,
@@ -520,6 +546,25 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     }
   }
 
+  // IDE live context (Claude-Code parity): when an IDE bridge is connected,
+  // share the editor's selection/active file/open tabs with this turn. Appended
+  // to the in-flight user message only — AFTER persistence — so a resumed
+  // session replays the prompt, not a stale editor snapshot. Best-effort with
+  // a short timeout; CC_IDE_CONTEXT=0 disables.
+  try {
+    const { buildIdePromptContext, appendTextToContent } =
+      await import("../lib/ide-context.js");
+    const ideCtx = await (deps.buildIdePromptContext || buildIdePromptContext)(
+      mcp,
+    );
+    if (ideCtx) {
+      const last = messages[messages.length - 1];
+      last.content = appendTextToContent(last.content, ideCtx);
+    }
+  } catch {
+    // IDE context is optional polish — never fail the run over it.
+  }
+
   // --permission-prompt-tool: route every CONFIRM-tier approval to an MCP tool
   // (loaded via --mcp-config) instead of headless fail-closed. Overrides the
   // permission-mode confirmer on the gate for this session.
@@ -766,9 +811,8 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     // settings.json SessionEnd hooks (observe-only) when the run finishes.
     if (settingsHooks) {
       try {
-        const { runObserveHooks } = await import(
-          "../lib/settings-hook-events.cjs"
-        );
+        const { runObserveHooks } =
+          await import("../lib/settings-hook-events.cjs");
         runObserveHooks(
           settingsHooks,
           "SessionEnd",

package/src/runtime/headless-stream.js

@@ -245,9 +245,8 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
   // settings.json SessionStart hooks → inject session context once (observe-only).
   if (settingsHooks) {
     try {
-      const { runSessionStartHooks } = await import(
-        "../lib/settings-hook-events.cjs"
-      );
+      const { runSessionStartHooks } =
+        await import("../lib/settings-hook-events.cjs");
       const ctx = runSessionStartHooks(settingsHooks, {
         source: "startup",
         cwd,
@@ -428,9 +427,8 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     // settings.json UserPromptSubmit hooks. block → skip this turn; context → inject.
     if (settingsHooks) {
       try {
-        const { runUserPromptSubmitHooks } = await import(
-          "../lib/settings-hook-events.cjs"
-        );
+        const { runUserPromptSubmitHooks } =
+          await import("../lib/settings-hook-events.cjs");
         const ups = runUserPromptSubmitHooks(settingsHooks, {
           prompt: userContent,
           cwd,
@@ -454,6 +452,19 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
       }
     }
 
+    // IDE live context (Claude-Code parity): re-shared on every turn while an
+    // IDE bridge is connected — the user's selection moves between prompts.
+    // Best-effort; CC_IDE_CONTEXT=0 disables.
+    try {
+      const { buildIdePromptContext } = await import("../lib/ide-context.js");
+      const ideCtx = await (
+        deps.buildIdePromptContext || buildIdePromptContext
+      )(mcp);
+      if (ideCtx) userContent += `\n\n${ideCtx}`;
+    } catch {
+      // optional polish — never fail the turn over it
+    }
+
     messages.push({ role: "user", content: userContent });
     turns += 1;
 
@@ -508,9 +519,8 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
   // settings.json SessionEnd hooks (observe-only) when stdin closes.
   if (settingsHooks) {
     try {
-      const { runObserveHooks } = await import(
-        "../lib/settings-hook-events.cjs"
-      );
+      const { runObserveHooks } =
+        await import("../lib/settings-hook-events.cjs");
       runObserveHooks(
         settingsHooks,
         "SessionEnd",