chainlesschain 0.47.6 → 0.47.8

package/src/repl/agent-repl.js

@@ -34,6 +34,7 @@ import {
   appendUserMessage,
   appendAssistantMessage,
   appendCompactEvent,
+  appendTokenUsage,
   rebuildMessages,
   sessionExists,
 } from "../harness/jsonl-session-store.js";
@@ -70,18 +71,24 @@ import {
  */
 let _hookDb = null;
 let _compressor = null;
+let _approvalGate = null;
 
 /**
  * Execute a tool call — delegates to agent-core with REPL's hookDb and cwd.
  */
 async function executeTool(name, args) {
-  return coreExecuteTool(name, args, { hookDb: _hookDb, cwd: process.cwd() });
+  return coreExecuteTool(name, args, {
+    hookDb: _hookDb,
+    cwd: process.cwd(),
+    approvalGate: _approvalGate,
+  });
 }
 
 /**
  * Agentic loop — wraps agent-core's async generator with REPL display output.
  */
 async function agentLoop(messages, options) {
+  const usageEvents = [];
   for await (const event of coreAgentLoop(messages, options)) {
     if (event.type === "tool-executing") {
       process.stdout.write(
@@ -94,9 +101,34 @@ async function agentLoop(messages, options) {
         process.stdout.write(
           chalk.red(`  Error: ${event.error || event.result?.error}\n`),
         );
+        // Parity with Desktop AIChatPage's `Switch to Trusted` button:
+        // when the deny came from ApprovalGate (not shell-policy), surface
+        // the exact CLI command the user can run to relax the per-session
+        // policy. The structured `approval` outcome is attached by
+        // `evaluateShellCommandWithApproval` in agent-core.js.
+        const approval = event.result?.approval;
+        if (approval?.decision === "deny" && approval?.via !== "shell-policy") {
+          const sid = options?.sessionId;
+          const policy = approval.policy || "strict";
+          if (sid && policy === "strict") {
+            process.stdout.write(
+              chalk.yellow(
+                `  Hint: relax policy with  cc session policy ${sid} --set trusted\n`,
+              ),
+            );
+          } else if (sid) {
+            process.stdout.write(
+              chalk.yellow(
+                `  Hint: per-session policy is "${policy}" — see  cc session policy ${sid}\n`,
+              ),
+            );
+          }
+        }
       } else if (event.result?.success) {
         process.stdout.write(chalk.green(`  Done\n`));
       }
+    } else if (event.type === "token-usage") {
+      usageEvents.push(event);
     } else if (event.type === "iteration-warning") {
       process.stdout.write(chalk.yellow(`\n  ${event.message}\n`));
     } else if (event.type === "iteration-budget-exhausted") {
@@ -104,10 +136,10 @@ async function agentLoop(messages, options) {
         chalk.red(`\n  [Budget Exhausted] ${event.budget}\n`),
       );
     } else if (event.type === "response-complete") {
-      return event.content;
+      return { content: event.content, usageEvents };
     }
   }
-  return "";
+  return { content: "", usageEvents };
 }
 
 /**
@@ -155,6 +187,39 @@ export async function startAgentRepl(options = {}) {
   // Set hook DB reference for tool pipeline
   _hookDb = db;
 
+  // Wire the persistent ApprovalGate singleton (approval-policies.json) with
+  // a readline confirm prompt. agent-core's run_shell branch gates
+  // MEDIUM/HIGH-risk commands against the session's policy tier
+  // (strict / trusted / autopilot).
+  try {
+    const { getApprovalGate } =
+      await import("../lib/session-core-singletons.js");
+    _approvalGate = await getApprovalGate();
+    if (typeof _approvalGate.setConfirmer === "function") {
+      _approvalGate.setConfirmer(async ({ args, riskLevel }) => {
+        const rlConfirm = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+        const q = (p) => new Promise((res) => rlConfirm.question(p, res));
+        const cmd = args?.command ? ` ${args.command}` : "";
+        const ans = (
+          await q(
+            chalk.yellow(
+              `\n[ApprovalGate] ${riskLevel || "medium"} risk command:${cmd}\n  Proceed? (y/N) `,
+            ),
+          )
+        )
+          .trim()
+          .toLowerCase();
+        rlConfirm.close();
+        return ans === "y" || ans === "yes";
+      });
+    }
+  } catch (_err) {
+    _approvalGate = null;
+  }
+
   // Resume existing session or create new one
   const useJsonl = feature("JSONL_SESSION");
 
@@ -200,10 +265,177 @@ export async function startAgentRepl(options = {}) {
     }
   }
 
+  // Phase H — register this session with session-core SessionManager so
+  // `cc session lifecycle / park / unpark / end` can see and control it.
+  // Resume a previously parked handle if --session points at one; otherwise
+  // create a fresh handle keyed by the JSONL sessionId.
+  let _sessionMgr = null;
+  let _sessionHandle = null;
+  try {
+    const { getSessionManager } =
+      await import("../lib/session-core-singletons.js");
+    _sessionMgr = getSessionManager();
+    if (sessionId) {
+      if (options.sessionId && !_sessionMgr.has(sessionId)) {
+        // Try unparking; no-op if nothing parked with that id
+        try {
+          await _sessionMgr.resume(sessionId);
+        } catch (_e) {
+          /* non-critical */
+        }
+      }
+      if (!_sessionMgr.has(sessionId)) {
+        _sessionHandle = _sessionMgr.create({
+          agentId: options.agentId || "cli-agent",
+          sessionId,
+          metadata: { provider, model },
+        });
+      } else {
+        _sessionHandle = _sessionMgr.get(sessionId);
+      }
+    }
+  } catch (_err) {
+    // Non-critical — SessionManager integration must not block startup
+  }
+
   const messages = [
     { role: "system", content: buildSystemPrompt(process.cwd()) },
   ];
 
+  // Deep Agents Deploy Phase 1 — load agent bundle if --bundle provided.
+  // Injects AGENTS.md as system prompt, seeds USER.md into MemoryStore,
+  // and applies bundle manifest metadata (model/provider override, agentId).
+  let _bundleResolved = null;
+  let _bundleMcpClient = null;
+  if (options.bundlePath) {
+    try {
+      const { loadBundle } =
+        await import("@chainlesschain/session-core/agent-bundle-loader");
+      const { resolveBundle } =
+        await import("@chainlesschain/session-core/agent-bundle-resolver");
+      const { getMemoryStore } =
+        await import("../lib/session-core-singletons.js");
+      const bundle = loadBundle(options.bundlePath);
+
+      const memoryStore = getMemoryStore();
+      _bundleResolved = resolveBundle(bundle, {
+        memoryStore,
+        seedOptions: {
+          userId: options.agentId || null,
+        },
+      });
+
+      if (_bundleResolved.systemPrompt) {
+        messages.push({
+          role: "system",
+          content: _bundleResolved.systemPrompt,
+        });
+      }
+
+      if (_bundleResolved.manifest) {
+        if (_bundleResolved.manifest.model && !options.model) {
+          model = _bundleResolved.manifest.model;
+        }
+        if (_bundleResolved.manifest.provider && !options.provider) {
+          provider = _bundleResolved.manifest.provider;
+        }
+      }
+
+      // Connect bundle MCP servers (stdio transport, local mode only).
+      const mcpServers = _bundleResolved.mcpConfig?.servers;
+      if (mcpServers && typeof mcpServers === "object") {
+        const serverEntries = Object.entries(mcpServers).filter(
+          ([, cfg]) => cfg && cfg.command,
+        );
+        if (serverEntries.length > 0) {
+          try {
+            const { MCPClient } = await import("../harness/mcp-client.js");
+            _bundleMcpClient = new MCPClient();
+            let connected = 0;
+            for (const [name, cfg] of serverEntries) {
+              try {
+                await _bundleMcpClient.connect(name, cfg);
+                connected += 1;
+              } catch (mcpErr) {
+                logger.log(
+                  chalk.yellow(
+                    `Bundle MCP: "${name}" connect failed — ${mcpErr.message}`,
+                  ),
+                );
+              }
+            }
+            if (connected === 0) {
+              await _bundleMcpClient.disconnectAll().catch(() => undefined);
+              _bundleMcpClient = null;
+            }
+          } catch (mcpInitErr) {
+            logger.log(
+              chalk.yellow(`Bundle MCP: init failed — ${mcpInitErr.message}`),
+            );
+            _bundleMcpClient = null;
+          }
+        }
+      }
+
+      const seedInfo = _bundleResolved.seedResult;
+      const seedMsg =
+        seedInfo && seedInfo.seeded > 0
+          ? `, seeded ${seedInfo.seeded} user memories`
+          : "";
+      const mcpMsg = _bundleMcpClient
+        ? `, ${_bundleMcpClient.servers.size} MCP servers`
+        : "";
+      const warnMsg =
+        _bundleResolved.warnings.length > 0
+          ? ` (${_bundleResolved.warnings.length} warnings)`
+          : "";
+      logger.log(
+        chalk.gray(
+          `Bundle: loaded ${_bundleResolved.manifest?.id || path.basename(options.bundlePath)}${seedMsg}${mcpMsg}${warnMsg}`,
+        ),
+      );
+    } catch (err) {
+      logger.log(chalk.red(`Bundle: failed to load — ${err.message}`));
+    }
+  }
+
+  // Apply bundle approval policy to this session (after both gate and sessionId are ready)
+  if (_bundleResolved?.approvalPolicy?.default && _approvalGate && sessionId) {
+    try {
+      _approvalGate.setSessionPolicy(
+        sessionId,
+        _bundleResolved.approvalPolicy.default,
+      );
+    } catch (_err) {
+      // Non-critical — invalid policy value is silently ignored
+    }
+  }
+
+  // Phase G #5 — inject top-K memory recall into system prompt for new sessions
+  // Skip on resume (existing context already reflects prior work) and when
+  // --no-recall-memory is passed.
+  if (!options.sessionId && options.recallMemory !== false) {
+    try {
+      const { buildMemoryInjection } =
+        await import("../lib/memory-injection.js");
+      const injection = buildMemoryInjection({
+        agentId: options.agentId || null,
+        query: options.recallQuery || "",
+        limit: Number(options.recallLimit) || undefined,
+      });
+      if (injection) {
+        messages.push({ role: injection.role, content: injection.content });
+        logger.log(
+          chalk.gray(
+            `Context: recalled ${injection.count} memory entries into system prompt`,
+          ),
+        );
+      }
+    } catch (_err) {
+      // Non-critical — memory recall failure must not block REPL startup
+    }
+  }
+
   // Load resumed session messages
   if (options.sessionId && sessionId) {
     try {
@@ -1235,7 +1467,7 @@ export async function startAgentRepl(options = {}) {
     try {
       process.stdout.write("\n");
       const iterationBudget = new IterationBudget({ owner: sessionId });
-      const response = await agentLoop(messages, {
+      const { content: response, usageEvents } = await agentLoop(messages, {
         provider,
         model: activeModel,
         baseUrl,
@@ -1245,8 +1477,24 @@ export async function startAgentRepl(options = {}) {
         sessionId,
         cwd: process.cwd(),
         prepareCall: defaultPrepareCall,
+        approvalGate: _approvalGate,
+        mcpClient: _bundleMcpClient || undefined,
       });
 
+      if (sessionId && usageEvents?.length) {
+        for (const ue of usageEvents) {
+          try {
+            appendTokenUsage(sessionId, {
+              provider: ue.provider,
+              model: ue.model,
+              usage: ue.usage,
+            });
+          } catch (_e) {
+            /* best-effort */
+          }
+        }
+      }
+
       // Fire AssistantResponse hook with rewrite/suppress support
       const responseDirective = await fireAssistantResponse(
         _hookDb,
@@ -1270,8 +1518,18 @@ export async function startAgentRepl(options = {}) {
       }
 
       if (effectiveResponse) {
-        process.stdout.write(`\n${effectiveResponse}\n\n`);
-        messages.push({ role: "assistant", content: effectiveResponse });
+        // Phase G #2 — route through StreamRouter so REPL / WS / future
+        // streaming providers share one StreamEvent protocol.
+        const { streamAgentResponse } = await import("../lib/agent-stream.js");
+        process.stdout.write("\n");
+        const noStream = options.noStream === true;
+        const streamResult = await streamAgentResponse(effectiveResponse, {
+          noStream,
+          writer: noStream ? null : (chunk) => process.stdout.write(chunk),
+        });
+        if (noStream) process.stdout.write(streamResult.text);
+        process.stdout.write("\n\n");
+        messages.push({ role: "assistant", content: streamResult.text });
       } else if (!responseDirective.suppress) {
         process.stdout.write("\n");
       }
@@ -1398,6 +1656,36 @@ export async function startAgentRepl(options = {}) {
       messageCount: messages.length,
     });
 
+    // Phase H — park the SessionManager handle on clean exit so the session
+    // can be resumed later via `cc session unpark <id>`. `--no-park-on-exit`
+    // opts out; a SIGINT path (process-level) will force close instead.
+    if (_sessionMgr && sessionId) {
+      try {
+        if (options.parkOnExit === false) {
+          await _sessionMgr.close(sessionId);
+        } else {
+          _sessionMgr.markIdle(sessionId);
+          await _sessionMgr.park(sessionId);
+          logger.log(
+            chalk.gray(
+              `Session ${sessionId.slice(0, 12)} parked — resume with: cc session unpark ${sessionId}`,
+            ),
+          );
+        }
+      } catch (_e) {
+        // Non-critical — parking failure must not block shutdown
+      }
+    }
+
+    // Disconnect bundle MCP servers
+    if (_bundleMcpClient) {
+      try {
+        await _bundleMcpClient.disconnectAll();
+      } catch (_e) {
+        // Non-critical
+      }
+    }
+
     // Shutdown runtime
     try {
       await shutdown();

package/src/repl/chat-repl.js

@@ -12,6 +12,16 @@ import readline from "readline";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { BUILT_IN_PROVIDERS } from "../lib/llm-providers.js";
+import {
+  streamOllama,
+  streamOpenAI,
+  streamAnthropic,
+} from "../lib/chat-core.js";
+import {
+  startSession,
+  appendTokenUsage,
+  appendEvent,
+} from "../harness/jsonl-session-store.js";
 
 const SLASH_COMMANDS = {
   "/exit": "Exit the chat",
@@ -23,104 +33,6 @@ const SLASH_COMMANDS = {
   "/help": "Show available commands",
 };
 
-/**
- * Stream a response from Ollama
- */
-async function streamOllama(messages, model, baseUrl, onToken) {
-  const response = await fetch(`${baseUrl}/api/chat`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      model,
-      messages,
-      stream: true,
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`Ollama error: ${response.status} ${response.statusText}`);
-  }
-
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let fullResponse = "";
-
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-
-    const text = decoder.decode(value, { stream: true });
-    const lines = text.split("\n").filter(Boolean);
-
-    for (const line of lines) {
-      try {
-        const json = JSON.parse(line);
-        if (json.message?.content) {
-          fullResponse += json.message.content;
-          onToken(json.message.content);
-        }
-      } catch {
-        // Partial JSON, skip
-      }
-    }
-  }
-
-  return fullResponse;
-}
-
-/**
- * Stream a response from OpenAI-compatible API
- */
-async function streamOpenAI(messages, model, baseUrl, apiKey, onToken) {
-  const response = await fetch(`${baseUrl}/chat/completions`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({
-      model,
-      messages,
-      stream: true,
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`API error: ${response.status} ${response.statusText}`);
-  }
-
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let fullResponse = "";
-
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-
-    const text = decoder.decode(value, { stream: true });
-    const lines = text.split("\n").filter(Boolean);
-
-    for (const line of lines) {
-      if (line.startsWith("data: ")) {
-        const data = line.slice(6);
-        if (data === "[DONE]") continue;
-        try {
-          const json = JSON.parse(data);
-          const content = json.choices?.[0]?.delta?.content;
-          if (content) {
-            fullResponse += content;
-            onToken(content);
-          }
-        } catch {
-          // Partial data
-        }
-      }
-    }
-  }
-
-  return fullResponse;
-}
-
 /**
  * Start the interactive chat REPL
  * @param {object} options
@@ -133,6 +45,21 @@ export async function startChatRepl(options = {}) {
 
   const messages = [];
 
+  // Phase J — attach chat REPL to a JSONL session so token_usage is recorded
+  // and `cc session usage` / `usage.*` WS routes show real numbers.
+  let sessionId = options.sessionId || null;
+  if (!sessionId && options.recordUsage !== false) {
+    try {
+      sessionId = startSession(null, {
+        title: "chat-repl",
+        provider,
+        model,
+      });
+    } catch {
+      sessionId = null;
+    }
+  }
+
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -142,6 +69,7 @@ export async function startChatRepl(options = {}) {
 
   logger.log(chalk.bold("\nChainlessChain AI Chat"));
   logger.log(chalk.gray(`Model: ${model}  Provider: ${provider}`));
+  if (sessionId) logger.log(chalk.gray(`Session: ${sessionId}`));
   logger.log(chalk.gray("Type /help for commands, /exit to quit\n"));
 
   rl.prompt();
@@ -234,9 +162,43 @@ export async function startChatRepl(options = {}) {
     try {
       let response;
       const onToken = (token) => process.stdout.write(token);
+      let capturedUsage = null;
+      const onUsage = (u) => {
+        capturedUsage = u;
+      };
+
+      if (sessionId)
+        appendEvent(sessionId, "user_message", { content: trimmed });
 
       if (provider === "ollama") {
-        response = await streamOllama(messages, model, baseUrl, onToken);
+        response = await streamOllama(
+          messages,
+          model,
+          baseUrl,
+          onToken,
+          onUsage,
+        );
+      } else if (provider === "anthropic") {
+        const providerDef = BUILT_IN_PROVIDERS.anthropic;
+        const url =
+          baseUrl !== "http://localhost:11434"
+            ? baseUrl
+            : providerDef?.baseUrl || "https://api.anthropic.com/v1";
+        const key =
+          apiKey ||
+          (providerDef?.apiKeyEnv ? process.env[providerDef.apiKeyEnv] : null);
+        if (!key)
+          throw new Error(
+            `API key required for anthropic (set ${providerDef?.apiKeyEnv || "ANTHROPIC_API_KEY"})`,
+          );
+        response = await streamAnthropic(
+          messages,
+          model,
+          url,
+          key,
+          onToken,
+          onUsage,
+        );
       } else {
         // OpenAI-compatible providers (openai, volcengine, deepseek, dashscope, mistral, gemini, anthropic-proxy)
         const providerDef = BUILT_IN_PROVIDERS[provider];
@@ -251,11 +213,36 @@ export async function startChatRepl(options = {}) {
           throw new Error(
             `API key required for ${provider} (set ${providerDef?.apiKeyEnv || "API key"})`,
           );
-        response = await streamOpenAI(messages, model, url, key, onToken);
+        response = await streamOpenAI(
+          messages,
+          model,
+          url,
+          key,
+          onToken,
+          onUsage,
+        );
       }
 
       process.stdout.write("\n\n");
       messages.push({ role: "assistant", content: response });
+
+      if (sessionId) {
+        try {
+          appendEvent(sessionId, "assistant_message", { content: response });
+          if (capturedUsage) {
+            appendTokenUsage(sessionId, {
+              provider,
+              model,
+              usage: {
+                input_tokens: capturedUsage.inputTokens,
+                output_tokens: capturedUsage.outputTokens,
+              },
+            });
+          }
+        } catch {
+          /* best-effort — never break REPL */
+        }
+      }
     } catch (err) {
       process.stdout.write("\n");
       logger.error(`Error: ${err.message}`);