chainlesschain 0.162.40 → 0.162.42

package/src/commands/mcp.js

@@ -214,6 +214,63 @@ export function registerMcpCommand(program) {
       }
     });
 
+  // mcp serve — expose THIS machine's files as an MCP server
+  mcp
+    .command("serve")
+    .description(
+      "Expose local file tools (read/list/search/write, root-confined) as a Streamable-HTTP MCP server for other clients",
+    )
+    .option("--port <n>", "Port to listen on (default: random free port)", "0")
+    .option("--root <dir>", "Serve root directory (default: cwd)")
+    .option("--read-only", "Disable the write_file tool")
+    .option("--token <token>", "Fixed Bearer token (default: random)")
+    .option("--no-auth", "Disable Bearer auth (server binds 127.0.0.1 only)")
+    .action(async (options) => {
+      try {
+        const { startMcpServe } = await import("../lib/mcp-serve.js");
+        const handle = await startMcpServe({
+          root: options.root,
+          port: Number(options.port) || 0,
+          readOnly: Boolean(options.readOnly),
+          token: options.auth === false ? false : options.token || null,
+        });
+        logger.log(chalk.bold("MCP server ready (Streamable-HTTP)"));
+        logger.log(`  URL:   ${chalk.cyan(handle.url)}`);
+        logger.log(`  Root:  ${handle.root}${handle.readOnly ? "  (read-only)" : ""}`);
+        if (handle.token) {
+          logger.log(`  Auth:  Bearer ${handle.token}`);
+        } else {
+          logger.log(chalk.yellow("  Auth:  disabled (--no-auth)"));
+        }
+        logger.log(chalk.gray("\nConnect from another cc via --mcp-config:"));
+        logger.log(
+          chalk.gray(
+            JSON.stringify(
+              {
+                mcpServers: {
+                  ccfiles: {
+                    transport: "http",
+                    url: handle.url,
+                    ...(handle.token
+                      ? { headers: { Authorization: `Bearer ${handle.token}` } }
+                      : {}),
+                  },
+                },
+              },
+              null,
+              2,
+            ),
+          ),
+        );
+        logger.log(chalk.gray("\nCtrl+C to stop."));
+        // keep the process alive until killed
+        await new Promise(() => {});
+      } catch (err) {
+        logger.error(chalk.red(`mcp serve failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
   // mcp servers — list configured servers
   mcp
     .command("servers")

package/src/commands/memory.js

@@ -53,6 +53,68 @@ export function registerMemoryCommand(program) {
     .command("memory")
     .description("Persistent memory and daily notes");
 
+  // memory files — observability for the cc.md project-memory loader
+  memory
+    .command("files")
+    .description(
+      "List the project-memory files cc agent auto-loads here (cc.md hierarchy + imports + path-scoped rules)",
+    )
+    .option("--cwd <dir>", "Inspect from this directory instead of cwd")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { loadProjectInstructions } = await import(
+          "../lib/project-instructions.js"
+        );
+        const cwd = options.cwd || process.cwd();
+        const loaded = loadProjectInstructions({ cwd });
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                cwd,
+                files: loaded.files.map((f) => ({
+                  path: f.path,
+                  scope: f.scope,
+                  bytes: f.bytes,
+                  truncated: f.truncated,
+                })),
+                warnings: loaded.warnings,
+              },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+        if (!loaded.files.length) {
+          logger.log(
+            "No project-memory files found — run `cc init` to generate a cc.md.",
+          );
+          return;
+        }
+        logger.log(chalk.bold("Project memory loaded by cc agent:"));
+        for (const f of loaded.files) {
+          logger.log(
+            `  [${f.scope.padEnd(7)}] ${f.path}  ${chalk.gray(
+              `${f.bytes} bytes${f.truncated ? " (truncated)" : ""}`,
+            )}`,
+          );
+        }
+        for (const w of loaded.warnings) {
+          logger.log(chalk.yellow(`  ⚠ ${w}`));
+        }
+        logger.log(
+          chalk.gray(
+            "Disable with CC_PROJECT_MEMORY=0 · file precedence: cc.md > CLAUDE.md > AGENTS.md",
+          ),
+        );
+      } catch (err) {
+        logger.error(`memory files failed: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
   // memory show
   memory
     .command("show", { isDefault: true })

package/src/commands/session.js

@@ -343,6 +343,76 @@ export function registerSessionCommand(program) {
       }
     });
 
+  // session search — full-text search across agent transcripts (JSONL store)
+  session
+    .command("search")
+    .description(
+      "Full-text search across agent session transcripts (JSONL --resume store)",
+    )
+    .argument("<query>", "Text to find (case-insensitive)")
+    .option("-n, --limit <n>", "Max matches", "20")
+    .option("--sessions <n>", "Max recent sessions to scan", "200")
+    .option("--json", "Output as JSON")
+    .action(async (query, options) => {
+      try {
+        const store = await import("../harness/jsonl-session-store.js");
+        const q = String(query).toLowerCase();
+        const limit = Number(options.limit) || 20;
+        const sessions = store.listJsonlSessions({
+          limit: Number(options.sessions) || 200,
+        });
+        const matches = [];
+        for (const s of sessions) {
+          if (matches.length >= limit) break;
+          for (const ev of store.readEvents(s.id)) {
+            if (matches.length >= limit) break;
+            if (ev.type !== "user_message" && ev.type !== "assistant_message")
+              continue;
+            const text =
+              typeof ev.data?.content === "string"
+                ? ev.data.content
+                : JSON.stringify(ev.data?.content || "");
+            const idx = text.toLowerCase().indexOf(q);
+            if (idx === -1) continue;
+            const from = Math.max(0, idx - 30);
+            matches.push({
+              session: s.id,
+              title: s.title,
+              role: ev.type === "user_message" ? "user" : "assistant",
+              when: ev.timestamp ? new Date(ev.timestamp).toISOString() : "",
+              preview: text
+                .slice(from, idx + q.length + 50)
+                .replace(/\s+/g, " ")
+                .trim(),
+            });
+          }
+        }
+        if (options.json) {
+          console.log(JSON.stringify({ query, matches }, null, 2));
+          return;
+        }
+        if (!matches.length) {
+          logger.log(`No matches for "${query}".`);
+          return;
+        }
+        logger.log(chalk.bold(`Matches for "${query}":`));
+        for (const m of matches) {
+          logger.log(
+            `  ${chalk.cyan(m.session)} ${chalk.gray(`[${m.role}${m.when ? ` ${m.when.slice(0, 16)}` : ""}]`)}`,
+          );
+          logger.log(`    …${m.preview}…`);
+        }
+        logger.log(
+          chalk.gray(
+            `\n${matches.length} match(es) · resume one with: cc agent --resume <session>`,
+          ),
+        );
+      } catch (err) {
+        logger.error(`session search failed: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
   // session delete
   session
     .command("delete")

package/src/lib/agent-core.js

@@ -18,6 +18,7 @@ export {
   getBaseSystemPrompt,
   buildSystemPrompt,
   executeTool,
+  computeProposedEdit,
   classifyError,
   isValidPackageName,
   chatWithTools,

package/src/lib/init-ai-refine.js

@@ -0,0 +1,66 @@
+/**
+ * `cc init --ai` — agent-enhanced inventory (claude /init parity, module 99
+ * §5.2). Runs AFTER the offline census wrote the starter cc.md: a bounded
+ * headless agent reads the repo (README, entry files) and rewrites cc.md so
+ * the Conventions section holds real, observed conventions instead of the
+ * "(add project rules here)" placeholder.
+ *
+ * Self-reference guard: the child run executes with CC_PROJECT_MEMORY=0 so
+ * the half-baked cc.md being refined is NOT injected into the very agent
+ * refining it. Restored in finally.
+ *
+ * Offline inventory stays the `cc init` default — this is strictly opt-in
+ * (needs a reachable LLM).
+ */
+
+export const AI_REFINE_MAX_TURNS = 12;
+export const AI_REFINE_TOOLS = [
+  "read_file",
+  "list_dir",
+  "search_files",
+  "write_file",
+];
+
+export function buildRefinePrompt() {
+  return [
+    "You are refining this project's memory file `cc.md` (it was just generated from an offline folder census).",
+    "Steps:",
+    "1. read_file cc.md to see the current draft.",
+    "2. Read the README and one or two key entry/config files to learn the project's real conventions (code style, commit format, how to run tests, architecture notes worth remembering).",
+    "3. write_file cc.md with the refined version: KEEP the existing sections and data, but replace the placeholder under `## Conventions` with concrete, observed conventions (5-10 short bullets max). Do not invent facts you did not see.",
+    "Keep the file concise — it is loaded into every agent run.",
+  ].join("\n");
+}
+
+/**
+ * Run the refine pass.
+ * @param {object} opts { cwd, provider?, model?, baseUrl?, apiKey?,
+ *                        maxTurns?, runHeadless? (test seam) }
+ * @returns {Promise<{exitCode:number, result:string, isError:boolean}>}
+ */
+export async function aiRefineMemoryFile(opts = {}) {
+  const run =
+    opts.runHeadless ||
+    (await import("../runtime/headless-runner.js")).runAgentHeadless;
+
+  const prev = process.env.CC_PROJECT_MEMORY;
+  process.env.CC_PROJECT_MEMORY = "0"; // self-reference guard
+  try {
+    return await run({
+      prompt: buildRefinePrompt(),
+      cwd: opts.cwd || process.cwd(),
+      provider: opts.provider || undefined,
+      model: opts.model || undefined,
+      baseUrl: opts.baseUrl || undefined,
+      apiKey: opts.apiKey || undefined,
+      permissionMode: "acceptEdits", // write_file must work headless
+      allowedTools: AI_REFINE_TOOLS,
+      maxTurns: opts.maxTurns || AI_REFINE_MAX_TURNS,
+      expandFileRefs: false,
+      outputFormat: "text",
+    });
+  } finally {
+    if (prev === undefined) delete process.env.CC_PROJECT_MEMORY;
+    else process.env.CC_PROJECT_MEMORY = prev;
+  }
+}

package/src/lib/json-schema-output.js

@@ -0,0 +1,181 @@
+/**
+ * `cc agent -p --json-schema <file>` — structured output for headless runs.
+ *
+ * The final answer must be JSON that validates against a (subset) JSON
+ * Schema; invalid replies are retried with a corrective prompt (up to
+ * MAX_ATTEMPTS total). Implemented entirely AROUND runAgentHeadless using its
+ * `deps.writeOut` capture seam — the runner itself is untouched: each attempt
+ * runs with output captured, the validated JSON is the only thing printed.
+ *
+ * Validator subset (enough for tool/script contracts, not full draft-2020):
+ * type (object/array/string/number/integer/boolean/null), properties,
+ * required, items, enum, const, additionalProperties:false. Zero deps.
+ */
+
+import fsDefault from "fs";
+
+export const MAX_ATTEMPTS = 3;
+export const _deps = { fs: fsDefault };
+
+/** Validate `value` against the schema subset. Returns error strings ([] = valid). */
+export function validateAgainstSchema(value, schema, path = "$") {
+  const errors = [];
+  if (!schema || typeof schema !== "object") return errors;
+
+  const typeOf = (v) =>
+    v === null
+      ? "null"
+      : Array.isArray(v)
+        ? "array"
+        : typeof v === "number" && Number.isInteger(v)
+          ? "integer"
+          : typeof v;
+
+  if (schema.type) {
+    const want = Array.isArray(schema.type) ? schema.type : [schema.type];
+    const got = typeOf(value);
+    const ok = want.some((t) => t === got || (t === "number" && got === "integer"));
+    if (!ok) {
+      errors.push(`${path}: expected type ${want.join("|")}, got ${got}`);
+      return errors; // type mismatch — deeper checks are noise
+    }
+  }
+  if (schema.enum && !schema.enum.some((e) => JSON.stringify(e) === JSON.stringify(value))) {
+    errors.push(`${path}: value not in enum [${schema.enum.map((e) => JSON.stringify(e)).join(", ")}]`);
+  }
+  if (schema.const !== undefined && JSON.stringify(schema.const) !== JSON.stringify(value)) {
+    errors.push(`${path}: must equal const ${JSON.stringify(schema.const)}`);
+  }
+  if (typeOf(value) === "object" && !Array.isArray(value)) {
+    for (const req of schema.required || []) {
+      if (!(req in value)) errors.push(`${path}: missing required property "${req}"`);
+    }
+    const props = schema.properties || {};
+    for (const [k, v] of Object.entries(value)) {
+      if (props[k]) {
+        errors.push(...validateAgainstSchema(v, props[k], `${path}.${k}`));
+      } else if (schema.additionalProperties === false) {
+        errors.push(`${path}: unexpected property "${k}"`);
+      }
+    }
+  }
+  if (Array.isArray(value) && schema.items) {
+    value.forEach((item, i) => {
+      errors.push(...validateAgainstSchema(item, schema.items, `${path}[${i}]`));
+    });
+  }
+  return errors;
+}
+
+/** Pull a JSON payload out of an LLM reply (bare, fenced, or embedded). */
+export function extractJsonPayload(text) {
+  const raw = String(text || "").trim();
+  const tries = [];
+  tries.push(raw);
+  const fence = /```(?:json)?\s*([\s\S]*?)```/i.exec(raw);
+  if (fence) tries.push(fence[1].trim());
+  const firstObj = raw.indexOf("{");
+  const lastObj = raw.lastIndexOf("}");
+  if (firstObj !== -1 && lastObj > firstObj) tries.push(raw.slice(firstObj, lastObj + 1));
+  const firstArr = raw.indexOf("[");
+  const lastArr = raw.lastIndexOf("]");
+  if (firstArr !== -1 && lastArr > firstArr) tries.push(raw.slice(firstArr, lastArr + 1));
+  for (const candidate of tries) {
+    if (!candidate) continue;
+    try {
+      return { ok: true, value: JSON.parse(candidate) };
+    } catch {
+      /* next candidate */
+    }
+  }
+  return { ok: false, error: "reply contains no parseable JSON" };
+}
+
+export function buildSchemaInstruction(schema) {
+  return [
+    "OUTPUT CONTRACT: your FINAL reply must be ONLY a JSON value (no prose, no markdown fences) that validates against this JSON Schema:",
+    JSON.stringify(schema),
+  ].join("\n");
+}
+
+export function buildRetryPrompt(originalPrompt, raw, errors) {
+  return [
+    originalPrompt,
+    "",
+    "Your previous reply failed JSON Schema validation:",
+    ...errors.slice(0, 10).map((e) => `- ${e}`),
+    "",
+    `Previous reply (for reference): ${String(raw).slice(0, 2000)}`,
+    "",
+    "Reply again with ONLY the corrected JSON.",
+  ].join("\n");
+}
+
+/**
+ * Run a headless turn constrained to a schema, retrying on validation
+ * failure. Prints the validated JSON to writeOut; returns the exit code.
+ *
+ * @param {object} cfg { schemaFile|schema, baseOptions, runHeadless,
+ *                       maxAttempts?, writeOut?, writeErr?, deps? }
+ */
+export async function runJsonSchemaConstrained(cfg = {}) {
+  const fs = cfg.deps?.fs || _deps.fs;
+  const writeOut = cfg.writeOut || ((s) => process.stdout.write(s));
+  const writeErr = cfg.writeErr || ((s) => process.stderr.write(s));
+  const maxAttempts = cfg.maxAttempts || MAX_ATTEMPTS;
+
+  const schema =
+    cfg.schema || JSON.parse(fs.readFileSync(cfg.schemaFile, "utf-8"));
+  const instruction = buildSchemaInstruction(schema);
+  const base = cfg.baseOptions || {};
+
+  let prompt = base.prompt;
+  let lastRaw = "";
+  let lastErrors = ["no attempts ran"];
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    let captured = "";
+    const outcome = await cfg.runHeadless(
+      {
+        ...base,
+        prompt,
+        outputFormat: "text",
+        appendSystemPrompt: [base.appendSystemPrompt, instruction]
+          .filter(Boolean)
+          .join("\n\n"),
+      },
+      {
+        writeOut: (s) => {
+          captured += s;
+        },
+        writeErr,
+      },
+    );
+    const raw = String(outcome?.result ?? captured ?? "").trim() || captured.trim();
+    lastRaw = raw;
+    const parsed = extractJsonPayload(raw);
+    if (parsed.ok) {
+      const errors = validateAgainstSchema(parsed.value, schema);
+      if (errors.length === 0) {
+        writeOut(`${JSON.stringify(parsed.value, null, 2)}\n`);
+        return 0;
+      }
+      lastErrors = errors;
+    } else {
+      lastErrors = [parsed.error];
+    }
+    if (attempt < maxAttempts) {
+      writeErr(
+        `--json-schema: attempt ${attempt} failed validation (${lastErrors.length} error(s)) — retrying…\n`,
+      );
+      prompt = buildRetryPrompt(base.prompt, raw, lastErrors);
+    }
+  }
+
+  writeErr(
+    `--json-schema: reply failed validation after ${maxAttempts} attempts:\n${lastErrors
+      .map((e) => `  - ${e}`)
+      .join("\n")}\nLast reply:\n${lastRaw.slice(0, 1000)}\n`,
+  );
+  return 1;
+}