chainlesschain 0.162.39 → 0.162.41

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

@@ -78,9 +78,12 @@ export function fileCandidates(prefix, { cwd = process.cwd(), deps } = {}) {
 
 /**
  * Build a readline completer. Returns `completer(line)` → `[hits, replaced]`
- * per the readline contract; non-@ lines complete to nothing.
+ * 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[]>, deps? }
+ * @param {object} opts { cwd?, getIdeOpenFiles?: () => Promise<string[]>,
+ *                        slashCommands?: string[], deps? }
  */
 export function makeAtCompleter(opts = {}) {
   const cwd = opts.cwd || process.cwd();
@@ -104,8 +107,12 @@ export function makeAtCompleter(opts = {}) {
               .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);
+                // out-of-workspace files keep their absolute path. On
+                // Windows a cross-drive relative() returns an *absolute*
+                // path (no ".." prefix), so isAbsolute must also gate it.
+                return rel && !rel.startsWith("..") && !path.isAbsolute(rel)
+                  ? fwd(rel)
+                  : fwd(f);
               })
           : [];
         ideFetchedAt = now();
@@ -118,7 +125,21 @@ export function makeAtCompleter(opts = {}) {
       });
   };
 
+  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

package/src/lib/repl-rewind.js

@@ -0,0 +1,107 @@
+/**
+ * REPL conversation rewind — Claude-Code double-Esc parity (v1: conversation
+ * state; file state stays on `cc checkpoint restore`, hinted alongside).
+ *
+ * Pure helpers over the REPL's live `messages` array so the picker logic is
+ * unit-testable without readline:
+ *  - listUserTurns(): newest-first numbered list of user messages
+ *  - rewindToTurn(): truncate the conversation BACK TO BEFORE turn #n and
+ *    return the original text so the caller can prefill the input line
+ *    (edit-and-resend, like Claude Code's rewind).
+ *
+ * Trigger surfaces (wired in agent-repl): `/rewind` lists, `/rewind <n>`
+ * rewinds, and a double-Esc while idle prints the same list as a shortcut.
+ */
+
+export const DEFAULT_LIST_LIMIT = 10;
+export const PREVIEW_CHARS = 60;
+
+function previewOf(content) {
+  const text =
+    typeof content === "string" ? content : JSON.stringify(content || "");
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > PREVIEW_CHARS
+    ? `${flat.slice(0, PREVIEW_CHARS)}…`
+    : flat;
+}
+
+/**
+ * Newest-first user turns.
+ * @returns {Array<{n:number, index:number, preview:string, content:any}>}
+ *          n is the 1-based pick number (1 = most recent user message).
+ */
+export function listUserTurns(messages, { limit = DEFAULT_LIST_LIMIT } = {}) {
+  const turns = [];
+  for (let i = (messages || []).length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (!m || m.role !== "user") continue;
+    turns.push({
+      n: turns.length + 1,
+      index: i,
+      preview: previewOf(m.content),
+      content: m.content,
+    });
+    if (turns.length >= limit) break;
+  }
+  return turns;
+}
+
+/**
+ * Rewind the conversation to BEFORE the picked user turn (mutates `messages`
+ * in place — everything from that user message onward is dropped).
+ *
+ * @param {Array} messages  live conversation array
+ * @param {number} n        1-based pick from listUserTurns
+ * @returns {{ removed:number, text:string|null }|null}  null on bad pick;
+ *          `text` is the original user text when it was a plain string
+ *          (caller prefills the input line with it).
+ */
+export function rewindToTurn(messages, n) {
+  const turns = listUserTurns(messages, { limit: 1000 });
+  const turn = turns.find((t) => t.n === Number(n));
+  if (!turn) return null;
+  const removed = messages.length - turn.index;
+  messages.splice(turn.index);
+  return {
+    removed,
+    text: typeof turn.content === "string" ? turn.content : null,
+  };
+}
+
+/**
+ * Offline extractive recap for a resumed conversation ("where were we") —
+ * no LLM call: turn counts + last ask + last reply previews.
+ * @returns {string[]|null} lines to print, or null when nothing to recap.
+ */
+export function buildResumeRecap(messages, { previewChars = 160 } = {}) {
+  const list = messages || [];
+  const flat = (c) =>
+    (typeof c === "string" ? c : JSON.stringify(c || ""))
+      .replace(/\s+/g, " ")
+      .trim();
+  const cap = (s) =>
+    s.length > previewChars ? `${s.slice(0, previewChars)}…` : s;
+  const lastOf = (role) => {
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (list[i]?.role === role) return list[i].content;
+    }
+    return null;
+  };
+  const users = list.filter((m) => m?.role === "user").length;
+  const assistants = list.filter((m) => m?.role === "assistant").length;
+  if (!users && !assistants) return null;
+  const lines = [`${users} user / ${assistants} assistant turns`];
+  const lu = lastOf("user");
+  if (lu) lines.push(`last ask  : ${cap(flat(lu))}`);
+  const la = lastOf("assistant");
+  if (la) lines.push(`last reply: ${cap(flat(la))}`);
+  return lines;
+}
+
+/** Render the picker list (shared by /rewind and double-Esc). */
+export function renderTurnList(turns) {
+  if (!turns.length) return "  (no user turns yet)";
+  return turns
+    .map((t) => `  ${String(t.n).padStart(2)}. ${t.preview}`)
+    .join("\n");
+}

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));