knodin 0.7.5 → 0.8.2

package/dist/bin/launcher.js

@@ -1,6 +1,21 @@
 #!/usr/bin/env node
-import { tryStructuralFastPath } from "../src/structural-fast-path.js";
+import { handoffCurrentProcessToSupportedNodeRuntime } from "../src/node-runtime.js";
+let runtime;
+try {
+    runtime = handoffCurrentProcessToSupportedNodeRuntime();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`knodin: ${message}\n`);
+    process.exit(1);
+}
+if (runtime.kind === "relaunched") {
+    if (runtime.signal)
+        process.kill(process.pid, runtime.signal);
+    process.exit(runtime.status ?? 1);
+}
 const argv = process.argv.slice(2);
+const { tryStructuralFastPath } = await import("../src/structural-fast-path.js");
 const fast = tryStructuralFastPath(argv);
 if (!fast) {
     const { tryPureCompressionFastPath } = await import("../src/pure-compression-cli.js");

package/dist/src/agent-integration.js

@@ -17,10 +17,33 @@ ${TOML_END}`;
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function commandExists(command) {
+function commandPath(command) {
     try {
-        child_process.execFileSync("which", [command], { stdio: "ignore" });
-        return true;
+        const resolver = process.platform === "win32" ? "where.exe" : "which";
+        return (child_process
+            .execFileSync(resolver, [command], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        })
+            .split(/\r?\n/, 1)[0]
+            ?.trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+function hasGitHubCopilotExtension() {
+    const code = commandPath("code");
+    if (!code)
+        return false;
+    try {
+        const extensions = child_process.execFileSync(code, ["--list-extensions"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return extensions
+            .split(/\r?\n/)
+            .some((extension) => ["github.copilot", "github.copilot-chat"].includes(extension.toLowerCase()));
     }
     catch {
         return false;
@@ -29,13 +52,15 @@ function commandExists(command) {
 /** Detect primary MCP-capable coding agents without launching them. */
 export function detectSupportedAgents() {
     const detected = [];
-    if (commandExists("claude"))
+    if (commandPath("claude"))
         detected.push("claude");
-    if (commandExists("codex"))
+    if (commandPath("codex"))
         detected.push("codex");
-    if (commandExists("gemini"))
+    if (commandPath("gemini"))
         detected.push("gemini");
-    if (commandExists("antigravity") || commandExists("agy"))
+    if (hasGitHubCopilotExtension())
+        detected.push("copilot");
+    if (commandPath("antigravity") || commandPath("agy"))
         detected.push("antigravity");
     return detected;
 }
@@ -126,6 +151,15 @@ function assertSafeProjectPath(repo, filePath) {
 function formatProjectJson(document) {
     return `${JSON.stringify(document, null, "\t").replace(/"args": \[\n(\t+)"serve"\n\t+\]/g, '"args": ["serve"]')}\n`;
 }
+function removeEmptyParent(filePath) {
+    try {
+        fs.rmdirSync(path.dirname(filePath));
+    }
+    catch (error) {
+        if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? ""))
+            throw error;
+    }
+}
 function updateJsonMcp(filePath, remove) {
     const document = readJsonObject(filePath);
     const existing = document.mcpServers;
@@ -148,6 +182,40 @@ function updateJsonMcp(filePath, remove) {
     fs.writeFileSync(filePath, formatProjectJson(document), "utf-8");
     return true;
 }
+function updateVsCodeMcp(filePath, remove) {
+    const document = readJsonObject(filePath);
+    const existing = document.servers;
+    if (existing !== undefined &&
+        (typeof existing !== "object" || existing === null || Array.isArray(existing)))
+        throw new Error(`${filePath}: expected "servers" to be an object`);
+    const servers = typeof existing === "object" && existing !== null && !Array.isArray(existing)
+        ? { ...existing }
+        : {};
+    if (remove)
+        delete servers[MCP_NAME];
+    else
+        servers[MCP_NAME] = { type: "stdio", command: "knodin", args: ["serve"] };
+    if (Object.keys(servers).length > 0)
+        document.servers = servers;
+    else
+        delete document.servers;
+    if (remove && Object.keys(document).length === 0) {
+        fs.rmSync(filePath, { force: true });
+        removeEmptyParent(filePath);
+        return false;
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, formatProjectJson(document), "utf-8");
+    return true;
+}
+/** Strips a marker-delimited managed block, leaving surrounding user config intact. */
+function removeManagedBlock(content, startMarker, endMarker) {
+    const start = content.indexOf(startMarker);
+    const end = content.indexOf(endMarker);
+    return start >= 0 && end >= start
+        ? `${content.slice(0, start)}${content.slice(end + endMarker.length)}`.trim()
+        : content.trim();
+}
 function updateTomlMcp(filePath, remove) {
     let existing = "";
     try {
@@ -157,13 +225,6 @@ function updateTomlMcp(filePath, remove) {
         if (error.code !== "ENOENT")
             throw error;
     }
-    function removeManagedBlock(content, startMarker, endMarker) {
-        const start = content.indexOf(startMarker);
-        const end = content.indexOf(endMarker);
-        return start >= 0 && end >= start
-            ? `${content.slice(0, start)}${content.slice(end + endMarker.length)}`.trim()
-            : content.trim();
-    }
     const without = removeManagedBlock(existing, TOML_START, TOML_END);
     const next = remove ? without : [without, TOML_BLOCK].filter(Boolean).join("\n\n");
     if (!next) {
@@ -178,8 +239,8 @@ function updateTomlMcp(filePath, remove) {
 export function configureProjectAgents(options) {
     const repo = path.resolve(options.repo);
     const remove = options.scope === "cli-only";
-    const agents = options.scope === "team"
-        ? ["claude", "codex", "gemini", "antigravity"]
+    const agents = options.scope === "team" || options.scope === "cli-only"
+        ? ["claude", "codex", "gemini", "copilot", "antigravity"]
         : options.agents;
     const commandResult = options.scope === "team"
         ? { configured: [], removed: [], failed: [], projectFiles: [] }
@@ -216,6 +277,11 @@ export function configureProjectAgents(options) {
                 assertSafeProjectPath(repo, path.join(repo, relative));
                 remains = updateJsonMcp(path.join(repo, relative), remove);
             }
+            else if (agent === "copilot") {
+                relative = ".vscode/mcp.json";
+                assertSafeProjectPath(repo, path.join(repo, relative));
+                remains = updateVsCodeMcp(path.join(repo, relative), remove);
+            }
             else if (agent === "antigravity") {
                 relative = ".agents/mcp_config.json";
                 assertSafeProjectPath(repo, path.join(repo, relative));

package/dist/src/artifact-refresh.js

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import { resolveStateDir } from "./engine/state-paths.js";
 const REFRESH_TIMEOUT_MS = 30_000;
 function defaultRuntime() {
     return {
@@ -75,7 +76,7 @@ export function refreshExternalGraphArtifacts(repoPath, event, runtime = default
 }
 /** Persist an audit record locally; no source content or tool output is retained. */
 export function writeArtifactRefreshRecord(repoPath, result) {
-    const knodinDir = path.join(path.resolve(repoPath), ".knodin");
+    const knodinDir = resolveStateDir(repoPath);
     fs.mkdirSync(knodinDir, { recursive: true });
     fs.appendFileSync(path.join(knodinDir, "artifact-refresh.jsonl"), `${JSON.stringify({ at: new Date().toISOString(), ...result })}\n`, "utf8");
 }

package/dist/src/cli-args.js

@@ -29,6 +29,23 @@ const GLOBAL_VALUE_FLAGS = new Set([
     "--limit",
 ]);
 const GLOBAL_BOOLEAN_FLAGS = new Set(["--exclude-tests", "--data-flow", "--json"]);
+/**
+ * Command-scoped flags that take a value. These are NOT global — they are not
+ * hoisted or reordered — but their value must never be mistaken for a
+ * positional path. `knodin index --sarif results.sarif` asks to import that log,
+ * not to index the log as a source file.
+ */
+const COMMAND_VALUE_FLAGS = new Set([
+    "--scip",
+    "--scip-max-bytes",
+    "--scip-max-files",
+    "--scip-max-facts",
+    "--scip-timeout-ms",
+    "--sarif",
+    "--sarif-max-bytes",
+    "--sarif-max-findings",
+    "--sarif-timeout-ms",
+]);
 const isDir = (p) => {
     try {
         return fs.statSync(p).isDirectory();
@@ -127,7 +144,8 @@ export function extractPositionals(args) {
     for (let index = 0; index < args.length; index++) {
         const argument = args[index];
         if (argument.startsWith("--")) {
-            if (!argument.includes("=") && GLOBAL_VALUE_FLAGS.has(argument))
+            if (!argument.includes("=") &&
+                (GLOBAL_VALUE_FLAGS.has(argument) || COMMAND_VALUE_FLAGS.has(argument)))
                 index++;
             continue;
         }

package/dist/src/cli-model.js

@@ -53,6 +53,17 @@ function addGlobalOptions(program) {
         .option("--exclude-tests", "exclude tests from impact")
         .option("--data-flow", "include bounded data-flow evidence");
 }
+function addRemoteCommands(program, capture) {
+    const remote = program
+        .command("remote")
+        .description("mirror repositories that are reachable but not checked out locally");
+    leaf(remote, "add <url>", "acquire a read-only mirror and index it", capture)
+        .option("--no-index", "acquire the clone without building a graph")
+        .option("--defer-semantic", "build structure only; leave semantic search coverage for a later `knodin index`");
+    leaf(remote, "list", "list acquired mirrors with their snapshot and size", capture);
+    leaf(remote, "remove <identity>", "delete a mirror's clone, graph, and registry entry", capture);
+    leaf(remote, "refresh <identity>", "fetch the mirror again and re-index it", capture);
+}
 function addRepositoryCommands(program, capture) {
     const repos = program.command("repos").description("manage a portfolio of repositories");
     for (const action of ["discover", "init", "status", "doctor"]) {
@@ -63,6 +74,7 @@ function addRepositoryCommands(program, capture) {
             command
                 .addOption(option("--include <selector>", "include a repository id or path", "collect"))
                 .addOption(option("--exclude <selector>", "exclude a repository id or path", "collect"))
+                .addOption(option("--memory-limit-mib <mib>", "optional per-repository worker RSS ceiling (default: uncapped)", "integer"))
                 .option("--manifest <path>", "write or resume a portfolio manifest")
                 .option("--dry-run", "report actions without changing repositories");
         }
@@ -101,8 +113,10 @@ function addGraphCommands(program, capture) {
         .option("--sort <mode>", "relevance, name, size, degree, or complexity")
         .option("--relations <kinds>", "comma-separated relationship kinds");
     leaf(program, "wiki", "write local architecture wiki pages", capture).option("--force", "rewrite unchanged pages");
-    leaf(program, "visualize <entry>", "write a local architecture/call-flow HTML artifact", capture)
+    leaf(program, "visualize [entry]", "write a local architecture/call-flow HTML artifact", capture)
         .requiredOption("--output <path>", "repo-relative HTML output path")
+        .option("--scope <scope>", "call-flow (default) or repo")
+        .option("--granularity <granularity>", "repo scope: file (default) or symbol")
         .addOption(option("--depth <count>", "call-flow depth", "integer"))
         .addOption(option("--max-bytes <count>", "hard artifact budget", "integer"));
     leaf(program, "search <query> [limit]", "hybrid symbol search", capture)
@@ -212,7 +226,15 @@ function createCliProgram(capture = () => { }) {
     leaf(program, "index [files...]", "index a repository or selected files", capture)
         .option("--clean", "rebuild selected index state")
         .option("--force", "force clean indexing")
-        .option("--scip <file>", "opt in to a bounded local SCIP protobuf import");
+        .option("--scip <file>", "opt in to a bounded local SCIP protobuf import")
+        .addOption(option("--scip-max-bytes <count>", "raise the SCIP input size ceiling", "integer"))
+        .addOption(option("--scip-max-files <count>", "raise the SCIP document ceiling", "integer"))
+        .addOption(option("--scip-max-facts <count>", "raise the SCIP fact ceiling", "integer"))
+        .addOption(option("--scip-timeout-ms <count>", "raise the SCIP read budget", "integer"))
+        .option("--sarif <file>", "import bounded local analyzer findings from a SARIF log")
+        .addOption(option("--sarif-max-bytes <count>", "raise the SARIF log size ceiling", "integer"))
+        .addOption(option("--sarif-max-findings <count>", "raise the imported findings ceiling", "integer"))
+        .addOption(option("--sarif-timeout-ms <count>", "raise the SARIF read budget", "integer"));
     leaf(program, "doctor", "diagnose installation, clients, hooks, graph, and updates", capture).option("--client <client>", "claude, codex, gemini, or antigravity");
     leaf(program, "status", "report graph, lifecycle, integration, and update state", capture)
         .option("--deep", "run a full graph audit")
@@ -231,6 +253,7 @@ function createCliProgram(capture = () => { }) {
     leaf(program, "hook-refresh <kind> [values...]", "internal Git lifecycle refresh", capture);
     leaf(program, "refresh-artifacts [event]", "refresh external graph artifacts", capture);
     addRepositoryCommands(program, capture);
+    addRemoteCommands(program, capture);
     addGraphCommands(program, capture);
     addArtifactCommands(program, capture);
     const system = program.command("system").description("inspect declared multi-repository systems");
@@ -273,6 +296,8 @@ function createCliProgram(capture = () => { }) {
         .addArgument(new Argument("<action>").choices([
         "enable",
         "status",
+        "preview",
+        "archive",
         "collect",
         "inspect",
         "clear",
@@ -283,6 +308,7 @@ function createCliProgram(capture = () => { }) {
         .addOption(option("--retention-days <count>", "local event retention in days", "integer"))
         .option("--since <duration>", "collection window, such as 24h or 7d")
         .option("--output <path>", "repository-contained .json.gz bundle path")
+        .option("--preview-id <id>", "exact prior preview to archive")
         .action((...values) => capture(values.at(-1)));
     return program;
 }

package/dist/src/codeflow-replay.js

@@ -1,3 +1,4 @@
+import { compareBytes } from "./compare.js";
 export const EXPECTED_RELATIONSHIPS = [
     "packages/api/route.ts->packages/auth/service.ts",
     "packages/api/route.ts->packages/audit/store.ts",
@@ -60,7 +61,7 @@ export function blastRadiusCompleteness(relationships) {
     return {
         origin,
         expected: [...expected],
-        found: [...found].sort(),
+        found: [...found].sort(compareBytes),
         missing: [...expected].filter((file) => !found.has(file)),
         completeness: [...expected].filter((file) => found.has(file)).length / expected.size,
     };

package/dist/src/compare.js

@@ -0,0 +1,39 @@
+/**
+ * Ordering primitives for values that get persisted or compared across machines.
+ *
+ * `Array.prototype.sort()` with no comparator coerces elements to strings and
+ * compares UTF-16 code units. For an array of strings that is already the order
+ * these helpers produce — so adopting them is behaviour-preserving. For anything
+ * else it is not: `[10, 9].sort()` yields `[10, 9]`, which is the bug the rule
+ * exists to catch.
+ *
+ * The reason these are hand-written rather than `String.localeCompare`:
+ * collation is machine-dependent. It varies with the host locale and with the
+ * ICU data the runtime was built against, so two machines can order identical
+ * input differently. knodin persists sort order into the graph and compares it
+ * across checkouts, and a SARIF import shipped with exactly that bug earlier
+ * today. Byte order is a function of the bytes alone.
+ */
+/** Lexicographic by UTF-16 code unit — identical to the default sort order. */
+export function compareBytes(left, right) {
+    if (left < right)
+        return -1;
+    return left > right ? 1 : 0;
+}
+/**
+ * Byte order, descending.
+ *
+ * Written out rather than expressed as `compareBytes(right, left)` so call
+ * sites do not have to swap their arguments. A swap reads as a bug — and is
+ * reported as one, since a reversed call whose parameters share the callee's
+ * names is indistinguishable from a genuine mistake.
+ */
+export function compareBytesDescending(left, right) {
+    if (left > right)
+        return -1;
+    return left < right ? 1 : 0;
+}
+/** Numeric ascending. The default sort would order these lexicographically. */
+export function compareNumbers(left, right) {
+    return left - right;
+}

package/dist/src/competitive-constraints.js

@@ -1,6 +1,7 @@
+import { compareBytes } from "./compare.js";
 /** Verifies the local-only, single-gateway contract that qualifies a competitive replay. */
 export function assessCompetitiveConstraints(tools) {
-    const mcpToolNames = tools.map((tool) => tool.name).sort();
+    const mcpToolNames = tools.map((tool) => tool.name).sort(compareBytes);
     const schemaBytes = Buffer.byteLength(JSON.stringify(tools));
     const violations = [];
     if (tools.length !== 1)

package/dist/src/competitive-runner.js

@@ -137,10 +137,10 @@ export function applyCompetitiveCaseContracts(competitor, raw, fixtureRevision)
                 };
             }
             const dimensions = [...mapping.scope.dimensions];
-            const direction = caseId.match(/^trace-(inbound|outbound|both)-/)?.[1];
+            const direction = /^trace-(inbound|outbound|both)-/.exec(caseId)?.[1];
             if (direction)
                 dimensions.push(`direction=${direction}`);
-            const facet = caseId.match(/^architecture-([a-z_]+)/)?.[1];
+            const facet = /^architecture-([a-z_]+)/.exec(caseId)?.[1];
             if (facet)
                 dimensions.push(`facet=${facet}`);
             return {
@@ -290,9 +290,9 @@ export function normalizeRawResult(competitor, raw) {
             blocked++;
         const contender = findCompetitorSide(test, competitor);
         const knodin = test.knodin;
-        if (contender && contender.ok === false)
+        if (contender?.ok === false)
             competitorErrors++;
-        if (knodin && knodin.ok === false)
+        if (knodin?.ok === false)
             knodinErrors++;
         const oracle = test.oracle;
         const contract = test.caseContract;

package/dist/src/context-export.js

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { RE2 } from "re2-wasm";
+import { compareBytes } from "./compare.js";
 import { measurePerfPhaseSync } from "./engine/perf.js";
 const DEFAULT_EXCLUDES = [".git/**", ".knodin/**", "node_modules/**", "dist/**", "build/**"];
 const GLOB_CACHE_LIMIT = 256;
@@ -221,7 +222,7 @@ export function exportContext(repoPath, request = {}) {
     const excludePatterns = compilePatterns(exclude);
     const policyRules = request.policies ?? {};
     const policies = Object.keys(policyRules)
-        .sort()
+        .sort(compareBytes)
         .map((pattern) => ({
         pattern: globRegex(normalizeRelative(pattern)),
         policy: policyRules[pattern],
@@ -233,7 +234,7 @@ export function exportContext(repoPath, request = {}) {
         .filter((file) => matchesCompiled(file, includePatterns) &&
         !matchesCompiled(file, excludePatterns) &&
         !omitted.has(file))
-        .sort();
+        .sort(compareBytes);
     let tree = request.includeTree ? [...candidates] : undefined;
     let git = gitSections(repo, request.git);
     const files = [];

package/dist/src/context.js

@@ -24,7 +24,7 @@ export function suggestNextOperation(task) {
         return "map";
     }
     // A bare identifier-shaped token (a single symbol name) → explain it directly.
-    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(task.trim())) {
+    if (/^[A-Za-z_]\w*$/.test(task.trim())) {
         return "explain";
     }
     // Otherwise no exact symbol is known → fuzzy search to find a starting point.

package/dist/src/deterministic-random.js

@@ -0,0 +1,34 @@
+/**
+ * Deterministic pseudo-random number generation.
+ *
+ * knodin never calls `Math.random` in production code: index topology, graph
+ * layout, and every artifact they feed must be reproducible so that a rerun
+ * over unchanged evidence produces a byte-identical result. Callers that need
+ * randomness seed one of these generators instead.
+ */
+/** Default seed (golden-ratio constant) shared by callers without their own. */
+export const DEFAULT_PRNG_SEED = 0x9e3779b9;
+/** Deterministic PRNG so derived structures are reproducible across runs. */
+export function mulberry32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/**
+ * Folds a string into a 32-bit seed (FNV-1a). Lets a caller derive a stable
+ * seed from repository-scoped evidence such as a commit id, so the same
+ * evidence always produces the same output.
+ */
+export function seedFromString(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index++) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}