chainlesschain 0.162.153 → 0.162.155

package/src/commands/background-session.js

@@ -0,0 +1,499 @@
+import { existsSync, readFileSync } from "node:fs";
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+function formatAge(ms) {
+  const n = Math.max(0, Math.round(Number(ms || 0) / 1000));
+  if (n < 60) return `${n}s`;
+  const m = Math.floor(n / 60);
+  const s = n % 60;
+  if (m < 60) return `${m}m${s ? ` ${s}s` : ""}`;
+  const h = Math.floor(m / 60);
+  const rest = m % 60;
+  return `${h}h${rest ? ` ${rest}m` : ""}`;
+}
+
+export function formatBackgroundAgentLine(session, now = Date.now()) {
+  const elapsed = session?.endedAt
+    ? session.endedAt - session.startedAt
+    : now - session.startedAt;
+  const title = session?.title ? `  ${session.title}` : "";
+  return `${session.id}  ${String(session.status || "?").padEnd(9)} ${formatAge(elapsed).padStart(6)}  ${session.cwd || ""}${title}`;
+}
+
+function printBackgroundAgents(sessions, { now = Date.now() } = {}) {
+  if (!sessions.length) {
+    logger.log(chalk.gray("No background agents."));
+    return;
+  }
+  for (const session of sessions) {
+    logger.log(formatBackgroundAgentLine(session, now));
+    if (session.pid || session.sessionId) {
+      logger.log(
+        chalk.gray(
+          `  pid ${session.pid || "?"}${session.sessionId ? `  session ${session.sessionId}` : ""}`,
+        ),
+      );
+    }
+  }
+}
+
+function formatTimestamp(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? new Date(n).toISOString() : "-";
+}
+
+export function formatBackgroundAgentDetails(
+  session,
+  logText = "",
+  options = {},
+) {
+  const now = typeof options.now === "number" ? options.now : Date.now();
+  const elapsed = session?.endedAt
+    ? session.endedAt - session.startedAt
+    : now - session.startedAt;
+  const lines = [
+    `Background agent ${session.id}`,
+    `  status: ${session.status || "?"}`,
+    `  title: ${session.title || "-"}`,
+    `  cwd: ${session.cwd || "-"}`,
+    `  pid: ${session.pid || "-"}`,
+    `  workerPid: ${session.workerPid || "-"}`,
+    `  agentPid: ${session.agentPid || "-"}`,
+    `  session: ${session.sessionId || "-"}`,
+    `  elapsed: ${formatAge(elapsed)}`,
+    `  startedAt: ${formatTimestamp(session.startedAt)}`,
+    `  endedAt: ${formatTimestamp(session.endedAt)}`,
+    `  log: ${session.logFile || "-"}`,
+  ];
+  if (session.phase) lines.push(`  phase: ${session.phase}`);
+  if (Number.isFinite(Number(session.turnCount))) {
+    lines.push(`  turns: ${session.turnCount}`);
+  }
+  if (session.transport?.pipe) {
+    lines.push(`  transport: interactive attach available`);
+  }
+  if (session.lostReason) lines.push(`  lostReason: ${session.lostReason}`);
+  if (Number.isFinite(Number(session.exitCode))) {
+    lines.push(`  exitCode: ${session.exitCode}`);
+  }
+  lines.push("", "Recent output:");
+  lines.push(logText ? logText.trimEnd() : "  (no log output)");
+  lines.push("", "Commands:");
+  lines.push(`  cc attach ${session.id}`);
+  lines.push(`  cc logs ${session.id} -n 100`);
+  if (session.status === "running") {
+    lines.push(`  cc daemon stop ${session.id}`);
+  }
+  return lines.join("\n");
+}
+
+function parseLines(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+
+async function loadSupervisor() {
+  return import("../lib/background-agent-supervisor.js");
+}
+
+function readLogFromOffset(file, offset) {
+  if (!existsSync(file)) return { text: "", offset };
+  const text = readFileSync(file, "utf8");
+  if (offset > text.length) offset = 0;
+  return { text: text.slice(offset), offset: text.length };
+}
+
+async function followBackgroundAgent(id, options = {}) {
+  const {
+    readBackgroundAgentState,
+    effectiveBackgroundAgentState,
+    readBackgroundAgentLog,
+    logPath,
+  } = await loadSupervisor();
+  const lines = parseLines(options.lines, 100);
+  let state = effectiveBackgroundAgentState(readBackgroundAgentState(id));
+  if (!state) throw new Error(`Background agent not found: ${id}`);
+  const logFile = logPath(id);
+  const initial = readBackgroundAgentLog(id, { lines });
+  if (initial)
+    process.stdout.write(initial.endsWith("\n") ? initial : `${initial}\n`);
+  let offset = existsSync(logFile) ? readFileSync(logFile, "utf8").length : 0;
+
+  if (options.follow === false || state.status !== "running") {
+    return state;
+  }
+
+  logger.log(chalk.gray(`Attached to ${id}. Streaming logs; Ctrl-C detaches.`));
+  while (true) {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const next = readLogFromOffset(logFile, offset);
+    offset = next.offset;
+    if (next.text) process.stdout.write(next.text);
+    state = effectiveBackgroundAgentState(readBackgroundAgentState(id));
+    if (!state || state.status !== "running") {
+      if (state) {
+        logger.log(chalk.gray(`\n${id} is ${state.status}.`));
+      }
+      return state;
+    }
+  }
+}
+
+/**
+ * Interactive attach over the session transport: stream the log AND accept
+ * typed follow-up prompts (plus /stop · /status · /detach). Returns false
+ * when the transport is unavailable so the caller can fall back to the
+ * log-only follow.
+ */
+async function interactiveAttach(id, state, options = {}) {
+  const { connectBackgroundSession } =
+    await import("../lib/background-session-transport.js");
+  const { readBackgroundAgentLog, logPath } = await loadSupervisor();
+
+  let closed = false;
+  let conn;
+  try {
+    conn = await connectBackgroundSession({
+      pipePath: state.transport.pipe,
+      token: state.transport.token,
+      onEvent: (message) => {
+        switch (message.type) {
+          case "turn-started":
+            logger.log(
+              chalk.gray(
+                `— turn ${message.turn} started${message.prompt ? `: ${message.prompt}` : ""}`,
+              ),
+            );
+            return;
+          case "turn-ended":
+            logger.log(
+              chalk.gray(
+                `— turn ${message.turn} ended (exit ${message.exitCode})`,
+              ),
+            );
+            return;
+          case "idle":
+            logger.log(
+              chalk.gray(
+                "— session idle; type a follow-up prompt, or Ctrl-C to detach (ends the session)",
+              ),
+            );
+            return;
+          case "accepted":
+            logger.log(chalk.gray(`— prompt queued (#${message.queued})`));
+            return;
+          case "status":
+            logger.log(
+              chalk.gray(
+                `— ${message.id} phase=${message.phase} turn=${message.turn}`,
+              ),
+            );
+            return;
+          case "stopping":
+            logger.log(chalk.gray("— stopping current turn"));
+            return;
+          case "closing":
+            return; // close handler prints the final state
+          case "error":
+            logger.log(chalk.yellow(`— ${message.message}`));
+            return;
+          default:
+            return;
+        }
+      },
+      onClose: () => {
+        closed = true;
+      },
+    });
+  } catch {
+    return false; // transport gone (worker finalizing/finalized) — fall back
+  }
+
+  const lines = parseLines(options.lines, 100);
+  const initial = readBackgroundAgentLog(id, { lines });
+  if (initial)
+    process.stdout.write(initial.endsWith("\n") ? initial : `${initial}\n`);
+  const logFile = logPath(id);
+  let offset = existsSync(logFile) ? readFileSync(logFile, "utf8").length : 0;
+  logger.log(
+    chalk.gray(
+      `Attached to ${id} (interactive). Type a prompt to continue the session; /stop · /status · Ctrl-C detaches.`,
+    ),
+  );
+
+  const readline = await import("node:readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  rl.on("line", (line) => {
+    const text = line.trim();
+    if (!text) return;
+    if (text === "/detach" || text === "/exit" || text === "/quit") {
+      rl.close();
+      return;
+    }
+    if (text === "/stop") {
+      conn.send({ type: "stop" });
+      return;
+    }
+    if (text === "/status") {
+      conn.send({ type: "status" });
+      return;
+    }
+    conn.send({ type: "prompt", text });
+  });
+  const detach = () => rl.close();
+  rl.on("SIGINT", detach);
+
+  await new Promise((resolve) => {
+    rl.on("close", resolve);
+    const poll = setInterval(() => {
+      const next = readLogFromOffset(logFile, offset);
+      offset = next.offset;
+      if (next.text) process.stdout.write(next.text);
+      if (closed) {
+        clearInterval(poll);
+        rl.close();
+      }
+    }, 500);
+    poll.unref?.();
+    rl.on("close", () => clearInterval(poll));
+  });
+
+  // Drain any output written between the last poll and detach.
+  const rest = readLogFromOffset(logFile, offset);
+  if (rest.text) process.stdout.write(rest.text);
+  try {
+    conn.close();
+  } catch {
+    /* already closed by the worker */
+  }
+  const { readBackgroundAgentState, effectiveBackgroundAgentState } =
+    await loadSupervisor();
+  const finalState = effectiveBackgroundAgentState(
+    readBackgroundAgentState(id),
+  );
+  if (finalState) logger.log(chalk.gray(`\n${id} is ${finalState.status}.`));
+  return true;
+}
+
+export function registerBackgroundSessionCommands(program) {
+  program
+    .command("logs <id>")
+    .description("Print recent output from a background agent")
+    .option("-n, --lines <n>", "Number of lines", "100")
+    .action(async (id, options) => {
+      try {
+        const { readBackgroundAgentState, readBackgroundAgentLog } =
+          await loadSupervisor();
+        if (!readBackgroundAgentState(id)) {
+          throw new Error(`Background agent not found: ${id}`);
+        }
+        process.stdout.write(
+          readBackgroundAgentLog(id, { lines: parseLines(options.lines, 100) }),
+        );
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+
+  program
+    .command("attach <id>")
+    .description(
+      "Attach to a background agent — interactive when its session transport is available, log stream otherwise",
+    )
+    .option("-n, --lines <n>", "Initial lines to print", "100")
+    .option("--no-follow", "Print the initial log tail and exit")
+    .option("--no-input", "Log stream only; never send prompts")
+    .action(async (id, options) => {
+      try {
+        const { readBackgroundAgentState, effectiveBackgroundAgentState } =
+          await loadSupervisor();
+        const state = effectiveBackgroundAgentState(
+          readBackgroundAgentState(id),
+        );
+        if (!state) throw new Error(`Background agent not found: ${id}`);
+        const wantsInteractive =
+          options.input !== false &&
+          options.follow !== false &&
+          state.status === "running" &&
+          state.transport?.pipe &&
+          state.transport?.token &&
+          process.stdin.isTTY;
+        if (wantsInteractive) {
+          const attached = await interactiveAttach(id, state, options);
+          if (attached) return;
+          // transport refused (worker mid-finalize) — fall back to logs
+        }
+        await followBackgroundAgent(id, options);
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+
+  const daemon = program
+    .command("daemon")
+    .description("Inspect and stop background agent supervisor sessions");
+
+  daemon
+    .command("status")
+    .description("Show background agent supervisor status")
+    .option("--all", "Include completed, failed, stopped and lost sessions")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { backgroundAgentsDir, listBackgroundAgents } =
+          await loadSupervisor();
+        const sessions = listBackgroundAgents({ all: options.all === true });
+        const running = sessions.filter((s) => s.status === "running").length;
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                supervisor: "background-agents",
+                dir: backgroundAgentsDir(),
+                running,
+                total: sessions.length,
+                sessions,
+              },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+        logger.log(
+          `${chalk.bold("Background agent supervisor")}  ${running} running  ${sessions.length} shown`,
+        );
+        logger.log(chalk.gray(`  dir ${backgroundAgentsDir()}`));
+        printBackgroundAgents(sessions);
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+
+  daemon
+    .command("view <id>")
+    .description("Show a detailed background agent view")
+    .option("-n, --lines <n>", "Recent log lines to include", "40")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const {
+          readBackgroundAgentState,
+          effectiveBackgroundAgentState,
+          readBackgroundAgentLog,
+        } = await loadSupervisor();
+        const session = effectiveBackgroundAgentState(
+          readBackgroundAgentState(id),
+        );
+        if (!session) throw new Error(`Background agent not found: ${id}`);
+        const lines = parseLines(options.lines, 40);
+        const log = readBackgroundAgentLog(id, { lines });
+        if (options.json) {
+          console.log(JSON.stringify({ session, log }, null, 2));
+          return;
+        }
+        logger.log(formatBackgroundAgentDetails(session, log));
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+
+  daemon
+    .command("rename <id> <title...>")
+    .description("Rename a background agent session")
+    .option("--json", "Output as JSON")
+    .action(async (id, title, options) => {
+      try {
+        const { renameBackgroundAgent } = await loadSupervisor();
+        const state = renameBackgroundAgent(
+          id,
+          Array.isArray(title) ? title.join(" ") : title,
+        );
+        if (options.json) {
+          console.log(JSON.stringify(state, null, 2));
+          return;
+        }
+        logger.log(chalk.green(`Renamed background agent ${state.id}`));
+        logger.log(chalk.gray(`  ${state.title}`));
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+
+  daemon
+    .command("resume <id> <prompt...>")
+    .description(
+      "Continue a finished/crashed background session as a new background run on the same conversation",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (id, prompt, options) => {
+      try {
+        const { resumeBackgroundAgent } = await loadSupervisor();
+        const state = resumeBackgroundAgent(
+          id,
+          Array.isArray(prompt) ? prompt.join(" ") : prompt,
+        );
+        if (options.json) {
+          console.log(JSON.stringify(state, null, 2));
+          return;
+        }
+        logger.log(
+          chalk.green(`Resumed session as background agent ${state.id}`),
+        );
+        logger.log(chalk.gray(`  session ${state.sessionId}`));
+        logger.log(chalk.gray(`  attach: cc attach ${state.id}`));
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+
+  daemon
+    .command("stop [id]")
+    .description("Stop one background agent, or all running agents with --any")
+    .option("--any", "Stop all running background agents")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const { listBackgroundAgents, stopBackgroundAgent } =
+          await loadSupervisor();
+        if (!id && options.any !== true) {
+          throw new Error("daemon stop requires <id> or --any");
+        }
+        const targets = options.any
+          ? listBackgroundAgents().map((s) => s.id)
+          : [id];
+        const results = [];
+        for (const target of targets) {
+          results.push(stopBackgroundAgent(target));
+        }
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+          return;
+        }
+        if (results.length === 0) {
+          logger.log(chalk.gray("No running background agents."));
+          return;
+        }
+        for (const result of results) {
+          if (result.stopped) {
+            logger.log(chalk.green(`Stopped background agent ${result.id}`));
+          } else {
+            logger.log(chalk.gray(`${result.id} is already ${result.status}`));
+          }
+        }
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/command.js

@@ -103,7 +103,10 @@ export function registerCommandCommand(program) {
     .option("--no-bang", "Do not execute !`cmd` bang segments")
     .option("--output-format <fmt>", "text | json | stream-json", "text")
     .option("--model <model>", "Override the model")
-    .option("--permission-mode <mode>", "ApprovalGate tier (see cc agent)")
+    .option(
+      "--permission-mode <mode>",
+      "manual | auto | dontAsk | default | plan | acceptEdits | bypassPermissions",
+    )
     .action(async (name, args, options) => {
       try {
         const { getCommand, expandCommand } =

package/src/commands/complete.js

@@ -0,0 +1,147 @@
+/**
+ * `cc complete` — inline code completion (fill-in-the-middle) for IDE ghost-text.
+ *
+ * Reads a JSON request `{prefix, suffix, language, path}` on stdin and prints the
+ * raw code to insert at the cursor (or `--json` for a structured reply). The IDE
+ * side (VS Code InlineCompletionItemProvider / JetBrains InlineCompletionProvider)
+ * builds the request from the editor context and renders the reply as a ghost
+ * suggestion. Backend reuse: the SAME provider routing + config as `cc ask`
+ * (queryLLM), so it honors the user's configured LLM/provider/key with no new auth.
+ *
+ * Manual-trigger v1 (the IDE binds it to a keystroke), so a slow/expensive chat
+ * model is acceptable; a fast local FIM model (e.g. ollama qwen2.5-coder) just
+ * makes it snappier.
+ */
+import { loadConfig } from "../lib/config-manager.js";
+import { resolveOllamaBaseUrl, queryLLM } from "./ask.js";
+
+/** Hard cap so a runaway model can't flood the editor with a whole file. */
+export const MAX_COMPLETION_CHARS = 2000;
+
+/**
+ * Build the chat prompt that asks the model to fill in code at the cursor.
+ * The cursor is marked with a sentinel between prefix and suffix so a plain
+ * chat model (no native FIM) still has the full bidirectional context.
+ */
+export function buildFimPrompt(prefix, suffix, language) {
+  const lang = (language || "").trim() || "the given language";
+  const before = prefix == null ? "" : String(prefix);
+  const after = suffix == null ? "" : String(suffix);
+  return [
+    `You are an inline code-completion engine for ${lang}.`,
+    "Continue the code at the position marked <CURSOR>.",
+    "Output ONLY the raw code that should be inserted at the cursor —",
+    "no explanations, no markdown code fences, and do not repeat the",
+    "surrounding code. If nothing should be inserted, output nothing.",
+    "",
+    `${before}<CURSOR>${after}`,
+  ].join("\n");
+}
+
+/**
+ * Turn the model's raw reply into an insertion string: strip an accidental
+ * markdown fence, drop any echoed <CURSOR> sentinel, and hard-cap the length.
+ *
+ * We deliberately do NOT trim a suffix overlap here — a naive "completion ends
+ * with the suffix's first line" cut eats legitimate trailing tokens (e.g. an
+ * `if`-block's own `}`), so duplication is left to the prompt's "do not repeat
+ * the surrounding code" instruction instead.
+ */
+export function cleanCompletion(raw) {
+  if (!raw) return "";
+  let s = String(raw);
+  // A model that ignored "no fences" wraps the code in ```lang … ```.
+  s = s.replace(/^\s*```[^\n]*\n?/, "").replace(/\n?```\s*$/, "");
+  s = s.replace(/<CURSOR>/g, "");
+  if (s.length > MAX_COMPLETION_CHARS) s = s.slice(0, MAX_COMPLETION_CHARS);
+  // Trim trailing whitespace only — leading indentation is meaningful.
+  return s.replace(/\s+$/, "");
+}
+
+/** Read a JSON request from stdin (empty string when nothing is piped in). */
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => (data += c));
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", () => resolve(data));
+  });
+}
+
+export function registerCompleteCommand(program) {
+  program
+    .command("complete")
+    .description(
+      "Inline code completion (FIM) for IDE ghost-text: reads {prefix,suffix,language} JSON on stdin, prints the code to insert.",
+    )
+    .option("--provider <provider>", "override the LLM provider")
+    .option("--model <model>", "override the model")
+    .option("--base-url <url>", "override the provider base URL")
+    .option("--api-key <key>", "override the API key")
+    .option("--json", "output {completion,model,provider} as JSON")
+    .action(async (options) => {
+      const config = await loadConfig();
+      const rawIn = await readStdin();
+      let req = {};
+      try {
+        req = rawIn.trim() ? JSON.parse(rawIn) : {};
+      } catch {
+        req = {};
+      }
+      const prefix = typeof req.prefix === "string" ? req.prefix : "";
+      const suffix = typeof req.suffix === "string" ? req.suffix : "";
+      const language = req.language || "";
+
+      const emit = (completion, extra = {}) => {
+        if (options.json) {
+          process.stdout.write(JSON.stringify({ completion, ...extra }));
+        } else {
+          process.stdout.write(completion);
+        }
+      };
+
+      if (!prefix && !suffix) {
+        emit(""); // nothing to complete around
+        return;
+      }
+
+      const provider = options.provider || config.llm?.provider || "ollama";
+      const resolvedOptions = {
+        provider,
+        model:
+          options.model ||
+          config.llm?.model ||
+          (provider === "ollama" ? "qwen2.5-coder" : undefined),
+        apiKey: options.apiKey || config.llm?.apiKey,
+      };
+      resolvedOptions.baseUrl =
+        provider === "ollama"
+          ? resolveOllamaBaseUrl({ options, config })
+          : options.baseUrl || config.llm?.baseUrl;
+
+      try {
+        const reply = await queryLLM(
+          buildFimPrompt(prefix, suffix, language),
+          resolvedOptions,
+        );
+        emit(cleanCompletion(reply), {
+          model: resolvedOptions.model,
+          provider,
+        });
+      } catch (e) {
+        // Ghost-text must fail quiet: an empty suggestion, not an error dump in
+        // the editor. --json carries the reason for debugging.
+        if (options.json) {
+          emit("", { error: String(e?.message || e) });
+        } else {
+          process.stderr.write(String(e?.message || e) + "\n");
+          process.exitCode = 1;
+        }
+      }
+    });
+}