chainlesschain 0.162.38 → 0.162.40

package/src/lib/project-inventory.js

@@ -0,0 +1,355 @@
+/**
+ * Project inventory — offline resource census for `cc init --memory`.
+ *
+ * Scans the target folder (bounded walk: depth/entry caps, heavy dirs
+ * skipped) and produces a deterministic snapshot of what is already there:
+ * languages by extension, package manager, npm scripts, workspaces/monorepo
+ * layout, notable tool configs (TS/bundlers/docker/CI/lint), test runners and
+ * a README summary. `renderMemoryFile` turns that snapshot into a starter
+ * `cc.md` project-memory file (the file `cc agent` auto-loads — see
+ * project-instructions.js). No LLM, no network: the census is pure I/O and
+ * unit-testable via the `deps` seam; reads are explicit UTF-8 (encoding.md).
+ */
+
+import fsDefault from "fs";
+import pathDefault from "path";
+
+export const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "target",
+  ".gradle",
+  ".idea",
+  ".vscode",
+  "Pods",
+  "DerivedData",
+]);
+
+export const DEFAULT_MAX_DEPTH = 4;
+export const DEFAULT_MAX_ENTRIES = 20000;
+
+const EXT_LANG = {
+  ".js": "JavaScript",
+  ".cjs": "JavaScript",
+  ".mjs": "JavaScript",
+  ".ts": "TypeScript",
+  ".tsx": "TypeScript",
+  ".jsx": "JavaScript",
+  ".vue": "Vue",
+  ".py": "Python",
+  ".java": "Java",
+  ".kt": "Kotlin",
+  ".kts": "Kotlin",
+  ".swift": "Swift",
+  ".go": "Go",
+  ".rs": "Rust",
+  ".rb": "Ruby",
+  ".php": "PHP",
+  ".cs": "C#",
+  ".c": "C",
+  ".h": "C/C++ header",
+  ".cpp": "C++",
+  ".cc": "C++",
+  ".m": "Objective-C",
+  ".sql": "SQL",
+  ".sh": "Shell",
+  ".ps1": "PowerShell",
+  ".md": "Markdown",
+};
+
+const CONFIG_MARKERS = [
+  ["tsconfig.json", "TypeScript"],
+  ["vite.config.js", "Vite"],
+  ["vite.config.ts", "Vite"],
+  ["webpack.config.js", "Webpack"],
+  ["rollup.config.js", "Rollup"],
+  ["next.config.js", "Next.js"],
+  ["nuxt.config.ts", "Nuxt"],
+  ["docker-compose.yml", "Docker Compose"],
+  ["docker-compose.yaml", "Docker Compose"],
+  ["Dockerfile", "Docker"],
+  ["pom.xml", "Maven"],
+  ["build.gradle", "Gradle"],
+  ["build.gradle.kts", "Gradle (Kotlin DSL)"],
+  ["settings.gradle.kts", "Gradle (Kotlin DSL)"],
+  ["Cargo.toml", "Cargo / Rust"],
+  ["go.mod", "Go modules"],
+  ["pyproject.toml", "Python (pyproject)"],
+  ["requirements.txt", "Python (requirements)"],
+  ["pubspec.yaml", "Flutter/Dart"],
+  [".eslintrc.json", "ESLint"],
+  ["eslint.config.js", "ESLint"],
+  [".prettierrc", "Prettier"],
+  ["vitest.config.js", "Vitest"],
+  ["vitest.config.ts", "Vitest"],
+  ["jest.config.js", "Jest"],
+  ["playwright.config.ts", "Playwright"],
+  ["electron-builder.yml", "electron-builder"],
+];
+
+const LOCKFILE_PM = [
+  ["package-lock.json", "npm"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lockb", "bun"],
+];
+
+function resolveDeps(opts) {
+  return {
+    fs: opts.deps?.fs || fsDefault,
+    path: opts.deps?.path || pathDefault,
+  };
+}
+
+function readJson(fs, p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function readText(fs, p) {
+  try {
+    return fs.readFileSync(p, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/** First markdown paragraph after the title — a cheap README synopsis. */
+export function readmeSynopsis(text, maxChars = 400) {
+  if (!text) return null;
+  const lines = String(text).split(/\r?\n/);
+  const out = [];
+  let started = false;
+  for (const line of lines) {
+    const t = line.trim();
+    if (!t) {
+      if (started) break;
+      continue;
+    }
+    if (/^#/.test(t) || /^!\[/.test(t) || /^<.*>$/.test(t) || /^\[!\[/.test(t))
+      continue; // headings / badges / bare HTML
+    out.push(t);
+    started = true;
+  }
+  const para = out.join(" ").trim();
+  if (!para) return null;
+  return para.length > maxChars ? `${para.slice(0, maxChars)}…` : para;
+}
+
+/**
+ * Walk the tree (bounded) counting files per language and remembering
+ * top-level directories with file counts.
+ */
+function census(root, { fs, path, maxDepth, maxEntries }) {
+  const languages = new Map(); // lang -> count
+  const topDirs = new Map(); // top-level dir -> file count
+  let entries = 0;
+  let truncated = false;
+
+  const walk = (dir, depth, top) => {
+    if (entries >= maxEntries) {
+      truncated = true;
+      return;
+    }
+    let list;
+    try {
+      list = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of list) {
+      if (entries >= maxEntries) {
+        truncated = true;
+        return;
+      }
+      entries += 1;
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name) || e.name.startsWith(".")) continue;
+        if (depth < maxDepth) {
+          walk(path.join(dir, e.name), depth + 1, top || e.name);
+        }
+      } else if (e.isFile()) {
+        if (top) topDirs.set(top, (topDirs.get(top) || 0) + 1);
+        const ext = path.extname(e.name).toLowerCase();
+        const lang = EXT_LANG[ext];
+        if (lang) languages.set(lang, (languages.get(lang) || 0) + 1);
+      }
+    }
+  };
+  walk(root, 0, null);
+  return { languages, topDirs, truncated };
+}
+
+/**
+ * Inventory the folder. Pure data out — rendering is separate.
+ *
+ * @param {string} cwd
+ * @param {object} [opts] { deps, maxDepth, maxEntries }
+ */
+export function inventoryProject(cwd, opts = {}) {
+  const { fs, path } = resolveDeps(opts);
+  const root = path.resolve(cwd);
+  const maxDepth = Number.isFinite(opts.maxDepth)
+    ? opts.maxDepth
+    : DEFAULT_MAX_DEPTH;
+  const maxEntries = Number.isFinite(opts.maxEntries)
+    ? opts.maxEntries
+    : DEFAULT_MAX_ENTRIES;
+
+  const pkg = readJson(fs, path.join(root, "package.json"));
+
+  let packageManager = null;
+  for (const [lock, pm] of LOCKFILE_PM) {
+    if (fs.existsSync(path.join(root, lock))) {
+      packageManager = pm;
+      break;
+    }
+  }
+
+  const configs = [];
+  for (const [file, label] of CONFIG_MARKERS) {
+    if (fs.existsSync(path.join(root, file)) && !configs.includes(label)) {
+      configs.push(label);
+    }
+  }
+
+  let ciWorkflows = 0;
+  try {
+    ciWorkflows = fs
+      .readdirSync(path.join(root, ".github", "workflows"))
+      .filter((f) => /\.ya?ml$/.test(f)).length;
+  } catch {
+    /* no CI dir */
+  }
+
+  const readme =
+    readText(fs, path.join(root, "README.md")) ||
+    readText(fs, path.join(root, "readme.md"));
+
+  const { languages, topDirs, truncated } = census(root, {
+    fs,
+    path,
+    maxDepth,
+    maxEntries,
+  });
+
+  const workspaces = Array.isArray(pkg?.workspaces)
+    ? pkg.workspaces
+    : Array.isArray(pkg?.workspaces?.packages)
+      ? pkg.workspaces.packages
+      : [];
+
+  const scripts = pkg?.scripts ? Object.entries(pkg.scripts) : [];
+
+  const existingMemory = ["cc.md", "CLAUDE.md", "AGENTS.md"].filter((f) =>
+    fs.existsSync(path.join(root, f)),
+  );
+
+  return {
+    root,
+    name: pkg?.name || path.basename(root),
+    description: pkg?.description || null,
+    synopsis: readmeSynopsis(readme),
+    packageManager,
+    configs,
+    ciWorkflows,
+    workspaces,
+    scripts,
+    languages: [...languages.entries()].sort((a, b) => b[1] - a[1]),
+    topDirs: [...topDirs.entries()].sort((a, b) => b[1] - a[1]),
+    truncated,
+    existingMemory,
+  };
+}
+
+/** Render the inventory as a starter cc.md project-memory file. */
+export function renderMemoryFile(inv, opts = {}) {
+  const today = opts.date || new Date().toISOString().slice(0, 10);
+  const L = [];
+  L.push(`# ${inv.name} — Project Memory`);
+  L.push("");
+  L.push(
+    `> Generated by \`cc init --memory\` on ${today} from an inventory of this folder.`,
+  );
+  L.push(
+    "> `cc agent` auto-loads this file as authoritative project context — edit freely.",
+  );
+  L.push("");
+
+  // cc.md outranks CLAUDE.md/AGENTS.md in discovery — import any existing
+  // memory file so generating cc.md never shadows hand-maintained content.
+  const existing = (inv.existingMemory || []).filter((f) => f !== "cc.md");
+  if (existing.length) {
+    L.push("## Existing project memory (imported)");
+    L.push("");
+    for (const f of existing) L.push(`@${f}`);
+    L.push("");
+  }
+
+  if (inv.synopsis || inv.description) {
+    L.push("## Overview");
+    L.push("");
+    L.push(inv.synopsis || inv.description);
+    L.push("");
+  }
+
+  L.push("## Stack");
+  L.push("");
+  if (inv.languages.length) {
+    const langs = inv.languages
+      .slice(0, 8)
+      .map(([lang, n]) => `${lang} (${n})`)
+      .join(", ");
+    L.push(`- Languages by file count: ${langs}${inv.truncated ? " — scan truncated" : ""}`);
+  }
+  if (inv.packageManager) L.push(`- Package manager: ${inv.packageManager}`);
+  if (inv.configs.length) L.push(`- Tooling: ${inv.configs.join(", ")}`);
+  if (inv.ciWorkflows)
+    L.push(`- CI: GitHub Actions (${inv.ciWorkflows} workflows)`);
+  L.push("");
+
+  if (inv.scripts.length) {
+    L.push("## Commands");
+    L.push("");
+    const pm = inv.packageManager || "npm";
+    for (const [name, cmd] of inv.scripts.slice(0, 12)) {
+      L.push(`- \`${pm} run ${name}\` — \`${cmd}\``);
+    }
+    if (inv.scripts.length > 12) {
+      L.push(`- … ${inv.scripts.length - 12} more scripts in package.json`);
+    }
+    L.push("");
+  }
+
+  if (inv.workspaces.length || inv.topDirs.length) {
+    L.push("## Layout");
+    L.push("");
+    if (inv.workspaces.length) {
+      L.push(`- Workspaces: ${inv.workspaces.join(", ")}`);
+    }
+    for (const [dir, n] of inv.topDirs.slice(0, 10)) {
+      L.push(`- \`${dir}/\` — ${n} files`);
+    }
+    L.push("");
+  }
+
+  L.push("## Conventions");
+  L.push("");
+  L.push("- (add project rules here — code style, commit format, test policy)");
+  L.push("");
+  return L.join("\n");
+}
+
+export const _deps = { fs: fsDefault, path: pathDefault };

package/src/lib/repl-bang-memorize.js

@@ -0,0 +1,142 @@
+/**
+ * REPL `!` bash passthrough + `#` quick-memorize (Claude-Code parity).
+ *
+ * Pure logic for two agent-REPL input prefixes, extracted so it is unit
+ * testable without driving readline:
+ *
+ *  - `! <cmd>`  — run the shell command immediately (no LLM round-trip) and
+ *    return a `<bash-input>/<bash-output>` context message so the model sees
+ *    what happened on the next turn. Windows runs through `cmd.exe /d /s /c`
+ *    with a `chcp 65001` prefix (encoding.md rule); POSIX through `/bin/sh -c`.
+ *
+ *  - `# <note>` — append a one-line note to the project memory file (cc.md at
+ *    the git root — the file project-instructions.js auto-loads). Creates the
+ *    file/`## Notes` section when missing; next sessions pick it up
+ *    automatically and the caller can also inject it into the live context.
+ *
+ * All process/fs access goes through `_deps` for tests.
+ */
+
+import { spawnSync as spawnSyncDefault } from "child_process";
+import fsDefault from "fs";
+import pathDefault from "path";
+import { findProjectRoot } from "./project-instructions.js";
+
+export const BANG_TIMEOUT_MS = 120_000;
+export const BANG_MAX_BUFFER = 10 * 1024 * 1024;
+export const BANG_OUTPUT_CAP = 30_000;
+
+export const _deps = {
+  spawnSync: spawnSyncDefault,
+  fs: fsDefault,
+  path: pathDefault,
+};
+
+function cap(s) {
+  const str = s || "";
+  return str.length > BANG_OUTPUT_CAP
+    ? `${str.slice(0, BANG_OUTPUT_CAP)}\n… [truncated]`
+    : str;
+}
+
+/** True when the REPL line is a `!` bash passthrough. */
+export function isBangCommand(trimmed) {
+  return (
+    typeof trimmed === "string" &&
+    trimmed.startsWith("!") &&
+    trimmed.slice(1).trim().length > 0
+  );
+}
+
+/** True when the REPL line is a `#` quick-memorize. */
+export function isMemorizeLine(trimmed) {
+  return (
+    typeof trimmed === "string" &&
+    trimmed.startsWith("#") &&
+    trimmed.slice(1).trim().length > 0
+  );
+}
+
+/**
+ * Run a `!` command synchronously.
+ *
+ * @returns {{ cmd, stdout, stderr, exitCode, error, contextMessage }}
+ *          `contextMessage` is ready to push as a user-role message.
+ */
+export function runBangCommand(line, opts = {}) {
+  const spawnSync = opts.deps?.spawnSync || _deps.spawnSync;
+  const cwd = opts.cwd || process.cwd();
+  const isWin =
+    opts.platform != null ? opts.platform === "win32" : process.platform === "win32";
+  const cmd = String(line).replace(/^!/, "").trim();
+
+  const res = isWin
+    ? spawnSync("cmd.exe", ["/d", "/s", "/c", `chcp 65001 >nul && ${cmd}`], {
+        encoding: "utf-8",
+        timeout: BANG_TIMEOUT_MS,
+        maxBuffer: BANG_MAX_BUFFER,
+        cwd,
+      })
+    : spawnSync("/bin/sh", ["-c", cmd], {
+        encoding: "utf-8",
+        timeout: BANG_TIMEOUT_MS,
+        maxBuffer: BANG_MAX_BUFFER,
+        cwd,
+      });
+
+  const exitCode = res.status == null ? (res.error ? -1 : 0) : res.status;
+  const stdout = cap(res.stdout);
+  const stderr = cap(res.stderr);
+  const body = [stdout, stderr].filter(Boolean).join("\n");
+  return {
+    cmd,
+    stdout,
+    stderr,
+    exitCode,
+    error: res.error || null,
+    contextMessage: {
+      role: "user",
+      content: `<bash-input>${cmd}</bash-input>\n<bash-output exit-code="${exitCode}">\n${body}\n</bash-output>`,
+    },
+  };
+}
+
+/**
+ * Append a `#` note to the project cc.md (created at the git root — falls
+ * back to cwd outside a repo). Inserts under a `## Notes` heading, creating
+ * file/section as needed.
+ *
+ * @returns {{ target, line, created }}
+ */
+export function appendMemoryNote(rawLine, opts = {}) {
+  const fs = opts.deps?.fs || _deps.fs;
+  const path = opts.deps?.path || _deps.path;
+  const cwd = opts.cwd || process.cwd();
+  const note = String(rawLine).replace(/^#/, "").trim();
+  const stamp = opts.date || new Date().toISOString().slice(0, 10);
+
+  const root =
+    findProjectRoot(cwd, { deps: { fs, path } }) || path.resolve(cwd);
+  const target = opts.target || path.join(root, "cc.md");
+  const line = `- ${note} _(noted ${stamp})_`;
+
+  let text = null;
+  try {
+    text = fs.readFileSync(target, "utf-8");
+  } catch {
+    /* file does not exist yet */
+  }
+
+  let created = false;
+  if (text == null) {
+    text = `# Project Memory\n\n## Notes\n\n${line}\n`;
+    created = true;
+  } else if (/^## Notes\s*$/m.test(text)) {
+    // insert right after the heading (keeps newest notes on top)
+    text = text.replace(/^## Notes\s*$/m, (m) => `${m}\n\n${line}`);
+  } else {
+    text = `${text.trimEnd()}\n\n## Notes\n\n${line}\n`;
+  }
+  fs.writeFileSync(target, text, "utf-8");
+  return { target, line, note, created };
+}

package/src/lib/repl-completer.js

@@ -0,0 +1,154 @@
+/**
+ * REPL `@` file-reference tab-completion (Claude-Code @-mention parity).
+ *
+ * Typing `@src/fo<TAB>` in the agent REPL completes file/dir paths the same
+ * way the @-token will later be expanded by file-ref-expander. Two candidate
+ * sources, merged:
+ *   1. the filesystem under cwd (dirs get a trailing `/` so TAB can descend)
+ *   2. the connected IDE's OPEN EDITOR TABS (when the IDE bridge is up) —
+ *      the files you are working on rank first, before any fs listing.
+ *
+ * IDE tabs come from an injected async `getIdeOpenFiles()`; the completer
+ * caches the last list (TTL) and refreshes in the background, so completion
+ * stays synchronous-fast and a slow/dead IDE costs nothing (first TAB simply
+ * has no IDE entries yet).
+ */
+import fs from "fs";
+import path from "path";
+
+/** Refresh the IDE open-editors list at most this often. */
+const IDE_CACHE_TTL_MS = 5000;
+/** Hard cap on candidates shown per TAB. */
+const MAX_CANDIDATES = 30;
+
+/**
+ * Find a trailing `@token` being typed at the end of the line. Returns
+ * `{ prefix }` (token without `@`, may be "") or null when the cursor is not
+ * on an @-token. An @ must start the line or follow whitespace, mirroring
+ * file-ref-expander's token rules.
+ */
+export function extractAtPrefix(line) {
+  const m = /(^|\s)@([^\s@]*)$/.exec(line || "");
+  return m ? { prefix: m[2] } : null;
+}
+
+/** Normalize to forward slashes (what @refs use on every platform). */
+function fwd(p) {
+  return String(p).replace(/\\/g, "/");
+}
+
+/**
+ * Filesystem candidates for an @-prefix, relative to cwd. Directories get a
+ * trailing `/`. Missing dirs / unreadable entries → empty (best-effort).
+ */
+export function fileCandidates(prefix, { cwd = process.cwd(), deps } = {}) {
+  const readdir = deps?.readdir || ((d) => fs.readdirSync(d));
+  const isDir =
+    deps?.isDir ||
+    ((p) => {
+      try {
+        return fs.statSync(p).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  const norm = fwd(prefix);
+  const slash = norm.lastIndexOf("/");
+  const dirPart = slash >= 0 ? norm.slice(0, slash + 1) : "";
+  const basePart = slash >= 0 ? norm.slice(slash + 1) : norm;
+  const absDir = path.resolve(cwd, dirPart || ".");
+  let names;
+  try {
+    names = readdir(absDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (basePart && !name.toLowerCase().startsWith(basePart.toLowerCase())) {
+      continue;
+    }
+    if (name === "node_modules" || name === ".git") continue;
+    const rel = dirPart + name;
+    out.push(isDir(path.join(absDir, name)) ? `${rel}/` : rel);
+    if (out.length >= MAX_CANDIDATES) break;
+  }
+  return out;
+}
+
+/**
+ * Build a readline completer. Returns `completer(line)` → `[hits, replaced]`
+ * per the readline contract. Completes `@path` tokens anywhere in the line
+ * and `/command` names at line start (while the command token is still being
+ * typed); everything else completes to nothing.
+ *
+ * @param {object} opts { cwd?, getIdeOpenFiles?: () => Promise<string[]>,
+ *                        slashCommands?: string[], deps? }
+ */
+export function makeAtCompleter(opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const getIde = opts.getIdeOpenFiles || null;
+  const now = opts.deps?.now || Date.now;
+  let ideFiles = [];
+  let ideFetchedAt = -Infinity; // "never" — the first @ must always fetch
+  let ideInFlight = false;
+
+  const refreshIde = () => {
+    if (!getIde || ideInFlight || now() - ideFetchedAt < IDE_CACHE_TTL_MS) {
+      return;
+    }
+    ideInFlight = true;
+    Promise.resolve()
+      .then(() => getIde())
+      .then((files) => {
+        ideFiles = Array.isArray(files)
+          ? files
+              .filter((f) => typeof f === "string" && f.length > 0)
+              .map((f) => {
+                const rel = path.relative(cwd, f);
+                // Keep workspace files relative (the natural @ref form);
+                // out-of-workspace files keep their absolute path.
+                return rel && !rel.startsWith("..") ? fwd(rel) : fwd(f);
+              })
+          : [];
+        ideFetchedAt = now();
+      })
+      .catch(() => {
+        ideFetchedAt = now(); // don't hammer a dead IDE
+      })
+      .finally(() => {
+        ideInFlight = false;
+      });
+  };
+
+  const slashCommands = Array.isArray(opts.slashCommands)
+    ? [...opts.slashCommands].sort()
+    : [];
+
+  const completer = (line) => {
+    // `/command` completion (Claude-Code parity): only while typing the
+    // command token itself — once a space follows, args are the user's.
+    const slash = /^\/([A-Za-z_-]*)$/.exec(line);
+    if (slash && slashCommands.length) {
+      const pref = `/${slash[1].toLowerCase()}`;
+      const hits = slashCommands.filter((c) => c.toLowerCase().startsWith(pref));
+      return [hits, line];
+    }
+    const at = extractAtPrefix(line);
+    if (!at) return [[], line];
+    refreshIde(); // async top-up for the NEXT tab; this one uses the cache
+    const norm = fwd(at.prefix).toLowerCase();
+    const fromIde = ideFiles.filter((f) => f.toLowerCase().startsWith(norm));
+    const fromFs = fileCandidates(at.prefix, { cwd, deps: opts.deps });
+    const merged = [...new Set([...fromIde, ...fromFs])].slice(
+      0,
+      MAX_CANDIDATES,
+    );
+    // readline replaces `replaced` with the chosen hit — keep the `@`.
+    return [merged.map((m) => `@${m}`), `@${at.prefix}`];
+  };
+  // test seam: expose the cache refresher state
+  completer._refreshIde = refreshIde;
+  completer._ideState = () => ({ ideFiles, ideFetchedAt });
+  return completer;
+}

package/src/lib/update-notice-refresh.mjs

@@ -0,0 +1,10 @@
+/**
+ * Detached cache refresher for the startup update notice.
+ * Spawned unref'd by update-notice.js; argv[2] = cache file path.
+ * Exits quietly on any failure — the notice is strictly best-effort.
+ */
+import { refreshCacheOnce } from "./update-notice.js";
+
+refreshCacheOnce({ cacheFile: process.argv[2] })
+  .catch(() => {})
+  .finally(() => process.exit(0));