chainlesschain 0.162.148 → 0.162.149

package/src/commands/agent.js

@@ -177,6 +177,19 @@ export function registerAgentCommand(program) {
       "Run shell commands in an ephemeral Docker sandbox (network disabled by default)",
     )
     .option("--sandbox-network", "Allow network access inside --sandbox")
+    .option(
+      "--otlp <file>",
+      "Write the agent run's OpenTelemetry spans (model/tool/retry) as OTLP/JSON to <file>",
+    )
+    .option(
+      "--auto-rewake",
+      "When an async `asyncRewake` hook (e.g. a background test) fails at turn end, re-engage the agent to fix it (bounded by --max-rewakes)",
+    )
+    .option(
+      "--max-rewakes <n>",
+      "Max auto-rewake re-drives per run (default 1); implies --auto-rewake",
+      (v) => parseInt(v, 10),
+    )
     .option(
       "--bg, --background",
       "Start as a detached background agent and return its id immediately",
@@ -252,7 +265,7 @@ export function registerAgentCommand(program) {
     )
     .option(
       "--fallback-model <model>",
-      "Backup model(s) to try in order when the primary fails (transient error or model-not-found). Repeatable or comma-separated; up to 3. Defaults to config llm.fallbackModels. claude-code parity.",
+      "Backup model(s) to try in order when the primary fails (transient error or model-not-found). Repeatable or comma-separated; up to 3. A `provider:model` entry (e.g. openai:gpt-4o) falls back cross-provider, using that provider's API key from its env var (skipped if unset — never reuses the primary key). Defaults to config llm.fallbackModels.",
       (val, prev) => (prev || []).concat([val]),
     )
     .option(
@@ -509,6 +522,7 @@ export function registerAgentCommand(program) {
       // over a settings model. Applied once here so every branch (headless +
       // interactive, which all read options.model) picks it up; env vars are
       // set on the process so the agent loop + child tools inherit them.
+      let settingsSandbox = null;
       try {
         const { loadSettingsConfig } =
           await import("../lib/settings-loader.cjs");
@@ -520,6 +534,7 @@ export function registerAgentCommand(program) {
           process.env[k] = v;
         }
         if (!options.model && sc.model) options.model = sc.model;
+        settingsSandbox = sc.sandbox || null;
       } catch {
         // settings overrides are best-effort 鈥?never block the run
       }
@@ -651,10 +666,22 @@ export function registerAgentCommand(program) {
       const fallbackChatFn = fallbackModels.length
         ? makeFallbackChatFn({
             fallbackModels,
-            onFallback: ({ from, to, error }) =>
-              process.stderr.write(
-                `Note: model "${from}" failed (${error}); retrying with fallback model "${to}".\n`,
-              ),
+            onFallback: ({
+              from,
+              to,
+              error,
+              skipped,
+              reason,
+              crossProvider,
+            }) =>
+              skipped
+                ? process.stderr.write(
+                    `Note: fallback "${to}" skipped (${reason}).\n`,
+                  )
+                : process.stderr.write(
+                    `Note: model "${from}" failed (${error}); retrying with ` +
+                      `${crossProvider ? "cross-provider " : ""}fallback "${to}".\n`,
+                  ),
           })
         : undefined;
 
@@ -822,6 +849,7 @@ export function registerAgentCommand(program) {
         const agentSandbox = normalizeAgentSandbox(options.sandbox, {
           cwd: process.cwd(),
           network: options.sandboxNetwork === true,
+          settings: settingsSandbox,
         });
         // Resume requested onto a session with no headless (JSONL) transcript?
         // Warn instead of silently starting empty 鈥?headless resume rebuilds
@@ -864,6 +892,16 @@ export function registerAgentCommand(program) {
           additionalDirectories,
           sandbox: agentSandbox,
           autoCheckpoint,
+          // --otlp <file>: capture + export the run's OTel spans as OTLP/JSON.
+          otlp: options.otlp || null,
+          // --auto-rewake / --max-rewakes: bounded re-drive on async-hook failure.
+          // --max-rewakes implies --auto-rewake (a positive budget turns it on).
+          autoRewake:
+            options.autoRewake === true ||
+            (Number.isFinite(options.maxRewakes) && options.maxRewakes > 0),
+          maxRewakes: Number.isFinite(options.maxRewakes)
+            ? options.maxRewakes
+            : undefined,
           maxTurns,
           // commander maps --no-file-refs 鈫?options.fileRefs === false
           expandFileRefs: options.fileRefs !== false,
@@ -975,6 +1013,7 @@ export function registerAgentCommand(program) {
         sandbox: normalizeAgentSandbox(options.sandbox, {
           cwd: process.cwd(),
           network: options.sandboxNetwork === true,
+          settings: settingsSandbox,
         }),
         autoCheckpoint,
         // --vim: start the REPL in vim-mode editing (also CC_VIM=1 or /vim).

package/src/commands/codeintel.js

@@ -0,0 +1,252 @@
+/**
+ * cc code-intel — semantic code navigation via the Language Server Protocol.
+ *
+ * End-to-end surface for the LSP code-intelligence layer (Phase 2 of the CLI
+ * optimization plan). Proves the stack works without touching the contended
+ * agent-core; the agent `code_intelligence` tool is wired separately.
+ *
+ *   cc code-intel status                          # which servers are installed
+ *   cc code-intel def <file> <line> <col>         # go to definition
+ *   cc code-intel refs <file> <line> <col>        # find references
+ *   cc code-intel hover <file> <line> <col>       # type / doc info
+ *   cc code-intel symbols <file>                  # document symbols
+ *   cc code-intel wsymbols <query>                # workspace symbol search
+ *   cc code-intel diag <file>                     # diagnostics
+ *   cc code-intel rename <file> <line> <col> <newName>   # preview a rename
+ *
+ * Positions are 1-based (line/col), matching editor gutters.
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+function num(v, name) {
+  const n = Number.parseInt(v, 10);
+  if (!Number.isFinite(n) || n < 1) {
+    throw new Error(`${name} must be a positive integer (1-based), got "${v}"`);
+  }
+  return n;
+}
+
+async function withCI(fn, { json } = {}) {
+  const { CodeIntelligence } = await import("../lib/lsp/code-intelligence.js");
+  // coldStart: each CLI invocation spawns a fresh server, so wait for the
+  // project to load before querying (the warm agent path leaves this off).
+  const ci = new CodeIntelligence({
+    projectRoot: process.cwd(),
+    coldStart: true,
+  });
+  try {
+    const result = await fn(ci);
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    }
+    return result;
+  } finally {
+    await ci.dispose();
+  }
+}
+
+function reportUnavailable(res) {
+  logger.warn(
+    chalk.yellow(`LSP unavailable: ${res.reason}`) +
+      chalk.gray(
+        "\n  → falling back to text search (`cc search` / agent search_files)",
+      ),
+  );
+  process.exitCode = 3;
+}
+
+function fmtLoc(l) {
+  const pos = `${chalk.cyan(l.file)}:${chalk.yellow(l.line)}:${l.col}`;
+  return l.snippet ? `${pos}  ${chalk.gray(l.snippet)}` : pos;
+}
+
+export function registerCodeIntelCommand(program) {
+  const ci = program
+    .command("code-intel")
+    .alias("ci")
+    .description(
+      "Semantic code navigation via LSP (definition/references/symbols/diagnostics)",
+    );
+
+  ci.command("status")
+    .description("Show which language servers are installed and detectable")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      const { probeServers, supportedExtensions } =
+        await import("../lib/lsp/lsp-server-registry.js");
+      // Surface plugin-contributed servers too (Phase 3: .lsp.json).
+      const { ensurePluginLspServers } =
+        await import("../lib/plugin-runtime/lsp.js");
+      ensurePluginLspServers({ cwd: process.cwd() });
+      const servers = probeServers(process.cwd());
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            { servers, extensions: supportedExtensions() },
+            null,
+            2,
+          ),
+        );
+        return;
+      }
+      logger.log(chalk.bold("LSP servers:"));
+      for (const s of servers) {
+        const mark = s.available ? chalk.green("✔") : chalk.gray("✖");
+        const where = s.available
+          ? chalk.gray(s.command)
+          : chalk.gray("not installed");
+        logger.log(`  ${mark} ${s.id.padEnd(28)} ${where}`);
+      }
+      const anyAvail = servers.some((s) => s.available);
+      if (!anyAvail) {
+        logger.log(
+          chalk.yellow(
+            "\nNo language servers found. Install one to enable semantic navigation, e.g.:\n",
+          ) + chalk.gray("  npm i -g typescript-language-server typescript"),
+        );
+      }
+    });
+
+  ci.command("def <file> <line> <col>")
+    .description("Go to definition of the symbol at file:line:col")
+    .option("--json", "Output as JSON")
+    .action(async (file, line, col, options) => {
+      const res = await withCI(
+        (c) => c.definition(file, num(line, "line"), num(col, "col")),
+        options,
+      );
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      if (!res.locations.length)
+        return logger.log(chalk.gray("No definition found."));
+      for (const l of res.locations) logger.log(fmtLoc(l));
+    });
+
+  ci.command("refs <file> <line> <col>")
+    .description("Find references to the symbol at file:line:col")
+    .option("--no-decl", "Exclude the declaration itself")
+    .option("--json", "Output as JSON")
+    .action(async (file, line, col, options) => {
+      const res = await withCI(
+        (c) =>
+          c.references(file, num(line, "line"), num(col, "col"), {
+            includeDeclaration: options.decl !== false,
+          }),
+        options,
+      );
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      logger.log(chalk.bold(`${res.locations.length} reference(s):`));
+      for (const l of res.locations) logger.log("  " + fmtLoc(l));
+    });
+
+  ci.command("hover <file> <line> <col>")
+    .description("Show type/doc info for the symbol at file:line:col")
+    .option("--json", "Output as JSON")
+    .action(async (file, line, col, options) => {
+      const res = await withCI(
+        (c) => c.hover(file, num(line, "line"), num(col, "col")),
+        options,
+      );
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      logger.log(res.contents || chalk.gray("No hover info."));
+    });
+
+  ci.command("symbols <file>")
+    .description("List symbols declared in a document")
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+      const res = await withCI((c) => c.documentSymbols(file), options);
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      for (const s of res.symbols) {
+        const loc = chalk.gray(`${s.line}:${s.col}`);
+        const kind = chalk.magenta(s.kind.padEnd(10));
+        const container = s.container ? chalk.gray(` (${s.container})`) : "";
+        logger.log(`  ${loc}  ${kind} ${s.name}${container}`);
+      }
+    });
+
+  ci.command("wsymbols <query>")
+    .description("Search symbols across the workspace by name")
+    .option("--json", "Output as JSON")
+    .action(async (query, options) => {
+      const res = await withCI((c) => c.workspaceSymbols(query), options);
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      logger.log(chalk.bold(`${res.symbols.length} symbol(s):`));
+      for (const s of res.symbols) {
+        logger.log(
+          `  ${chalk.magenta(s.kind.padEnd(10))} ${s.name}  ${chalk.gray(`${s.file}:${s.line}`)}`,
+        );
+      }
+    });
+
+  ci.command("diag <file>")
+    .description("Show diagnostics (errors/warnings) for a file")
+    .option(
+      "--timeout <ms>",
+      "How long to wait for the server to publish",
+      "5000",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+      const res = await withCI(
+        (c) =>
+          c.diagnostics(file, { timeoutMs: num(options.timeout, "timeout") }),
+        options,
+      );
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      if (!res.diagnostics.length)
+        return logger.log(chalk.green("No diagnostics."));
+      for (const d of res.diagnostics) {
+        const sev =
+          d.severity === "error"
+            ? chalk.red(d.severity)
+            : d.severity === "warning"
+              ? chalk.yellow(d.severity)
+              : chalk.gray(d.severity);
+        logger.log(
+          `  ${chalk.gray(`${d.line}:${d.col}`)} ${sev} ${d.message}${d.code ? chalk.gray(` [${d.code}]`) : ""}`,
+        );
+      }
+    });
+
+  ci.command("rename <file> <line> <col> <newName>")
+    .description(
+      "Preview a symbol rename across files (does NOT apply the edit)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (file, line, col, newName, options) => {
+      const res = await withCI(
+        (c) =>
+          c.renamePreview(file, num(line, "line"), num(col, "col"), newName),
+        options,
+      );
+      if (!res.available) return reportUnavailable(res);
+      if (options.json) return;
+      const total = res.edits.reduce((n, f) => n + f.edits.length, 0);
+      logger.log(
+        chalk.bold(
+          `Rename would touch ${res.edits.length} file(s), ${total} edit(s):`,
+        ),
+      );
+      for (const f of res.edits) {
+        logger.log(`  ${chalk.cyan(f.file)} — ${f.edits.length} edit(s)`);
+        for (const e of f.edits) {
+          logger.log(chalk.gray(`      ${e.line}:${e.col} → "${e.newText}"`));
+        }
+      }
+      logger.log(
+        chalk.gray(
+          "\n(preview only — apply with your editor or agent edit tools)",
+        ),
+      );
+    });
+
+  return ci;
+}

package/src/commands/eval.js

@@ -0,0 +1,248 @@
+/**
+ * `cc eval` — reliability eval harness (Phase 7). Runs a suite of self-checking
+ * coding tasks against the real agent and reports the task-success rate.
+ *
+ * Each task gets a fresh temp workspace; the agent is invoked headlessly
+ * (`cc agent -p` in that cwd with acceptEdits so it can write files) and the
+ * task's objective check() decides pass/fail. `--dry-run` swaps in a no-op agent
+ * so the harness + report can be exercised without a model.
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { spawn } from "child_process";
+import { runEvalSuite } from "../lib/eval/runner.js";
+import { getSuite } from "../lib/eval/tasks.js";
+import {
+  TelemetryRecorder,
+  formatTelemetry,
+} from "../lib/telemetry/span-recorder.js";
+import { computeTrend, formatTrend } from "../lib/eval/trend.js";
+
+/** Append a run summary as one JSONL line to the history file. */
+function appendHistory(file, record) {
+  fs.appendFileSync(file, JSON.stringify(record) + "\n", "utf8");
+}
+
+/** Read a JSONL eval-history file into an array of run records (skips bad lines). */
+function readHistory(file) {
+  if (!fs.existsSync(file)) return [];
+  const out = [];
+  for (const line of fs.readFileSync(file, "utf8").split(/\r?\n/)) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      out.push(JSON.parse(t));
+    } catch {
+      /* skip a corrupt history line rather than abort the report */
+    }
+  }
+  return out;
+}
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// This file is src/commands/eval.js → the CLI entry is bin/chainlesschain.js.
+const BIN = path.resolve(__dirname, "..", "..", "bin", "chainlesschain.js");
+
+/**
+ * Build a runAgent that shells out to a headless `cc agent -p` in the task's
+ * workspace. acceptEdits lets it write files without an interactive prompt.
+ */
+function makeHeadlessRunAgent(opts = {}) {
+  return function runAgent({ prompt, cwd, timeoutMs }) {
+    return new Promise((resolve) => {
+      const args = [
+        BIN,
+        "agent",
+        "-p",
+        prompt,
+        "--permission-mode",
+        "acceptEdits",
+        "--output-format",
+        "text",
+      ];
+      if (opts.model) args.push("--model", opts.model);
+      if (opts.provider) args.push("--provider", opts.provider);
+      const child = spawn(process.execPath, args, {
+        cwd,
+        env: { ...process.env, CLAUDECODE: "1" },
+        windowsHide: true,
+      });
+      let out = "";
+      let err = "";
+      let settled = false;
+      const done = (result) => {
+        if (settled) return;
+        settled = true;
+        resolve(result);
+      };
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+          /* already gone */
+        }
+        done({
+          ok: false,
+          output: out,
+          error: `timed out after ${timeoutMs || 120000}ms`,
+        });
+      }, timeoutMs || 120000);
+      if (typeof timer.unref === "function") timer.unref();
+      child.stdout?.on("data", (d) => (out += d.toString("utf8")));
+      child.stderr?.on("data", (d) => (err += d.toString("utf8")));
+      child.on("error", (e) => {
+        clearTimeout(timer);
+        done({ ok: false, output: out, error: e.message });
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        done({ ok: code === 0, output: out, error: code === 0 ? null : err });
+      });
+    });
+  };
+}
+
+export function registerEvalCommand(program, { logger } = {}) {
+  const log = logger || console;
+  program
+    .command("eval")
+    .description(
+      "Run the reliability eval suite (self-checking coding tasks) and report the task-success rate",
+    )
+    .option("--suite <name>", "Suite to run", "builtin")
+    .option("--model <model>", "Model for the agent runs")
+    .option("--provider <provider>", "Provider for the agent runs")
+    .option("--json", "Output the summary as JSON")
+    .option("--keep", "Keep the per-task temp workspaces (debug)")
+    .option(
+      "--otlp <file>",
+      "Write OpenTelemetry (OTLP/JSON) spans for the run to a file",
+    )
+    .option(
+      "--dry-run",
+      "Use a no-op agent (exercise the harness/report without a model)",
+    )
+    .option(
+      "--history <file>",
+      "Append this run's summary (JSONL) for trend tracking",
+    )
+    .option(
+      "--label <label>",
+      "Tag this run in the history (e.g. a version/commit)",
+    )
+    .option(
+      "--trend",
+      "Report the pass-rate trend from --history instead of running (CI gate)",
+    )
+    .option(
+      "--regression-threshold <pct>",
+      "With --trend: pass-rate drop (in points) that fails the gate on its own",
+      "0",
+    )
+    .action(async (options) => {
+      // Trend mode: don't run the suite — read the recorded history and report
+      // the pass-rate trend + per-task regressions. This is the release-pipeline
+      // consumer (the runs themselves need a real model; the report is pure).
+      if (options.trend) {
+        if (!options.history) {
+          (log.error || console.error)("--trend requires --history <file>");
+          process.exitCode = 1;
+          return;
+        }
+        const runs = readHistory(options.history);
+        const threshold =
+          Math.max(0, Number(options.regressionThreshold) || 0) / 100;
+        const trend = computeTrend(runs, { regressionThreshold: threshold });
+        if (options.json) console.log(JSON.stringify(trend, null, 2));
+        else (log.log || console.log)(formatTrend(trend));
+        if (trend.regressed) process.exitCode = 1;
+        return;
+      }
+
+      let tasks;
+      try {
+        tasks = getSuite(options.suite);
+      } catch (err) {
+        log.error ? log.error(err.message) : console.error(err.message);
+        process.exitCode = 1;
+        return;
+      }
+      const runAgent = options.dryRun
+        ? async () => ({ ok: true, output: "(dry-run: no agent)" })
+        : makeHeadlessRunAgent({
+            model: options.model,
+            provider: options.provider,
+          });
+
+      // OTel-shaped telemetry for the run (per-task span + failure class).
+      const recorder = new TelemetryRecorder({ serviceName: "cc-eval" });
+
+      const summary = await runEvalSuite(tasks, {
+        runAgent,
+        recorder,
+        keepWorkspaces: options.keep === true,
+        onResult: options.json
+          ? undefined
+          : (r) =>
+              (log.info || console.log)(
+                `  ${r.pass ? "✔" : "✗"} ${r.id} (${r.ms}ms)` +
+                  (r.error
+                    ? ` — ${r.error}`
+                    : r.detail
+                      ? ` — ${r.detail}`
+                      : ""),
+              ),
+      });
+
+      if (options.otlp) {
+        try {
+          fs.writeFileSync(
+            options.otlp,
+            JSON.stringify(recorder.toOtlp(), null, 2),
+            "utf8",
+          );
+        } catch (e) {
+          (log.error || console.error)(`  otlp write failed: ${e.message}`);
+        }
+      }
+
+      // Append to the trend history (a compact record — pass counts + per-task
+      // pass/fail + a timestamp/label — so `cc eval --trend` can chart it).
+      if (options.history) {
+        try {
+          appendHistory(options.history, {
+            ranAt: new Date().toISOString(),
+            label: options.label || null,
+            passed: summary.passed,
+            total: summary.total,
+            passRate: summary.passRate,
+            results: (summary.results || []).map((r) => ({
+              id: r.id,
+              pass: r.pass,
+            })),
+          });
+        } catch (e) {
+          (log.error || console.error)(`  history write failed: ${e.message}`);
+        }
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify(summary, null, 2));
+      } else {
+        // Per-task lines already streamed via onResult; print the summary +
+        // the telemetry metrics (durations / failure classification).
+        const pct = (summary.passRate * 100).toFixed(1);
+        (log.log || console.log)(
+          `\nEval: ${summary.passed}/${summary.total} passed (${pct}%) in ${summary.ms}ms`,
+        );
+        if (summary.telemetry) {
+          (log.log || console.log)("\n" + formatTelemetry(summary.telemetry));
+        }
+      }
+      // Non-zero exit when not every task passed — usable as a CI gate.
+      if (summary.passed < summary.total) process.exitCode = 1;
+    });
+  return program;
+}