chainlesschain 0.162.101 → 0.162.102

package/src/lib/__tests__/project-inventory.test.js

@@ -0,0 +1,280 @@
+"use strict";
+
+/**
+ * project-inventory tests — the offline census behind `cc init --memory`
+ * (previously untested). Covers readmeSynopsis (markdown synopsis extraction),
+ * inventoryProject (package.json / lockfile→PM / config markers / CI count /
+ * language census / SKIP_DIRS / workspaces both shapes / existingMemory) and
+ * renderMemoryFile (the generated cc.md). Driven by an in-memory fake fs over
+ * POSIX paths via the deps seam — no real I/O.
+ */
+
+import { describe, it, expect } from "vitest";
+import pathDefault from "path";
+import {
+  readmeSynopsis,
+  inventoryProject,
+  renderMemoryFile,
+  SKIP_DIRS,
+} from "../project-inventory.js";
+
+const P = pathDefault.posix;
+
+/** Build a fake fs from a { absPosixPath: content } map. Dirs are derived. */
+function makeFs(files) {
+  const contents = new Map(Object.entries(files));
+  const fileSet = new Set(contents.keys());
+  const dirSet = new Set(["/"]);
+  for (const f of fileSet) {
+    let d = P.dirname(f);
+    while (d && !dirSet.has(d)) {
+      dirSet.add(d);
+      d = P.dirname(d);
+    }
+  }
+  const childrenOf = (dir) => {
+    const out = new Map(); // name -> isDir
+    for (const f of fileSet)
+      if (P.dirname(f) === dir) out.set(P.basename(f), false);
+    for (const d of dirSet)
+      if (d !== "/" && P.dirname(d) === dir) out.set(P.basename(d), true);
+    return out;
+  };
+  return {
+    readFileSync(p) {
+      if (!fileSet.has(p)) {
+        const e = new Error("ENOENT");
+        e.code = "ENOENT";
+        throw e;
+      }
+      return contents.get(p);
+    },
+    existsSync(p) {
+      return fileSet.has(p) || dirSet.has(p);
+    },
+    readdirSync(p, opts) {
+      if (!dirSet.has(p)) {
+        const e = new Error("ENOENT");
+        e.code = "ENOENT";
+        throw e;
+      }
+      const kids = childrenOf(p);
+      if (opts && opts.withFileTypes) {
+        return [...kids].map(([name, isDir]) => ({
+          name,
+          isDirectory: () => isDir,
+          isFile: () => !isDir,
+        }));
+      }
+      return [...kids.keys()];
+    },
+  };
+}
+
+const inv = (files, opts = {}) =>
+  inventoryProject("/proj", { deps: { fs: makeFs(files), path: P }, ...opts });
+
+// --------------------------------------------------------------------------- //
+// readmeSynopsis
+// --------------------------------------------------------------------------- //
+describe("readmeSynopsis", () => {
+  it("returns null for empty input", () => {
+    expect(readmeSynopsis(null)).toBe(null);
+    expect(readmeSynopsis("")).toBe(null);
+  });
+
+  it("skips headings, badges and bare HTML, returns first real paragraph", () => {
+    const md = [
+      "# My Project",
+      "![badge](x.svg)",
+      "[![ci](a)](b)",
+      "<p>html</p>",
+      "",
+      "This is the real summary line.",
+      "Second line of the same paragraph.",
+      "",
+      "Later paragraph ignored.",
+    ].join("\n");
+    expect(readmeSynopsis(md)).toBe(
+      "This is the real summary line. Second line of the same paragraph.",
+    );
+  });
+
+  it("returns null when there is no prose (only headings)", () => {
+    expect(readmeSynopsis("# Title\n## Sub")).toBe(null);
+  });
+
+  it("truncates to maxChars with an ellipsis", () => {
+    const out = readmeSynopsis("x".repeat(50), 10);
+    expect(out).toBe("xxxxxxxxxx…");
+    expect(out.length).toBe(11);
+  });
+});
+
+// --------------------------------------------------------------------------- //
+// inventoryProject
+// --------------------------------------------------------------------------- //
+describe("inventoryProject", () => {
+  it("reads name/description from package.json", () => {
+    const r = inv({
+      "/proj/package.json": JSON.stringify({ name: "acme", description: "d" }),
+    });
+    expect(r.name).toBe("acme");
+    expect(r.description).toBe("d");
+  });
+
+  it("falls back to folder basename when no package.json", () => {
+    expect(inv({ "/proj/foo.txt": "x" }).name).toBe("proj");
+  });
+
+  it("detects package manager from lockfile (first match wins)", () => {
+    expect(inv({ "/proj/pnpm-lock.yaml": "" }).packageManager).toBe("pnpm");
+    expect(inv({ "/proj/yarn.lock": "" }).packageManager).toBe("yarn");
+    expect(inv({ "/proj/foo.txt": "" }).packageManager).toBe(null);
+  });
+
+  it("collects deduped tooling config markers", () => {
+    const r = inv({
+      "/proj/tsconfig.json": "{}",
+      "/proj/vite.config.js": "",
+      "/proj/vite.config.ts": "", // same label "Vite" — deduped
+    });
+    expect(r.configs).toContain("TypeScript");
+    expect(r.configs.filter((c) => c === "Vite").length).toBe(1);
+  });
+
+  it("counts CI workflow files", () => {
+    const r = inv({
+      "/proj/.github/workflows/ci.yml": "",
+      "/proj/.github/workflows/release.yaml": "",
+      "/proj/.github/workflows/notes.md": "", // not yaml
+    });
+    expect(r.ciWorkflows).toBe(2);
+  });
+
+  it("censuses languages by extension, sorted desc, skipping SKIP_DIRS", () => {
+    const r = inv({
+      "/proj/a.ts": "",
+      "/proj/src/b.ts": "",
+      "/proj/src/c.js": "",
+      "/proj/node_modules/d.ts": "", // skipped
+    });
+    const langs = Object.fromEntries(r.languages);
+    expect(langs.TypeScript).toBe(2); // a.ts + src/b.ts, NOT node_modules
+    expect(langs.JavaScript).toBe(1);
+    expect(r.languages[0][0]).toBe("TypeScript"); // sorted desc
+  });
+
+  it("tracks top-level directories with file counts", () => {
+    const r = inv({
+      "/proj/src/a.js": "",
+      "/proj/src/b.js": "",
+      "/proj/docs/c.md": "",
+    });
+    const dirs = Object.fromEntries(r.topDirs);
+    expect(dirs.src).toBe(2);
+    expect(dirs.docs).toBe(1);
+  });
+
+  it("reads workspaces in both array and {packages} shapes", () => {
+    expect(
+      inv({ "/proj/package.json": JSON.stringify({ workspaces: ["a", "b"] }) })
+        .workspaces,
+    ).toEqual(["a", "b"]);
+    expect(
+      inv({
+        "/proj/package.json": JSON.stringify({
+          workspaces: { packages: ["x"] },
+        }),
+      }).workspaces,
+    ).toEqual(["x"]);
+  });
+
+  it("lists scripts and existing memory files", () => {
+    const r = inv({
+      "/proj/package.json": JSON.stringify({
+        scripts: { build: "tsc", test: "vitest" },
+      }),
+      "/proj/CLAUDE.md": "x",
+    });
+    expect(r.scripts).toEqual([
+      ["build", "tsc"],
+      ["test", "vitest"],
+    ]);
+    expect(r.existingMemory).toContain("CLAUDE.md");
+  });
+
+  it("derives synopsis from README.md", () => {
+    const r = inv({ "/proj/README.md": "# T\n\nHello world synopsis." });
+    expect(r.synopsis).toBe("Hello world synopsis.");
+  });
+
+  it("respects maxDepth (deep files beyond cap not counted)", () => {
+    const r = inv({ "/proj/a/b/c/deep.ts": "" }, { maxDepth: 1 });
+    expect(Object.fromEntries(r.languages).TypeScript).toBeUndefined();
+  });
+
+  it("SKIP_DIRS includes the usual heavy directories", () => {
+    expect(SKIP_DIRS.has("node_modules")).toBe(true);
+    expect(SKIP_DIRS.has("target")).toBe(true);
+  });
+});
+
+// --------------------------------------------------------------------------- //
+// renderMemoryFile
+// --------------------------------------------------------------------------- //
+describe("renderMemoryFile", () => {
+  const base = {
+    name: "acme",
+    description: null,
+    synopsis: "A cool tool.",
+    packageManager: "npm",
+    configs: ["TypeScript", "Vitest"],
+    ciWorkflows: 3,
+    workspaces: ["packages/*"],
+    scripts: [
+      ["build", "tsc"],
+      ["test", "vitest"],
+    ],
+    languages: [
+      ["TypeScript", 10],
+      ["JavaScript", 2],
+    ],
+    topDirs: [["src", 10]],
+    truncated: false,
+    existingMemory: ["CLAUDE.md"],
+  };
+
+  it("renders title, overview, stack, commands and layout", () => {
+    const md = renderMemoryFile(base, { date: "2026-06-22" });
+    expect(md).toContain("# acme — Project Memory");
+    expect(md).toContain("2026-06-22");
+    expect(md).toContain("A cool tool.");
+    expect(md).toContain("TypeScript (10), JavaScript (2)");
+    expect(md).toContain("Package manager: npm");
+    expect(md).toContain("CI: GitHub Actions (3 workflows)");
+    expect(md).toContain("`npm run build` — `tsc`");
+    expect(md).toContain("Workspaces: packages/*");
+    expect(md).toContain("`src/` — 10 files");
+  });
+
+  it("imports existing memory files via @-include (excluding cc.md)", () => {
+    const md = renderMemoryFile({
+      ...base,
+      existingMemory: ["cc.md", "CLAUDE.md"],
+    });
+    expect(md).toContain("@CLAUDE.md");
+    expect(md).not.toContain("@cc.md");
+  });
+
+  it("caps the script list at 12 with a remainder note", () => {
+    const scripts = Array.from({ length: 15 }, (_, i) => [`s${i}`, `cmd${i}`]);
+    const md = renderMemoryFile({ ...base, scripts });
+    expect(md).toContain("… 3 more scripts");
+  });
+
+  it("notes a truncated scan", () => {
+    const md = renderMemoryFile({ ...base, truncated: true });
+    expect(md).toContain("scan truncated");
+  });
+});

package/src/lib/__tests__/project-root.test.js

@@ -0,0 +1,96 @@
+"use strict";
+
+/**
+ * project-root tests (previously untested) — the git-root walk shared by the
+ * .claude/.chainlesschain discovery layers (permission rules, output-styles,
+ * slash-commands, sub-agents). A bug here means a subdir run silently drops the
+ * project's config (a safety gap), so the walk + defensive bail-to-null branches
+ * are pinned here. Fake fs/path via the deps seam; no real I/O.
+ */
+
+import { describe, it, expect } from "vitest";
+import pathDefault from "path";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+const { findGitProjectRoot, projectRootBase } = require("../project-root.cjs");
+
+const P = pathDefault.posix;
+
+/** fs whose existsSync(`${dir}/.git`) is true for dirs in the given set. */
+function fsWithGit(gitDirs, { throwAt } = {}) {
+  const set = new Set(gitDirs);
+  return {
+    existsSync(p) {
+      if (throwAt && p === throwAt) throw new Error("EACCES");
+      return p.endsWith("/.git") && set.has(p.slice(0, -"/.git".length));
+    },
+  };
+}
+
+describe("findGitProjectRoot", () => {
+  it("returns cwd when .git is right there", () => {
+    expect(
+      findGitProjectRoot("/proj", { fs: fsWithGit(["/proj"]), path: P }),
+    ).toBe("/proj");
+  });
+
+  it("walks up to the nearest ancestor containing .git", () => {
+    expect(
+      findGitProjectRoot("/proj/src/app", {
+        fs: fsWithGit(["/proj"]),
+        path: P,
+      }),
+    ).toBe("/proj");
+  });
+
+  it("returns null when no .git is found", () => {
+    expect(findGitProjectRoot("/a/b/c", { fs: fsWithGit([]), path: P })).toBe(
+      null,
+    );
+  });
+
+  it("keeps walking when existsSync throws on an intermediate dir", () => {
+    // .git lives at /proj; checking /proj/src/.git throws but the walk continues
+    const fs = fsWithGit(["/proj"], { throwAt: "/proj/src/.git" });
+    expect(findGitProjectRoot("/proj/src/app", { fs, path: P })).toBe("/proj");
+  });
+
+  it("bails to null when fs has no existsSync", () => {
+    expect(findGitProjectRoot("/proj", { fs: {}, path: P })).toBe(null);
+  });
+
+  it("bails to null when path lacks dirname/join", () => {
+    expect(
+      findGitProjectRoot("/proj", { fs: fsWithGit(["/proj"]), path: {} }),
+    ).toBe(null);
+  });
+
+  it("works without path.resolve (falls back to String(cwd))", () => {
+    const noResolve = { dirname: P.dirname, join: P.join };
+    expect(
+      findGitProjectRoot("/proj/sub", {
+        fs: fsWithGit(["/proj"]),
+        path: noResolve,
+      }),
+    ).toBe("/proj");
+  });
+});
+
+describe("projectRootBase", () => {
+  it("returns the root when cwd is a strict subdirectory", () => {
+    expect(
+      projectRootBase("/proj/src", { fs: fsWithGit(["/proj"]), path: P }),
+    ).toBe("/proj");
+  });
+
+  it("returns null when cwd IS the root (own dirs already cover it)", () => {
+    expect(
+      projectRootBase("/proj", { fs: fsWithGit(["/proj"]), path: P }),
+    ).toBe(null);
+  });
+
+  it("returns null when no root is found", () => {
+    expect(projectRootBase("/x/y", { fs: fsWithGit([]), path: P })).toBe(null);
+  });
+});

package/src/lib/__tests__/provider-stream.test.js

@@ -0,0 +1,190 @@
+"use strict";
+
+/**
+ * provider-stream tests (previously untested) — the token-stream parsers behind
+ * `cc stream` and the Hosted Session stream.run route. Pins the bug-prone
+ * streaming parse logic: Ollama NDJSON (yield response, stop on done, line
+ * buffering across chunk boundaries, skip malformed) and OpenAI-style SSE
+ * (yield delta.content, stop on [DONE], skip non-data/empty), error on non-ok,
+ * plus buildProviderSource routing (ollama defaults / known-provider endpoint +
+ * Authorization / unsupported / missing-key). fetch is stubbed; no network.
+ */
+
+import { describe, it, expect, afterEach, vi } from "vitest";
+import {
+  ollamaTokenStream,
+  openAIStream,
+  buildProviderSource,
+} from "../provider-stream.js";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.unstubAllEnvs();
+});
+
+/** A fake fetch whose response body streams the given string chunks. */
+function mockFetch(
+  chunks,
+  { ok = true, status = 200, statusText = "OK" } = {},
+) {
+  return vi.fn(async () => {
+    const enc = new TextEncoder();
+    let i = 0;
+    return {
+      ok,
+      status,
+      statusText,
+      body: {
+        getReader: () => ({
+          read: async () =>
+            i < chunks.length
+              ? { value: enc.encode(chunks[i++]), done: false }
+              : { value: undefined, done: true },
+        }),
+      },
+    };
+  });
+}
+
+async function collect(gen) {
+  const out = [];
+  for await (const t of gen) out.push(t);
+  return out;
+}
+
+// --------------------------------------------------------------------------- //
+// ollamaTokenStream
+// --------------------------------------------------------------------------- //
+describe("ollamaTokenStream", () => {
+  it("yields responses across NDJSON lines and stops on done", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch([
+        '{"response":"He"}\n{"response":"llo"}\n',
+        '{"response":"!"}\n{"done":true}\n',
+        '{"response":"AFTER"}\n', // never read — returned on done
+      ]),
+    );
+    const out = await collect(
+      ollamaTokenStream({ baseUrl: "http://x", model: "m", prompt: "p" }),
+    );
+    expect(out).toEqual(["He", "llo", "!"]);
+  });
+
+  it("buffers a JSON line split across chunk boundaries", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch(['{"resp', 'onse":"hi"}\n{"done":true}\n']),
+    );
+    expect(
+      await collect(
+        ollamaTokenStream({ baseUrl: "http://x", model: "m", prompt: "p" }),
+      ),
+    ).toEqual(["hi"]);
+  });
+
+  it("skips malformed JSON lines", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch(['not json\n{"response":"ok"}\n{"done":true}\n']),
+    );
+    expect(
+      await collect(
+        ollamaTokenStream({ baseUrl: "http://x", model: "m", prompt: "p" }),
+      ),
+    ).toEqual(["ok"]);
+  });
+
+  it("throws on a non-ok response", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch([], { ok: false, status: 500, statusText: "Err" }),
+    );
+    await expect(
+      collect(
+        ollamaTokenStream({ baseUrl: "http://x", model: "m", prompt: "p" }),
+      ),
+    ).rejects.toThrow(/500/);
+  });
+});
+
+// --------------------------------------------------------------------------- //
+// openAIStream
+// --------------------------------------------------------------------------- //
+describe("openAIStream", () => {
+  const args = { baseUrl: "http://x", apiKey: "k", model: "m", prompt: "p" };
+
+  it("yields delta.content from data lines and stops on [DONE]", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch([
+        'data: {"choices":[{"delta":{"content":"A"}}]}\n',
+        'data: {"choices":[{"delta":{"content":"B"}}]}\ndata: [DONE]\n',
+        'data: {"choices":[{"delta":{"content":"AFTER"}}]}\n',
+      ]),
+    );
+    expect(await collect(openAIStream(args))).toEqual(["A", "B"]);
+  });
+
+  it("skips non-data, empty and content-less delta lines", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch([
+        ": comment\n\n",
+        'data: {"choices":[{"delta":{}}]}\n', // no content
+        'data: {"choices":[{"delta":{"content":"x"}}]}\ndata: [DONE]\n',
+      ]),
+    );
+    expect(await collect(openAIStream(args))).toEqual(["x"]);
+  });
+
+  it("throws on a non-ok response", async () => {
+    vi.stubGlobal(
+      "fetch",
+      mockFetch([], { ok: false, status: 401, statusText: "No" }),
+    );
+    await expect(collect(openAIStream(args))).rejects.toThrow(/401/);
+  });
+});
+
+// --------------------------------------------------------------------------- //
+// buildProviderSource
+// --------------------------------------------------------------------------- //
+describe("buildProviderSource", () => {
+  it("routes ollama to /api/generate with localhost default", async () => {
+    const fetchMock = mockFetch(['{"done":true}\n']);
+    vi.stubGlobal("fetch", fetchMock);
+    await collect(buildProviderSource("ollama", { prompt: "hi" }));
+    expect(fetchMock).toHaveBeenCalledWith(
+      "http://localhost:11434/api/generate",
+      expect.objectContaining({ method: "POST" }),
+    );
+  });
+
+  it("routes a known provider to /chat/completions with a Bearer key", async () => {
+    const fetchMock = mockFetch(["data: [DONE]\n"]);
+    vi.stubGlobal("fetch", fetchMock);
+    await collect(
+      buildProviderSource("deepseek", { apiKey: "sk-x", prompt: "hi" }),
+    );
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://api.deepseek.com/v1/chat/completions",
+      expect.objectContaining({
+        headers: expect.objectContaining({ Authorization: "Bearer sk-x" }),
+      }),
+    );
+  });
+
+  it("throws for an unsupported provider", () => {
+    expect(() => buildProviderSource("nope", { prompt: "x" })).toThrow(
+      /Unsupported provider/,
+    );
+  });
+
+  it("throws when a known provider has no api key", () => {
+    vi.stubEnv("DEEPSEEK_API_KEY", "");
+    expect(() => buildProviderSource("deepseek", { prompt: "x" })).toThrow(
+      /API key/,
+    );
+  });
+});

package/src/lib/cli-arg.js

@@ -0,0 +1,41 @@
+/**
+ * cli-arg — validating commander option coercers.
+ *
+ * Bare `parseInt` / `parseFloat` / `Number` used as a commander coercer
+ * (`.option("--limit <n>", "...", parseInt)`) silently yield NaN on bad input
+ * (`--limit abc`), threading NaN into whatever the action does with the option.
+ * These factories validate at parse time and raise a commander
+ * `InvalidArgumentError`, so a typo fails with the standard
+ * `error: option '--limit <n>' argument 'abc' is invalid` message and exit 1 —
+ * instead of a silently-corrupt run.
+ *
+ * Drop-in replacements:
+ *   .option("--limit <n>", "...", parseInt)      ->  intArg("--limit")
+ *   .option("--rate <n>",  "...", parseFloat)    ->  floatArg("--rate")
+ *   .option("--eps <n>",   "...", Number)        ->  floatArg("--eps")
+ *
+ * Behaviour for valid and omitted values is identical to the bare coercer
+ * (the coercer only runs when the option is supplied with a value); only the
+ * NaN-on-bad-input case changes.
+ *
+ * @param {string} name  option label for the message (e.g. "--limit")
+ * @param {{min?: number, max?: number}} [opts]
+ */
+import { InvalidArgumentError } from "commander";
+import { numericOption } from "./cli-numeric.js";
+
+function makeArg(integer) {
+  return (name, opts = {}) =>
+    (raw) => {
+      try {
+        return numericOption(raw, { ...opts, name, integer });
+      } catch (err) {
+        throw new InvalidArgumentError(err.message);
+      }
+    };
+}
+
+export const intArg = makeArg(true);
+export const floatArg = makeArg(false);
+
+export default { intArg, floatArg };

package/src/lib/cli-numeric.js

@@ -10,7 +10,9 @@
  * @param {*} raw  the option value (string from commander, or undefined)
  * @param {object} [opts]
  * @param {string} [opts.name="value"]   label for error messages (e.g. "--limit")
- * @param {boolean} [opts.integer=false] parse as integer (parseInt) vs float (Number)
+ * @param {boolean} [opts.integer=false] require a whole number (rejects 1.5);
+ *                                       parsing is strict either way (Number,
+ *                                       not parseInt — "12abc" is rejected)
  * @param {number} [opts.min]            inclusive lower bound
  * @param {number} [opts.max]            inclusive upper bound
  * @param {number} [opts.fallback]       returned for missing/invalid input; when
@@ -26,8 +28,15 @@ export function numericOption(raw, opts = {}) {
   };
 
   if (raw == null || raw === "") return fail(`${name} is required`);
-  const n = integer ? parseInt(raw, 10) : Number(raw);
-  if (!Number.isFinite(n)) {
+  if (typeof raw === "string" && raw.trim() === "")
+    return fail(`${name} is required`);
+  // Number() (NOT parseInt) so trailing junk is rejected instead of silently
+  // truncated: parseInt("12abc") === 12 and parseInt("0x10", 10) === 0 would
+  // slip a corrupt value through. Number("12abc") is NaN; whole numbers given
+  // via exponent ("1e3" -> 1000) still parse, and a fractional value is
+  // rejected in integer mode.
+  const n = Number(raw);
+  if (!Number.isFinite(n) || (integer && !Number.isInteger(n))) {
     return fail(
       `${name} must be a ${integer ? "whole " : ""}number (got ${JSON.stringify(String(raw))})`,
     );