ragcode-context-engine 0.1.0

package/dist/src/topology/orm-topology.js

@@ -0,0 +1,200 @@
+import ts from "typescript";
+import { stableId } from "../utils/hash.js";
+const PRISMA_READ_OPERATIONS = new Set(["aggregate", "count", "findFirst", "findMany", "findUnique"]);
+const PRISMA_WRITE_OPERATIONS = new Set(["create", "createMany", "delete", "deleteMany", "update", "updateMany", "upsert"]);
+const DRIZZLE_READ_OPERATIONS = new Set(["from", "select"]);
+const DRIZZLE_WRITE_OPERATIONS = new Set(["delete", "insert", "update"]);
+// Bounded ORM resolver: recognizes the conventional client identifiers `prisma.<model>.<op>()`
+// and `db.<op>(<model>)` / `db.select().from(<model>)` only. Renamed clients (e.g. `database`,
+// `drizzleDb`) are intentionally out of scope — broadening detection needs a resolver that
+// tracks the import binding rather than the literal name, which is deferred (see todo.md D/L4).
+export function buildOrmTopologyEdges(repoRoot, _files, sources, symbols) {
+    const edges = [];
+    for (const source of sources) {
+        const sourceFile = parseSourceFile(source);
+        const requestPayloadBindings = collectRequestPayloadBindings(sourceFile);
+        function visit(node) {
+            if (ts.isCallExpression(node)) {
+                const access = annotateDataflow(prismaAccessFromCall(node) ?? drizzleAccessFromCall(node), node, sourceFile, requestPayloadBindings);
+                if (access) {
+                    const line = lineAt(sourceFile, node);
+                    const sourceSymbol = containingSymbol(symbols, source.filePath, line) ?? fileSymbol(symbols, source.filePath);
+                    if (sourceSymbol)
+                        edges.push(ormEdge(repoRoot, source.filePath, sourceSymbol, access, line));
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        ts.forEachChild(sourceFile, visit);
+    }
+    return dedupeEdges(edges);
+}
+function prismaAccessFromCall(node) {
+    if (!ts.isPropertyAccessExpression(node.expression))
+        return undefined;
+    const operation = node.expression.name.text;
+    const kind = PRISMA_READ_OPERATIONS.has(operation)
+        ? "reads_from"
+        : PRISMA_WRITE_OPERATIONS.has(operation)
+            ? "writes_to"
+            : undefined;
+    if (!kind || !ts.isPropertyAccessExpression(node.expression.expression))
+        return undefined;
+    const modelExpression = node.expression.expression;
+    if (!ts.isIdentifier(modelExpression.expression) || modelExpression.expression.text !== "prisma")
+        return undefined;
+    const model = modelExpression.name.text;
+    return { orm: "prisma", kind, operation, model, resource: `prisma.${model}` };
+}
+function drizzleAccessFromCall(node) {
+    if (!ts.isPropertyAccessExpression(node.expression))
+        return undefined;
+    const operation = node.expression.name.text;
+    if (operation === "values" || operation === "set") {
+        const writeCall = ts.isCallExpression(node.expression.expression) ? node.expression.expression : undefined;
+        const writeAccess = writeCall ? drizzleAccessFromCall(writeCall) : undefined;
+        if (writeAccess?.kind === "writes_to")
+            return writeAccess;
+    }
+    if (DRIZZLE_WRITE_OPERATIONS.has(operation) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "db") {
+        const model = identifierText(node.arguments[0]);
+        if (model)
+            return { orm: "drizzle", kind: "writes_to", operation, model, resource: `drizzle.${model}` };
+    }
+    if (operation === "from") {
+        const model = identifierText(node.arguments[0]);
+        const selectCall = ts.isCallExpression(node.expression.expression) ? node.expression.expression : undefined;
+        if (model && selectCall && isDbSelectCall(selectCall)) {
+            return { orm: "drizzle", kind: "reads_from", operation: "select", model, resource: `drizzle.${model}` };
+        }
+    }
+    if (DRIZZLE_READ_OPERATIONS.has(operation) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "db") {
+        return { orm: "drizzle", kind: "reads_from", operation, model: "unknown", resource: "drizzle.unknown" };
+    }
+    return undefined;
+}
+function isDbSelectCall(node) {
+    return ts.isPropertyAccessExpression(node.expression)
+        && ts.isIdentifier(node.expression.expression)
+        && node.expression.expression.text === "db"
+        && node.expression.name.text === "select";
+}
+function identifierText(node) {
+    if (!node)
+        return undefined;
+    if (ts.isIdentifier(node))
+        return node.text;
+    if (ts.isPropertyAccessExpression(node))
+        return node.name.text;
+    return undefined;
+}
+function ormEdge(repoRoot, sourceFile, sourceSymbol, access, line) {
+    return {
+        projectId: sourceSymbol.projectId,
+        sourceId: sourceSymbol.id,
+        targetId: stableId([repoRoot, "orm", access.orm, access.model]),
+        kind: access.kind,
+        metadata: {
+            orm: access.orm,
+            sourceFile,
+            targetName: access.resource,
+            resource: access.resource,
+            model: access.model,
+            operation: access.operation,
+            line,
+            dataflowSource: access.dataflowSource,
+            dataflowKind: access.dataflowKind,
+            resolution: access.dataflowSource ? "orm_dataflow" : "orm_static",
+            producer: `${access.orm}_resolver`
+        }
+    };
+}
+function annotateDataflow(access, node, sourceFile, bindings) {
+    if (!access || access.kind !== "writes_to")
+        return access;
+    const source = dataflowSourceForCall(node, sourceFile, bindings);
+    return source ? { ...access, dataflowSource: source, dataflowKind: "request_payload" } : access;
+}
+function collectRequestPayloadBindings(sourceFile) {
+    const bindings = new Set();
+    function visit(node) {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+            const initializer = node.initializer.getText(sourceFile);
+            if (/\.(body|params|query)\b|\.json\s*\(/.test(initializer))
+                bindings.add(node.name.text);
+        }
+        ts.forEachChild(node, visit);
+    }
+    ts.forEachChild(sourceFile, visit);
+    return bindings;
+}
+function dataflowSourceForCall(node, sourceFile, bindings) {
+    const direct = directRequestPayloadSource(node, sourceFile);
+    if (direct)
+        return direct;
+    if (bindings.size === 0)
+        return undefined;
+    const text = node.getText(sourceFile);
+    return [...bindings].find((binding) => new RegExp(`\\b${escapeRegExp(binding)}\\b`).test(text));
+}
+function directRequestPayloadSource(node, sourceFile) {
+    for (const argument of node.arguments) {
+        const source = requestPayloadExpression(argument, sourceFile);
+        if (source)
+            return source;
+    }
+    return undefined;
+}
+function requestPayloadExpression(node, sourceFile) {
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && ["body", "params", "query"].includes(node.name.text)) {
+        return `${node.expression.text}.${node.name.text}`;
+    }
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.name.text === "json") {
+        return `${node.expression.expression.text}.json()`;
+    }
+    let found;
+    node.forEachChild((child) => {
+        if (found)
+            return;
+        found = requestPayloadExpression(child, sourceFile);
+    });
+    return found;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseSourceFile(source) {
+    return ts.createSourceFile(source.filePath, source.content, ts.ScriptTarget.Latest, true, scriptKindForPath(source.filePath));
+}
+function containingSymbol(symbols, filePath, line) {
+    return symbols
+        .filter((symbol) => symbol.filePath === filePath && symbol.kind !== "file" && symbol.startLine <= line && symbol.endLine >= line)
+        .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0];
+}
+function fileSymbol(symbols, filePath) {
+    return symbols.find((symbol) => symbol.filePath === filePath && symbol.kind === "file");
+}
+function lineAt(sourceFile, node) {
+    return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function scriptKindForPath(filePath) {
+    if (filePath.endsWith(".tsx"))
+        return ts.ScriptKind.TSX;
+    if (filePath.endsWith(".jsx"))
+        return ts.ScriptKind.JSX;
+    if (filePath.endsWith(".js") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs"))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+function dedupeEdges(edges) {
+    const seen = new Set();
+    const deduped = [];
+    for (const edge of edges) {
+        const key = [edge.kind, edge.sourceId, edge.targetId, edge.metadata?.operation, edge.metadata?.sourceFile, edge.metadata?.line].join("::");
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(edge);
+    }
+    return deduped;
+}

package/dist/src/topology/runtime-topology.d.ts

@@ -0,0 +1,3 @@
+import type { CodeFile, GraphEdge, SymbolNode } from "../core/types.js";
+import type { TypeScriptSourceFile } from "../lsp/typescript-language-service.js";
+export declare function buildRuntimeTopologyEdges(repoRoot: string, files: CodeFile[], sources: TypeScriptSourceFile[], symbols: SymbolNode[]): GraphEdge[];

package/dist/src/topology/runtime-topology.js

@@ -0,0 +1,204 @@
+import ts from "typescript";
+import { stableId } from "../utils/hash.js";
+const READ_OPERATIONS = new Set(["aggregate", "count", "findFirst", "findMany", "findUnique", "get", "query", "read", "select"]);
+const WRITE_OPERATIONS = new Set(["create", "createMany", "delete", "deleteMany", "insert", "save", "set", "update", "updateMany", "upsert", "write"]);
+const EVENT_OPERATIONS = new Set(["addEventListener", "handle", "listen", "on", "once", "subscribe"]);
+const RESOURCE_ROOTS = new Set(["client", "database", "db", "prisma"]);
+export function buildRuntimeTopologyEdges(repoRoot, files, sources, symbols) {
+    return dedupeEdges([
+        ...resourceAccessEdges(repoRoot, sources, symbols),
+        ...eventHandlerEdges(repoRoot, sources, symbols),
+        ...middlewareUsageEdges(files, symbols)
+    ]);
+}
+function resourceAccessEdges(repoRoot, sources, symbols) {
+    const edges = [];
+    for (const source of sources) {
+        const sourceFile = parseSourceFile(source);
+        function visit(node) {
+            if (ts.isCallExpression(node)) {
+                const access = resourceAccessFromCall(node);
+                if (access) {
+                    const line = lineAt(sourceFile, node);
+                    const sourceSymbol = containingSymbol(symbols, source.filePath, line) ?? fileSymbol(symbols, source.filePath);
+                    if (sourceSymbol) {
+                        edges.push({
+                            projectId: sourceSymbol.projectId,
+                            sourceId: sourceSymbol.id,
+                            targetId: stableId([repoRoot, "resource", access.resource]),
+                            kind: access.kind,
+                            metadata: {
+                                sourceFile: source.filePath,
+                                targetName: access.resource,
+                                resource: access.resource,
+                                operation: access.operation,
+                                line,
+                                resolution: "resource_static",
+                                producer: "typescript_runtime_topology"
+                            }
+                        });
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        ts.forEachChild(sourceFile, visit);
+    }
+    return edges;
+}
+function eventHandlerEdges(repoRoot, sources, symbols) {
+    const edges = [];
+    for (const source of sources) {
+        const sourceFile = parseSourceFile(source);
+        function visit(node) {
+            if (ts.isCallExpression(node)) {
+                const event = eventFromCall(node);
+                if (event) {
+                    const line = lineAt(sourceFile, node);
+                    const sourceSymbol = containingSymbol(symbols, source.filePath, line) ?? fileSymbol(symbols, source.filePath);
+                    if (sourceSymbol) {
+                        edges.push({
+                            projectId: sourceSymbol.projectId,
+                            sourceId: sourceSymbol.id,
+                            targetId: stableId([repoRoot, "event", event.name]),
+                            kind: "handles_event",
+                            metadata: {
+                                sourceFile: source.filePath,
+                                targetName: event.name,
+                                event: event.name,
+                                operation: event.operation,
+                                line,
+                                resolution: "event_static",
+                                producer: "typescript_runtime_topology"
+                            }
+                        });
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        ts.forEachChild(sourceFile, visit);
+    }
+    return edges;
+}
+function middlewareUsageEdges(files, symbols) {
+    const middlewareFile = files.find((file) => /^(src\/)?middleware\.[jt]s$/.test(file.path));
+    if (!middlewareFile)
+        return [];
+    const targetSymbol = symbols.find((symbol) => symbol.filePath === middlewareFile.path && symbol.name === "middleware")
+        ?? fileSymbol(symbols, middlewareFile.path);
+    if (!targetSymbol)
+        return [];
+    const edges = [];
+    for (const file of files) {
+        if (!isRouteFile(file.path))
+            continue;
+        const sourceSymbol = routeHandlerSymbol(symbols, file.path) ?? fileSymbol(symbols, file.path);
+        if (!sourceSymbol)
+            continue;
+        edges.push({
+            projectId: sourceSymbol.projectId,
+            sourceId: sourceSymbol.id,
+            targetId: targetSymbol.id,
+            kind: "uses_middleware",
+            metadata: {
+                framework: "nextjs",
+                sourceFile: file.path,
+                targetFile: middlewareFile.path,
+                targetName: targetSymbol.name,
+                resolution: "framework_static",
+                producer: "typescript_runtime_topology"
+            }
+        });
+    }
+    return edges;
+}
+function resourceAccessFromCall(node) {
+    if (!ts.isPropertyAccessExpression(node.expression))
+        return undefined;
+    const operation = node.expression.name.text;
+    const kind = READ_OPERATIONS.has(operation)
+        ? "reads_from"
+        : WRITE_OPERATIONS.has(operation)
+            ? "writes_to"
+            : undefined;
+    if (!kind || !ts.isPropertyAccessExpression(node.expression.expression))
+        return undefined;
+    const resourceExpression = node.expression.expression;
+    if (!ts.isIdentifier(resourceExpression.expression))
+        return undefined;
+    const root = resourceExpression.expression.text;
+    if (!RESOURCE_ROOTS.has(root))
+        return undefined;
+    return {
+        kind,
+        operation,
+        resource: `${root}.${resourceExpression.name.text}`
+    };
+}
+function eventFromCall(node) {
+    if (!ts.isPropertyAccessExpression(node.expression))
+        return undefined;
+    const operation = node.expression.name.text;
+    if (!EVENT_OPERATIONS.has(operation))
+        return undefined;
+    const eventName = stringLiteralValue(node.arguments[0]);
+    if (!eventName)
+        return undefined;
+    if (!looksLikeEventReceiver(node.expression.expression) && operation !== "addEventListener")
+        return undefined;
+    return { operation, name: eventName };
+}
+function looksLikeEventReceiver(expression) {
+    const text = expression.getText();
+    return /event|emitter|bus|queue|stream|socket|document|window/i.test(text);
+}
+function stringLiteralValue(node) {
+    if (!node)
+        return undefined;
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+        return node.text;
+    return undefined;
+}
+function parseSourceFile(source) {
+    return ts.createSourceFile(source.filePath, source.content, ts.ScriptTarget.Latest, true, scriptKindForPath(source.filePath));
+}
+function routeHandlerSymbol(symbols, filePath) {
+    return symbols.find((symbol) => symbol.filePath === filePath && ["GET", "POST", "PUT", "PATCH", "DELETE"].includes(symbol.name))
+        ?? symbols.find((symbol) => symbol.filePath === filePath && symbol.exported && symbol.kind !== "file");
+}
+function fileSymbol(symbols, filePath) {
+    return symbols.find((symbol) => symbol.filePath === filePath && symbol.kind === "file");
+}
+function containingSymbol(symbols, filePath, line) {
+    return symbols
+        .filter((symbol) => symbol.filePath === filePath && symbol.kind !== "file" && symbol.startLine <= line && symbol.endLine >= line)
+        .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0];
+}
+function isRouteFile(filePath) {
+    return /(?:^|\/)(?:app|pages)\/api\/.+(?:\/route)?\.[jt]sx?$/.test(filePath.replaceAll("\\", "/"));
+}
+function lineAt(sourceFile, node) {
+    return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function scriptKindForPath(filePath) {
+    if (filePath.endsWith(".tsx"))
+        return ts.ScriptKind.TSX;
+    if (filePath.endsWith(".jsx"))
+        return ts.ScriptKind.JSX;
+    if (filePath.endsWith(".js") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs"))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+function dedupeEdges(edges) {
+    const seen = new Set();
+    const deduped = [];
+    for (const edge of edges) {
+        const key = [edge.kind, edge.sourceId, edge.targetId, edge.metadata?.targetName, edge.metadata?.sourceFile].join("::");
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(edge);
+    }
+    return deduped;
+}

package/dist/src/topology/symbol-resolver.d.ts

@@ -0,0 +1,6 @@
+import type { CodeFile, GraphEdge, SymbolNode } from "../core/types.js";
+export interface ImportBinding {
+    imported: string;
+    local: string;
+}
+export declare function resolveGraphEdges(files: CodeFile[], symbols: SymbolNode[], edges: GraphEdge[]): GraphEdge[];

package/dist/src/topology/symbol-resolver.js

@@ -0,0 +1,74 @@
+import { createExportIndex, exportKey } from "./export-index.js";
+import { resolveImportPath } from "./import-resolver.js";
+export function resolveGraphEdges(files, symbols, edges) {
+    const exportIndex = createExportIndex(symbols);
+    const bindingsByFile = new Map();
+    const resolvedEdges = [];
+    for (const edge of edges) {
+        if (edge.kind !== "imports") {
+            resolvedEdges.push(edge);
+            continue;
+        }
+        const sourceFile = stringMetadata(edge, "sourceFile");
+        const importSource = stringMetadata(edge, "source");
+        const targetFile = sourceFile && importSource ? resolveImportPath(sourceFile, importSource, files) : undefined;
+        if (!sourceFile || !targetFile) {
+            resolvedEdges.push({ ...edge, metadata: { ...edge.metadata, resolution: "unresolved" } });
+            continue;
+        }
+        const fileSymbol = exportIndex.fileSymbols.get(targetFile);
+        resolvedEdges.push({
+            ...edge,
+            targetId: fileSymbol?.id ?? edge.targetId,
+            metadata: { ...edge.metadata, resolution: "resolved", targetFile }
+        });
+        const bindings = importBindings(edge);
+        if (bindings.length === 0)
+            continue;
+        const fileBindings = bindingsByFile.get(sourceFile) ?? new Map();
+        for (const binding of bindings) {
+            fileBindings.set(binding.local, { ...binding, targetFile });
+        }
+        bindingsByFile.set(sourceFile, fileBindings);
+    }
+    return resolvedEdges.map((edge) => {
+        if (edge.kind !== "calls")
+            return edge;
+        const sourceFile = stringMetadata(edge, "sourceFile");
+        const targetName = stringMetadata(edge, "targetName");
+        if (!sourceFile || !targetName)
+            return edge;
+        const binding = bindingsByFile.get(sourceFile)?.get(targetName);
+        if (!binding)
+            return { ...edge, metadata: { ...edge.metadata, resolution: "unresolved" } };
+        const targetSymbol = exportIndex.exportedSymbols.get(exportKey(binding.targetFile, binding.imported));
+        if (!targetSymbol)
+            return { ...edge, metadata: { ...edge.metadata, resolution: "unresolved", targetFile: binding.targetFile } };
+        return {
+            ...edge,
+            targetId: targetSymbol.id,
+            metadata: {
+                ...edge.metadata,
+                resolution: "resolved",
+                targetFile: targetSymbol.filePath,
+                importedName: binding.imported
+            }
+        };
+    });
+}
+function importBindings(edge) {
+    const raw = edge.metadata?.bindings;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter(isImportBinding);
+}
+function isImportBinding(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return typeof candidate.imported === "string" && typeof candidate.local === "string";
+}
+function stringMetadata(edge, key) {
+    const value = edge.metadata?.[key];
+    return typeof value === "string" ? value : undefined;
+}

package/dist/src/topology/test-topology.d.ts

@@ -0,0 +1,2 @@
+import type { GraphEdge, SymbolNode } from "../core/types.js";
+export declare function buildTestTopologyEdges(symbols: SymbolNode[], edges: GraphEdge[]): GraphEdge[];

package/dist/src/topology/test-topology.js

@@ -0,0 +1,82 @@
+import { createExportIndex, exportKey } from "./export-index.js";
+export function buildTestTopologyEdges(symbols, edges) {
+    const exportIndex = createExportIndex(symbols);
+    const testEdges = [];
+    for (const edge of edges) {
+        if (edge.kind !== "imports")
+            continue;
+        const testFile = stringMetadata(edge, "sourceFile");
+        const sourceFile = stringMetadata(edge, "targetFile");
+        if (!testFile || !sourceFile || !isTestFile(testFile) || isTestFile(sourceFile))
+            continue;
+        const testFileSymbol = exportIndex.fileSymbols.get(testFile);
+        if (!testFileSymbol)
+            continue;
+        const bindings = importBindings(edge);
+        const sourceSymbols = bindings.length > 0
+            ? bindings.map((binding) => ({
+                symbol: binding.imported === "default"
+                    ? undefined
+                    : exportIndex.exportedSymbols.get(exportKey(sourceFile, binding.imported)),
+                binding
+            }))
+            : [{ symbol: undefined, binding: undefined }];
+        for (const entry of sourceSymbols) {
+            const sourceSymbol = entry.symbol ?? exportIndex.fileSymbols.get(sourceFile);
+            if (!sourceSymbol)
+                continue;
+            testEdges.push({
+                projectId: edge.projectId,
+                sourceId: sourceSymbol.id,
+                targetId: testFileSymbol.id,
+                kind: "tested_by",
+                metadata: {
+                    sourceFile,
+                    targetFile: testFile,
+                    testFile,
+                    targetName: testFile,
+                    importedName: entry.binding?.imported,
+                    localName: entry.binding?.local,
+                    line: edge.metadata?.line,
+                    resolution: "test_import",
+                    colocated: sameDirectory(sourceFile, testFile)
+                }
+            });
+        }
+    }
+    return dedupeEdges(testEdges);
+}
+function importBindings(edge) {
+    const raw = edge.metadata?.bindings;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter(isImportBinding);
+}
+function isImportBinding(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return typeof candidate.imported === "string" && typeof candidate.local === "string";
+}
+function stringMetadata(edge, key) {
+    const value = edge.metadata?.[key];
+    return typeof value === "string" ? value : undefined;
+}
+function isTestFile(filePath) {
+    return /(^|\/)(__tests__|tests?)(\/|$)|\.(test|spec)\.[jt]sx?$/.test(filePath);
+}
+function sameDirectory(left, right) {
+    return left.split("/").slice(0, -1).join("/") === right.split("/").slice(0, -1).join("/");
+}
+function dedupeEdges(edges) {
+    const seen = new Set();
+    const deduped = [];
+    for (const edge of edges) {
+        const key = [edge.kind, edge.sourceId, edge.targetId, edge.metadata?.importedName].join("::");
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(edge);
+    }
+    return deduped;
+}

package/dist/src/utils/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function sha256(input: string): string;
+export declare function stableId(parts: Array<string | number | undefined>): string;

package/dist/src/utils/hash.js

@@ -0,0 +1,7 @@
+import { createHash } from "node:crypto";
+export function sha256(input) {
+    return createHash("sha256").update(input).digest("hex");
+}
+export function stableId(parts) {
+    return sha256(parts.filter((part) => part !== undefined).join("::")).slice(0, 24);
+}

package/dist/src/utils/path.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeRepoPath(repoRoot: string, candidate: string): string;
+export declare function normalizeUserPath(candidate: string): string;

package/dist/src/utils/path.js

@@ -0,0 +1,7 @@
+import path from "node:path";
+export function normalizeRepoPath(repoRoot, candidate) {
+    return path.relative(repoRoot, candidate).split(path.sep).join("/");
+}
+export function normalizeUserPath(candidate) {
+    return candidate.split(path.sep).join("/");
+}

package/dist/src/watch/event-journal.d.ts

@@ -0,0 +1,17 @@
+export interface WatchEventJournalEntry {
+    event: "add" | "change" | "unlink" | "addDir" | "unlinkDir";
+    filePath: string;
+    observedAtMs: number;
+}
+export declare class FileEventJournal {
+    readonly journalPath: string;
+    private readonly repoRoot?;
+    constructor(journalPath: string, repoRoot?: string | undefined);
+    static forRepo(repoRoot: string, fileName?: string): FileEventJournal;
+    append(entry: WatchEventJournalEntry): Promise<void>;
+    appendBatch(entries: WatchEventJournalEntry[]): Promise<void>;
+    replay(): Promise<WatchEventJournalEntry[]>;
+    replayPaths(): Promise<string[]>;
+    truncate(): Promise<void>;
+    private normalizeJournalPath;
+}