knodin 0.7.4 → 0.7.6

package/dist/src/engine/perf.js

@@ -1,115 +0,0 @@
-/** Opt-in phase timing used by the R43 benchmark harness. */
-export const PERF_PHASES = [
-    "db_open_migration",
-    "file_collection",
-    "parser_wasm_init",
-    "read",
-    "parse_extract",
-    "sqlite_write",
-    "model_load",
-    "embedding_inference_write",
-    "search_row_fetch_decode",
-    "similarity",
-    "fts",
-    "map_community",
-    "fusion",
-    "freshness_probe",
-    "graph_analytics",
-    "traversal_snapshot",
-    "architecture_facets",
-    "architecture_edge_materialization",
-    "context_composition",
-    "status_audit",
-    "pack_walk",
-    "pack_serialize",
-    "artifact_read",
-    "artifact_grep",
-    "review_diff_discovery",
-    "review_churn",
-    "review_parsing",
-    "review_flow_lookup",
-    "review_serialization",
-];
-let active = null;
-function emptyPhases() {
-    return Object.fromEntries(PERF_PHASES.map((phase) => [phase, 0]));
-}
-function peakRss() {
-    try {
-        const kilobytes = process.resourceUsage().maxRSS;
-        return Number.isFinite(kilobytes) && kilobytes >= 0 ? kilobytes * 1024 : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Start a measurement explicitly. Starting while active resets that measurement. */
-export function beginPerfSession() {
-    active = { startedAt: performance.now(), phases: emptyPhases(), peakRssBytes: peakRss() };
-}
-/** Finish the active measurement, or return null when instrumentation is disabled. */
-export function endPerfSession() {
-    const session = active;
-    if (!session)
-        return null;
-    active = null;
-    const currentRss = peakRss();
-    if (currentRss !== undefined) {
-        session.peakRssBytes = Math.max(session.peakRssBytes ?? 0, currentRss);
-    }
-    return {
-        phases: { ...session.phases },
-        totalMs: Math.max(0, performance.now() - session.startedAt),
-        ...(session.peakRssBytes === undefined ? {} : { peakRssBytes: session.peakRssBytes }),
-    };
-}
-function record(phase, startedAt) {
-    const session = active;
-    if (!session)
-        return;
-    session.phases[phase] += Math.max(0, performance.now() - startedAt);
-    const currentRss = peakRss();
-    if (currentRss !== undefined)
-        session.peakRssBytes = Math.max(session.peakRssBytes ?? 0, currentRss);
-}
-/** Start a phase that spans an existing try/finally block. The returned closer is idempotent. */
-export function beginPerfPhase(phase) {
-    if (!active)
-        return () => undefined;
-    const startedAt = performance.now();
-    let closed = false;
-    return () => {
-        if (closed)
-            return;
-        closed = true;
-        record(phase, startedAt);
-    };
-}
-/** Time an async phase. Nested phases are retained independently and errors still close timers. */
-export async function measurePerfPhase(phase, work) {
-    if (!active)
-        return work();
-    const startedAt = performance.now();
-    try {
-        return await work();
-    }
-    finally {
-        record(phase, startedAt);
-    }
-}
-/** Synchronous counterpart for filesystem, parsing, and SQLite calls. */
-export function measurePerfPhaseSync(phase, work) {
-    if (!active)
-        return work();
-    const startedAt = performance.now();
-    try {
-        return work();
-    }
-    finally {
-        record(phase, startedAt);
-    }
-}
-/** Test-only state reset; deliberately does not enable timing. */
-export function resetPerfForTests() {
-    active = null;
-}

package/dist/src/engine/prune.js

@@ -1,112 +0,0 @@
-import path from "node:path";
-/**
- * Single source of truth for "which directories does knodin ignore" (R14).
- *
- * Before this module, the same intent — skip node_modules, .git, .knodin,
- * build output, caches, VCS internals — was encoded THREE separate times:
- *   1. src/__tests__/setup.ts's `PRUNE_DIRS` regex (glob-shim exclude filter)
- *   2. the indexer's own directory filter (`EXCLUDED_DIR_SEGMENTS` / `isIndexablePath`)
- *   3. the chokidar watcher's `makeWatchIgnorePredicate` (added by R13)
- *
- * They drifted. R13's bug was exactly this shape: the watcher's copy silently
- * stopped matching anything for an entire chokidar major version while the
- * indexer's copy kept working, so indexing looked correct and only the
- * watcher melted (it registered ~12.6k files and starved the event loop under
- * Bun). This module is the ONE list; every consumer below is a thin adapter
- * over it, so a future drift is structurally impossible rather than merely
- * discouraged.
- */
-/**
- * Directory segments never worth indexing or watching: build output, deps,
- * VCS/tool state, caches. Matched by whole path SEGMENT, never substring, so
- * a real file/dir like `distributor.ts` or `build-graph.ts` is never wrongly
- * pruned.
- */
-export const PRUNE_DIR_NAMES = new Set([
-    "node_modules",
-    ".git",
-    ".knodin",
-    // Local state maintained by other code-intelligence tools. It is neither
-    // repository source nor stable project configuration, and indexing it makes
-    // a healthy checkout look perpetually stale as those tools update databases
-    // and caches in the background.
-    ".gitnexus",
-    ".codegraph",
-    ".code-review-graph",
-    ".aider.tags.cache.v4",
-    "dist",
-    "build",
-    "coverage",
-    ".next",
-    ".turbo",
-    ".svelte-kit",
-    "vendor",
-    "__pycache__",
-]);
-/** True when a single path segment (one directory name) is a pruned directory. */
-export function isPrunedSegment(segment) {
-    return PRUNE_DIR_NAMES.has(segment);
-}
-/**
- * Agent worktrees are checkouts of this same repo living under
- * `.claude/worktrees/*`; indexing/watching them would double-count every
- * symbol. `segments` is the full split relative path; `i` is the segment
- * index currently being tested against the two-segment `.claude/worktrees`
- * pattern.
- */
-function isClaudeWorktreeSegment(segments, i) {
-    return segments[i] === ".claude" && segments[i + 1] === "worktrees";
-}
-/**
- * True when ANY segment of an already-split repo-relative path trips the
- * ignore policy (a pruned directory name, or the `.claude/worktrees` root).
- * This is the one walk both `isIndexablePath` (indexer) and
- * `makeWatchIgnorePredicate` (watcher) run — the code that used to be
- * duplicated between them.
- */
-export function pathSegmentsAreIgnored(segments) {
-    for (let i = 0; i < segments.length; i++) {
-        if (isPrunedSegment(segments[i]))
-            return true;
-        if (isClaudeWorktreeSegment(segments, i))
-            return true;
-    }
-    return false;
-}
-/**
- * Indexer adapter: true when a repo-relative path (either OS separator)
- * should be indexed.
- */
-export function isIndexablePath(relPath) {
-    return !pathSegmentsAreIgnored(relPath.split(/[/\\]/));
-}
-/**
- * Watcher adapter: builds chokidar's `ignored` predicate for a given repo
- * root.
- *
- * chokidar v4 removed glob support; v5 accepts only a function, a regex, or a
- * literal path. Matching here is done on the path RELATIVE to the repo, so a
- * repo that happens to live under a directory named e.g. `build/` does not
- * prune its own root (the R13 fix this preserves).
- */
-export function makeWatchIgnorePredicate(repoPath) {
-    return (targetPath) => {
-        const relative = path.relative(repoPath, targetPath);
-        // The watch root itself ("") and anything outside it are never pruned.
-        if (relative === "" || relative.startsWith(".."))
-            return false;
-        return pathSegmentsAreIgnored(relative.split(path.sep));
-    };
-}
-/**
- * Policy-test adapter: a regex equivalent to the segment-based policy above.
- * Anchored on `/` boundaries so it only matches whole segments — same guarantee
- * as `isPrunedSegment` — never a substring inside an unrelated name.
- */
-export function makePruneDirsRegex() {
-    const escaped = [...PRUNE_DIR_NAMES].map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-    // `.claude/worktrees` is a two-segment pattern, expressed directly rather
-    // than through the single-segment name list.
-    escaped.push("\\.claude/worktrees");
-    return new RegExp(`(?:^|/)(?:${escaped.join("|")})(?:/|$)`);
-}

package/dist/src/engine/scip-import.js

@@ -1,408 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-export const SCIP_DEFAULT_LIMITS = {
-    maxBytes: 64 * 1024 * 1024,
-    maxFiles: 10_000,
-    maxFacts: 250_000,
-    timeoutMs: 30_000,
-};
-const textDecoder = new TextDecoder("utf-8", { fatal: true });
-let activeDeadline = Number.POSITIVE_INFINITY;
-let activeTimeoutMs = 0;
-function fail(message) {
-    activeDeadline = Number.POSITIVE_INFINITY;
-    activeTimeoutMs = 0;
-    throw new Error(`knodin SCIP import: ${message}`);
-}
-function checkDeadline() {
-    if (performance.now() > activeDeadline)
-        fail(`import exceeded ${activeTimeoutMs} ms limit`);
-}
-function readVarint(bytes, offset) {
-    let value = 0;
-    let shift = 0;
-    for (let count = 0; count < 10 && offset < bytes.length; count++) {
-        const byte = bytes[offset++];
-        if (shift < 53)
-            value += (byte & 0x7f) * 2 ** shift;
-        if ((byte & 0x80) === 0)
-            return [value, offset];
-        shift += 7;
-    }
-    return fail("malformed protobuf varint");
-}
-function visitFields(bytes, visitor) {
-    let offset = 0;
-    while (offset < bytes.length) {
-        checkDeadline();
-        let tag;
-        [tag, offset] = readVarint(bytes, offset);
-        const number = Math.floor(tag / 8);
-        const wire = tag & 7;
-        if (number < 1)
-            fail("malformed protobuf field number");
-        if (wire === 0) {
-            let value;
-            [value, offset] = readVarint(bytes, offset);
-            visitor(number, wire, value);
-        }
-        else if (wire === 2) {
-            let length;
-            [length, offset] = readVarint(bytes, offset);
-            if (!Number.isSafeInteger(length) || length < 0 || offset + length > bytes.length)
-                fail("malformed protobuf length");
-            visitor(number, wire, bytes.subarray(offset, offset + length));
-            offset += length;
-        }
-        else if (wire === 1) {
-            offset += 8;
-        }
-        else if (wire === 5) {
-            offset += 4;
-        }
-        else {
-            fail(`unsupported protobuf wire type ${wire}`);
-        }
-        if (offset > bytes.length)
-            fail("truncated protobuf field");
-    }
-}
-function countLengthDelimitedFields(bytes, target, maximum) {
-    let count = 0;
-    let offset = 0;
-    while (offset < bytes.length) {
-        checkDeadline();
-        let tag;
-        [tag, offset] = readVarint(bytes, offset);
-        const number = Math.floor(tag / 8);
-        const wire = tag & 7;
-        if (number < 1)
-            fail("malformed protobuf field number");
-        if (wire === 0) {
-            [, offset] = readVarint(bytes, offset);
-        }
-        else if (wire === 2) {
-            let length;
-            [length, offset] = readVarint(bytes, offset);
-            if (!Number.isSafeInteger(length) || length < 0 || offset + length > bytes.length)
-                fail("malformed protobuf length");
-            if (number === target && ++count > maximum)
-                return count;
-            offset += length;
-        }
-        else if (wire === 1)
-            offset += 8;
-        else if (wire === 5)
-            offset += 4;
-        else
-            fail(`unsupported protobuf wire type ${wire}`);
-        if (offset > bytes.length)
-            fail("truncated protobuf field");
-    }
-    return count;
-}
-function strings(message, number) {
-    const result = [];
-    visitFields(message, (fieldNumber, wire, value) => {
-        if (fieldNumber === number && wire === 2)
-            result.push(textDecoder.decode(value));
-    });
-    return result;
-}
-function messages(message, number) {
-    const result = [];
-    visitFields(message, (fieldNumber, wire, value) => {
-        if (fieldNumber === number && wire === 2)
-            result.push(value);
-    });
-    return result;
-}
-function numberField(message, number) {
-    let result = 0;
-    let found = false;
-    visitFields(message, (fieldNumber, wire, value) => {
-        if (!found && fieldNumber === number && wire === 0) {
-            result = value;
-            found = true;
-        }
-    });
-    return result;
-}
-function packedNumbers(message, number) {
-    const result = [];
-    visitFields(message, (fieldNumber, wire, value) => {
-        if (fieldNumber !== number)
-            return;
-        if (wire === 0)
-            result.push(value);
-        if (wire === 2) {
-            const bytes = value;
-            let offset = 0;
-            while (offset < bytes.length) {
-                let packedValue;
-                [packedValue, offset] = readVarint(bytes, offset);
-                result.push(packedValue);
-            }
-        }
-    });
-    return result;
-}
-function parseRange(values) {
-    if (values.length !== 3 && values.length !== 4)
-        fail("range must contain three or four integers");
-    const [startLine, startCol] = values;
-    const endLine = values.length === 3 ? startLine : values[2];
-    const endCol = values.length === 3 ? values[2] : values[3];
-    if ([startLine, startCol, endLine, endCol].some((value) => !Number.isSafeInteger(value)))
-        fail("range contains an unsafe integer");
-    if (endLine < startLine || (endLine === startLine && endCol < startCol))
-        fail("range is reversed");
-    return { startLine, startCol, endLine, endCol };
-}
-function parseOccurrence(message) {
-    const singleLine = messages(message, 8)[0];
-    const multiLine = messages(message, 9)[0];
-    const symbol = strings(message, 2)[0] ?? "";
-    let range;
-    if (singleLine) {
-        const line = numberField(singleLine, 1);
-        range = parseRange([line, numberField(singleLine, 2), numberField(singleLine, 3)]);
-    }
-    else if (multiLine) {
-        range = parseRange([
-            numberField(multiLine, 1),
-            numberField(multiLine, 2),
-            numberField(multiLine, 3),
-            numberField(multiLine, 4),
-        ]);
-    }
-    else {
-        range = parseRange(packedNumbers(message, 1));
-    }
-    if (!symbol)
-        fail("occurrence is missing its symbol");
-    return { range, symbol, roles: numberField(message, 3) };
-}
-function parseSymbolInfo(message) {
-    const symbol = strings(message, 1)[0] ?? "";
-    if (!symbol)
-        fail("symbol information is missing its symbol");
-    return {
-        symbol,
-        displayName: strings(message, 6)[0] ?? "",
-        kind: numberField(message, 5),
-        relationships: messages(message, 4).map((relationship) => ({
-            symbol: strings(relationship, 1)[0] ?? "",
-            isReference: numberField(relationship, 2) !== 0,
-            isImplementation: numberField(relationship, 3) !== 0,
-            isTypeDefinition: numberField(relationship, 4) !== 0,
-            isDefinition: numberField(relationship, 5) !== 0,
-        })),
-    };
-}
-function safeRelativePath(repoPath, value) {
-    if (!value || value.includes("\0") || path.isAbsolute(value))
-        fail(`hostile document path ${JSON.stringify(value)}`);
-    const normalized = value.replaceAll("\\", "/");
-    if (normalized.split("/").some((part) => part === ".." || part === ""))
-        fail(`hostile document path ${JSON.stringify(value)}`);
-    const absolute = path.resolve(repoPath, normalized);
-    const relative = path.relative(repoPath, absolute);
-    if (relative.startsWith("..") || path.isAbsolute(relative))
-        fail(`document escapes repository: ${value}`);
-    let stat;
-    try {
-        stat = fs.lstatSync(absolute);
-    }
-    catch {
-        return fail(`document is missing: ${normalized}`);
-    }
-    if (!stat.isFile() || stat.isSymbolicLink())
-        fail(`document is not a regular repository file: ${normalized}`);
-    return normalized;
-}
-function symbolName(symbol, displayName) {
-    if (displayName.trim())
-        return displayName.trim();
-    if (symbol.startsWith("local "))
-        return symbol;
-    const descriptor = symbol.trim().split(/\s+/).at(-1) ?? symbol;
-    const withoutSuffix = descriptor.replace(/\([^)]*\)\.$|[#/.:!]$/, "");
-    const cleaned = (withoutSuffix.split(/[/#]/).at(-1) ?? descriptor).replaceAll("`", "");
-    return cleaned || symbol;
-}
-function symbolKind(_kind) {
-    // Do not translate a versioned producer enum into a potentially false native
-    // semantic kind; the original SCIP symbol remains in provenance.
-    return "SCIP_Symbol";
-}
-function parseMetadata(index) {
-    const metadata = messages(index, 1)[0];
-    if (!metadata)
-        return [];
-    const toolInfo = messages(metadata, 2)[0];
-    if (!toolInfo)
-        return [];
-    const name = strings(toolInfo, 1)[0];
-    const version = strings(toolInfo, 2)[0];
-    return name ? [`${name}${version ? `@${version}` : ""}`] : [];
-}
-export function readScipIndex(repoPath, options) {
-    const started = performance.now();
-    const limits = { ...SCIP_DEFAULT_LIMITS, ...options };
-    for (const [name, value] of Object.entries(limits)) {
-        if (name === "path")
-            continue;
-        if (!Number.isSafeInteger(value) || value < 1)
-            fail(`${name} must be a positive integer`);
-    }
-    activeTimeoutMs = limits.timeoutMs;
-    activeDeadline = started + limits.timeoutMs;
-    const resolvedRepo = path.resolve(repoPath);
-    const inputPath = path.resolve(resolvedRepo, options.path);
-    const inputRelative = path.relative(resolvedRepo, inputPath);
-    if (inputRelative.startsWith("..") || path.isAbsolute(inputRelative))
-        fail("input path escapes repository");
-    let inputStat;
-    try {
-        inputStat = fs.lstatSync(inputPath);
-    }
-    catch {
-        return fail(`input is missing: ${inputRelative}`);
-    }
-    if (!inputStat.isFile() || inputStat.isSymbolicLink())
-        fail("input must be a regular repository file");
-    if (inputStat.size > limits.maxBytes)
-        fail(`input exceeds ${limits.maxBytes} byte limit`);
-    const bytes = fs.readFileSync(inputPath);
-    const index = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const documents = [];
-    let parsedFacts = 0;
-    const documentCount = countLengthDelimitedFields(index, 2, limits.maxFiles);
-    if (documentCount > limits.maxFiles)
-        fail(`index exceeds ${limits.maxFiles} file limit`);
-    for (const message of messages(index, 2)) {
-        const filePath = safeRelativePath(resolvedRepo, strings(message, 1)[0] ?? "");
-        const sourceStat = fs.statSync(path.join(resolvedRepo, filePath));
-        if (sourceStat.mtimeMs > inputStat.mtimeMs + 1)
-            fail(`input is stale for ${filePath}`);
-        const occurrenceCount = countLengthDelimitedFields(message, 2, limits.maxFacts - parsedFacts);
-        parsedFacts += occurrenceCount;
-        if (parsedFacts > limits.maxFacts)
-            fail(`index exceeds ${limits.maxFacts} fact limit`);
-        const symbolCount = countLengthDelimitedFields(message, 3, limits.maxFacts - parsedFacts);
-        parsedFacts += symbolCount;
-        if (parsedFacts > limits.maxFacts)
-            fail(`index exceeds ${limits.maxFacts} fact limit`);
-        const occurrenceMessages = messages(message, 2);
-        const symbolMessages = messages(message, 3);
-        for (const symbolMessage of symbolMessages) {
-            const remainingRelationships = Math.floor((limits.maxFacts - parsedFacts) / 4);
-            parsedFacts += countLengthDelimitedFields(symbolMessage, 4, remainingRelationships) * 4;
-            if (parsedFacts > limits.maxFacts)
-                fail(`index exceeds ${limits.maxFacts} fact limit`);
-        }
-        documents.push({
-            filePath,
-            language: strings(message, 4)[0] ?? "unknown",
-            occurrences: occurrenceMessages.map(parseOccurrence),
-            symbols: symbolMessages.map(parseSymbolInfo),
-        });
-        if (performance.now() - started > limits.timeoutMs)
-            fail(`import exceeded ${limits.timeoutMs} ms limit`);
-    }
-    const scopedSymbol = (document, symbol) => symbol.startsWith("local ") ? `${document.filePath}\0${symbol}` : `\0${symbol}`;
-    const definitions = new Map();
-    for (const document of documents) {
-        const infos = new Map(document.symbols.map((info) => [info.symbol, info]));
-        for (const occurrence of document.occurrences) {
-            const key = scopedSymbol(document, occurrence.symbol);
-            if ((occurrence.roles & 1) !== 0 && !definitions.has(key)) {
-                definitions.set(key, {
-                    document,
-                    occurrence,
-                    info: infos.get(occurrence.symbol),
-                });
-            }
-        }
-    }
-    const symbols = [...definitions.values()].map((definition) => ({
-        symbol: definition.occurrence.symbol,
-        name: symbolName(definition.occurrence.symbol, definition.info?.displayName ?? ""),
-        kind: symbolKind(definition.info?.kind ?? 0),
-        filePath: definition.document.filePath,
-        startLine: definition.occurrence.range.startLine + 1,
-        endLine: definition.occurrence.range.endLine + 1,
-        startCol: definition.occurrence.range.startCol + 1,
-        endCol: definition.occurrence.range.endCol + 1,
-    }));
-    const references = [];
-    for (const document of documents) {
-        for (const occurrence of document.occurrences) {
-            if ((occurrence.roles & 1) !== 0)
-                continue;
-            const target = definitions.get(scopedSymbol(document, occurrence.symbol));
-            if (!target)
-                continue;
-            references.push({
-                callerSymbol: null,
-                callerFile: document.filePath,
-                calleeSymbol: symbolName(occurrence.symbol, target.info?.displayName ?? ""),
-                calleeFile: target.document.filePath,
-                line: occurrence.range.startLine + 1,
-                column: occurrence.range.startCol + 1,
-                kind: "scip_reference",
-            });
-        }
-        for (const info of document.symbols) {
-            const source = definitions.get(scopedSymbol(document, info.symbol));
-            if (!source)
-                continue;
-            for (const relationship of info.relationships) {
-                const target = definitions.get(scopedSymbol(document, relationship.symbol));
-                if (!target)
-                    continue;
-                const kinds = [];
-                if (relationship.isReference)
-                    kinds.push("scip_relationship_reference");
-                if (relationship.isImplementation)
-                    kinds.push("scip_implementation");
-                if (relationship.isTypeDefinition)
-                    kinds.push("scip_type_definition");
-                if (relationship.isDefinition)
-                    kinds.push("scip_definition");
-                for (const kind of kinds)
-                    references.push({
-                        callerSymbol: symbolName(info.symbol, info.displayName),
-                        callerFile: source.document.filePath,
-                        calleeSymbol: symbolName(relationship.symbol, target.info?.displayName ?? ""),
-                        calleeFile: target.document.filePath,
-                        line: source.occurrence.range.startLine + 1,
-                        column: source.occurrence.range.startCol + 1,
-                        kind,
-                    });
-            }
-        }
-    }
-    const factCount = symbols.length + references.length;
-    if (factCount > limits.maxFacts)
-        fail(`index exceeds ${limits.maxFacts} fact limit`);
-    if (performance.now() - started > limits.timeoutMs)
-        fail(`import exceeded ${limits.timeoutMs} ms limit`);
-    const result = {
-        inputPath: inputRelative.replaceAll("\\", "/"),
-        bytes: inputStat.size,
-        files: documents.length,
-        facts: factCount,
-        languages: [...new Set(documents.map((document) => document.language))].sort(),
-        indexers: parseMetadata(index).sort(),
-        symbols: symbols.sort((a, b) => a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine),
-        references: references.sort((a, b) => a.callerFile.localeCompare(b.callerFile) ||
-            a.line - b.line ||
-            a.calleeSymbol.localeCompare(b.calleeSymbol)),
-        elapsedMs: Math.round((performance.now() - started) * 1000) / 1000,
-    };
-    activeDeadline = Number.POSITIVE_INFINITY;
-    activeTimeoutMs = 0;
-    return result;
-}