context-slice 1.8.2

package/dist/src/planner/composition.js

@@ -0,0 +1,372 @@
+import { estimateTokens } from "./budget.js";
+const TYPE_KINDS = new Set([
+    "class",
+    "interface",
+    "enum",
+    "record",
+    "namespace",
+]);
+/** A skeleton stays compact even for a large class. */
+const MAX_SKELETON_MEMBERS = 12;
+/** The first line of a declaration, exactly as written, without its opening brace. */
+export function declarationLine(symbol) {
+    return symbol.source
+        .split("\n")[0]
+        .trim()
+        .replace(/\s*\{\s*$/, "")
+        .replace(/\s*=>\s*$/, "")
+        .trim();
+}
+/**
+ * Java fields are not indexed as symbols, so read their declarations from the
+ * enclosing type's source. Analysis only: nothing is added to the index, so
+ * retrieval and ranking are untouched.
+ */
+function javaFieldDeclarations(parent) {
+    if (parent.language !== "java")
+        return [];
+    return [
+        ...(parent.body ?? parent.source).matchAll(/^\s*(?:(?:public|protected|private|static|final|transient|volatile)\s+)*[A-Za-z_$][\w$<>,.[\]\s]*?\s+[A-Za-z_$][\w$]*\s*(?:=[^;]*)?;/gm),
+    ]
+        .map((match) => match[0].trim())
+        .filter((declaration) => !/[()]/.test(declaration));
+}
+/**
+ * Compose a compact skeleton of the target's enclosing type: its own
+ * declaration line, its field declarations and up to 12 member declaration
+ * lines. Never a body, so this can never become a whole-class dump.
+ */
+export function composeSiblings(index, target, 
+/** Symbols already in the slice: the skeleton must not repeat them. */
+alreadyIncluded = new Set()) {
+    const parent = target.parentId
+        ? index.symbols.find((symbol) => symbol.id === target.parentId)
+        : undefined;
+    if (!parent || !TYPE_KINDS.has(parent.kind))
+        return [];
+    const members = index.symbols.filter((symbol) => symbol.parentId === parent.id && symbol.id !== target.id);
+    if (!members.length)
+        return [];
+    const remaining = members.filter((member) => !alreadyIncluded.has(member.id));
+    const shown = remaining
+        .sort((a, b) => a.range.startLine - b.range.startLine)
+        .slice(0, MAX_SKELETON_MEMBERS);
+    const lines = [
+        `// Enclosing type of ${target.name}`,
+        declarationLine(parent),
+        ...javaFieldDeclarations(parent).map((declaration) => `  ${declaration}`),
+        ...shown.map((member) => `  ${declarationLine(member)}`),
+    ];
+    if (remaining.length > shown.length)
+        lines.push(`  // … ${remaining.length - shown.length} more members`);
+    const rendered = lines.join("\n");
+    return [
+        {
+            symbol: parent,
+            label: parent.qualifiedName ?? parent.name,
+            reason: "enclosing type",
+            evidence: [
+                `${target.name} is declared in ${parent.name}; declaration lines only, ${shown.length} of ${members.length} members${members.length - remaining.length > 0
+                    ? `, ${members.length - remaining.length} already in the slice`
+                    : ""}`,
+            ],
+            rendered,
+            estimatedTokens: estimateTokens(rendered),
+            filePath: parent.filePath,
+        },
+    ];
+}
+/**
+ * Compose each related file's top-level `use` declarations (Task 1's
+ * synthetic per-file import symbol) into the slice, so a caller's imports
+ * explain names the caller's skeleton references. Rust only: other
+ * languages don't get a synthetic import symbol to find.
+ */
+export function composeImportContext(index, target, relatedFiles, alreadyIncluded) {
+    if (target.language !== "rust")
+        return [];
+    const candidates = [];
+    const seen = new Set();
+    for (const file of relatedFiles) {
+        if (seen.has(file))
+            continue;
+        seen.add(file);
+        const symbol = index.symbols.find((s) => s.kind === "namespace" && s.metadata?.moduleScope === true && s.filePath === file);
+        if (!symbol || alreadyIncluded.has(symbol.id) || !symbol.source)
+            continue;
+        candidates.push({
+            symbol,
+            label: `Imports in ${file}`,
+            reason: "file imports",
+            evidence: [`file-level use declarations for ${file}`],
+            rendered: symbol.source,
+            estimatedTokens: estimateTokens(symbol.source),
+            filePath: file,
+        });
+    }
+    return candidates;
+}
+/**
+ * Compose the route(s) that reach the target: a ROUTE_TO_HANDLER relation
+ * whose source is the target itself, or an already-included caller of it
+ * (recovering the controller→service direction when the target is a
+ * service method one hop below the route handler). Java only: other
+ * languages have no Spring MVC extractor to find relations from.
+ */
+/** Pull the injected field/param/setter name out of a DI relation's evidence text. */
+function fieldOrParamName(evidence) {
+    return (evidence.match(/constructor parameter \S+ (\S+)/)?.[1] ??
+        evidence.match(/@\w+ field \S+ (\S+)/)?.[1] ??
+        evidence.match(/@\w+ setter (\w+)\(/)?.[1]);
+}
+function injectionMechanism(evidence) {
+    if (evidence.startsWith("constructor parameter"))
+        return "constructor-injected";
+    if (/@\w+ field /.test(evidence))
+        return "field-injected";
+    if (/@\w+ setter /.test(evidence))
+        return "setter-injected";
+    return "dependency-injected";
+}
+/**
+ * Compose the dependencies the target's own type injects, but only the ones
+ * relevant to this task: a dependency is surfaced only when the resolved
+ * type owns a member already present in `relatedIds` (a direct caller or
+ * callee already in the slice) — otherwise it's annotation spam. Java only:
+ * other languages have no DI extractor to find relations from.
+ */
+export function composeDependencyContext(index, target, relatedIds, alreadyIncluded) {
+    if (target.language !== "java")
+        return [];
+    let owner = target.kind === "class" ? target : undefined;
+    let cursor = target.parentId
+        ? index.symbols.find((s) => s.id === target.parentId)
+        : undefined;
+    while (!owner && cursor) {
+        if (cursor.kind === "class")
+            owner = cursor;
+        else
+            cursor = cursor.parentId ? index.symbols.find((s) => s.id === cursor.parentId) : undefined;
+    }
+    if (!owner)
+        return [];
+    const ownSymbolIds = new Set(index.symbols
+        .filter((s) => s.parentId === owner.id &&
+        (s.kind === "constructor" || s.kind === "method"))
+        .map((s) => s.id));
+    ownSymbolIds.add(owner.id);
+    const candidates = [];
+    const seenRelations = new Set();
+    for (const relation of index.enterpriseRelations) {
+        if (relation.kind !== "INJECTS_DEPENDENCY")
+            continue;
+        if (relation.confidence === "unresolved")
+            continue;
+        if (!ownSymbolIds.has(relation.sourceSymbolId))
+            continue;
+        if (!relation.targetSymbolId)
+            continue;
+        const dependencyMembers = index.symbols.filter((s) => s.parentId === relation.targetSymbolId);
+        const isRelevant = dependencyMembers.some((s) => relatedIds.has(s.id));
+        if (!isRelevant)
+            continue;
+        const key = `${relation.sourceSymbolId}:${relation.targetSymbolId}`;
+        if (seenRelations.has(key))
+            continue;
+        seenRelations.add(key);
+        const evidence = relation.evidence[0] ?? "";
+        const name = fieldOrParamName(evidence);
+        const mechanism = injectionMechanism(evidence);
+        const rendered = `// Dependency\n${owner.name}.${name ?? relation.targetLabel} → ${relation.targetLabel} (${mechanism})`;
+        candidates.push({
+            label: relation.targetLabel ?? "dependency",
+            reason: "enterprise relation",
+            evidence: relation.evidence,
+            rendered,
+            estimatedTokens: estimateTokens(rendered),
+            filePath: relation.filePath,
+        });
+    }
+    return candidates;
+}
+/**
+ * Compose the transaction attributes carried by the target itself or by an
+ * already-included caller/callee — a method's own @Transactional attributes
+ * matter regardless of which symbol in the slice they belong to, since this
+ * family's relations are already keyed directly to the method (no
+ * class-ownership walk needed, unlike composeDependencyContext). Java only:
+ * other languages have no @Transactional extractor to find relations from.
+ */
+export function composeTransactionContext(index, target, relatedIds, alreadyIncluded) {
+    if (target.language !== "java")
+        return [];
+    const candidateIds = new Set([target.id, ...relatedIds]);
+    const candidates = [];
+    for (const relation of index.enterpriseRelations) {
+        if (relation.kind !== "TRANSACTION_BOUNDARY")
+            continue;
+        if (!candidateIds.has(relation.sourceSymbolId))
+            continue;
+        // The method symbol is looked up only for a friendlier label/name; it is
+        // never attached as `symbol` here, since it is always already in the
+        // slice (as the target itself, or as an already-included caller/callee)
+        // and the shared composition loop in buildPreview dedupes candidates by
+        // symbol id — attaching it would silently drop this very candidate.
+        const methodSymbol = index.symbols.find((s) => s.id === relation.sourceSymbolId);
+        const name = methodSymbol?.qualifiedName ?? methodSymbol?.name ?? target.name;
+        const rendered = `// Transaction\n${name} (${relation.targetLabel})`;
+        candidates.push({
+            label: relation.targetLabel ?? "transaction",
+            reason: "enterprise relation",
+            evidence: relation.evidence,
+            rendered,
+            estimatedTokens: estimateTokens(rendered),
+            filePath: methodSymbol?.filePath ?? relation.filePath,
+        });
+    }
+    return candidates;
+}
+const JPA_RELATION_KINDS = new Set([
+    "ENTITY_RELATION",
+    "PERSISTS_ENTITY",
+    "REPOSITORY_QUERY",
+]);
+/** `"@OneToMany on field pets"` → `{ relKind: "OneToMany", field: "pets" }`. */
+function entityRelationParts(evidence) {
+    const match = evidence.match(/^@(\w+) on field (\w+)/);
+    return { relKind: match?.[1], field: match?.[2] };
+}
+/** `"extends JpaRepository<Owner, Integer>"` → `"JpaRepository"`. */
+function baseRepositoryName(evidence) {
+    return evidence.match(/extends\s+(\w+)/)?.[1];
+}
+/**
+ * Compose the JPA entity relationships and Spring Data repository/query
+ * facts relevant to the target: an ENTITY_RELATION owned by the target's
+ * enclosing entity class (fields aren't indexed as symbols, so a member
+ * target needs the class-ownership walk, same as composeDependencyContext),
+ * or a PERSISTS_ENTITY/REPOSITORY_QUERY keyed directly to the target itself
+ * (repository interface or query method are already indexed symbols, so no
+ * walk is needed for those two). An ENTITY_RELATION is further gated by
+ * relevance (its resolved target entity must own a member already in
+ * `relatedIds`), same "no annotation spam" rule composeDependencyContext
+ * applies — PERSISTS_ENTITY/REPOSITORY_QUERY don't need this, they're
+ * already scoped to the single interface/method, not an owning class with
+ * multiple children. Java only: other languages have no JPA/Spring Data
+ * extractor to find relations from.
+ */
+export function composeJpaContext(index, target, relatedIds, alreadyIncluded) {
+    if (target.language !== "java")
+        return [];
+    let owner = target.kind === "class" ? target : undefined;
+    let cursor = target.parentId
+        ? index.symbols.find((s) => s.id === target.parentId)
+        : undefined;
+    while (!owner && cursor) {
+        if (cursor.kind === "class")
+            owner = cursor;
+        else
+            cursor = cursor.parentId ? index.symbols.find((s) => s.id === cursor.parentId) : undefined;
+    }
+    const candidateIds = new Set([target.id, ...relatedIds]);
+    if (owner)
+        candidateIds.add(owner.id);
+    const candidates = [];
+    const seenRelations = new Set();
+    for (const relation of index.enterpriseRelations) {
+        if (!JPA_RELATION_KINDS.has(relation.kind))
+            continue;
+        if (relation.confidence === "unresolved")
+            continue;
+        if (!candidateIds.has(relation.sourceSymbolId))
+            continue;
+        // Unlike PERSISTS_ENTITY/REPOSITORY_QUERY (already keyed directly to the
+        // interface/method, no class-ownership walk involved), an
+        // ENTITY_RELATION is keyed to the whole owning class, so without a
+        // relevance gate every relationship field on that class would surface
+        // for any member target — same "no annotation spam" discipline as
+        // composeDependencyContext: only surface it when its resolved target
+        // entity type owns a member already in the slice.
+        if (relation.kind === "ENTITY_RELATION") {
+            if (!relation.targetSymbolId)
+                continue;
+            const targetMembers = index.symbols.filter((s) => s.parentId === relation.targetSymbolId);
+            if (!targetMembers.some((s) => relatedIds.has(s.id)))
+                continue;
+        }
+        // evidence[0] names the declaring field (e.g. "@ManyToOne on field
+        // billingAddress"): without it, two distinct fields of the same kind on
+        // the same class pointing at the same target type (billingAddress and
+        // shippingAddress, both @ManyToOne Address) would collapse into one key
+        // and silently drop the second relation.
+        const key = `${relation.sourceSymbolId}:${relation.kind}:${relation.targetLabel ?? ""}:${relation.evidence[0] ?? ""}`;
+        if (seenRelations.has(key))
+            continue;
+        seenRelations.add(key);
+        // The source symbol is looked up only for a friendlier label/name; it is
+        // never attached as `symbol` here, since it may already be in the slice
+        // (as the target itself, its enclosing class, or an already-included
+        // relative) and the shared composition loop in buildPreview dedupes
+        // candidates by symbol id — attaching it would silently drop this very
+        // candidate.
+        const sourceSymbol = index.symbols.find((s) => s.id === relation.sourceSymbolId);
+        const name = sourceSymbol?.name ?? target.name;
+        let rendered;
+        if (relation.kind === "ENTITY_RELATION") {
+            const { relKind, field } = entityRelationParts(relation.evidence[0] ?? "");
+            rendered = `// Entity relationship\n${name}${field ? `.${field}` : ""} → ${relation.targetLabel}${relKind ? ` (${relKind})` : ""}`;
+        }
+        else if (relation.kind === "PERSISTS_ENTITY") {
+            const base = baseRepositoryName(relation.evidence[0] ?? "");
+            rendered = `// Repository\n${name} → ${relation.targetLabel}${base ? ` (${base})` : ""}`;
+        }
+        else {
+            rendered = `// Query\n${name} → ${relation.evidence.join(", ")}`;
+        }
+        candidates.push({
+            label: relation.targetLabel ?? relation.kind,
+            reason: "enterprise relation",
+            evidence: relation.evidence,
+            rendered,
+            estimatedTokens: estimateTokens(rendered),
+            filePath: sourceSymbol?.filePath ?? relation.filePath,
+        });
+    }
+    return candidates;
+}
+export function composeRouteContext(index, target, relatedIds, alreadyIncluded) {
+    if (target.language !== "java")
+        return [];
+    const candidateIds = new Set([target.id, ...relatedIds]);
+    const candidates = [];
+    const seenRelations = new Set();
+    for (const relation of index.enterpriseRelations) {
+        if (relation.kind !== "ROUTE_TO_HANDLER")
+            continue;
+        if (relation.confidence === "unresolved")
+            continue;
+        if (!candidateIds.has(relation.sourceSymbolId))
+            continue;
+        const key = `${relation.sourceSymbolId}:${relation.kind}:${relation.targetLabel ?? ""}`;
+        if (seenRelations.has(key))
+            continue;
+        seenRelations.add(key);
+        // The handler symbol is looked up only for a friendlier filePath; it is
+        // never attached as `symbol` here, since it may already be in the slice
+        // (as the target itself, or as an already-included caller) and the
+        // shared composition loop in buildPreview dedupes candidates by symbol
+        // id — attaching it would silently drop the very route line this
+        // function exists to surface.
+        const handlerSymbol = index.symbols.find((s) => s.id === relation.sourceSymbolId);
+        const rendered = `// Route\n${relation.targetLabel} → ${handlerSymbol?.name ?? target.name}`;
+        candidates.push({
+            label: relation.targetLabel ?? "route",
+            reason: "enterprise relation",
+            evidence: relation.evidence,
+            rendered,
+            estimatedTokens: estimateTokens(rendered),
+            filePath: handlerSymbol?.filePath ?? relation.filePath,
+        });
+    }
+    return candidates;
+}

package/dist/src/planner/rank.js

@@ -0,0 +1,10 @@
+export function rankSymbol(symbol, query, intent = "") {
+    const terms = `${query} ${intent}`
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean);
+    const text = `${symbol.name} ${symbol.qualifiedName ?? ""} ${symbol.signature ?? ""} ${symbol.filePath} ${symbol.annotations.join(" ")}`.toLowerCase();
+    const matches = terms.filter((term) => text.includes(term)).length;
+    const exact = symbol.name.toLowerCase() === query.trim().toLowerCase() ? 0.5 : 0;
+    return Number((matches / Math.max(terms.length, 1) + exact).toFixed(4));
+}

package/dist/src/render/compact-context.js

@@ -0,0 +1,11 @@
+export const renderSignature = (s) => s.signature ?? `${s.kind} ${s.name}`;
+export function renderSkeleton(s, calls = []) {
+    return [
+        renderSignature(s),
+        s.metadata?.exported ? `\nEXPORT\n${s.metadata.exported}` : "",
+        s.annotations.length ? `\nANNOTATIONS\n${s.annotations.join("\n")}` : "",
+        calls.length ? `\nCALLS\n${calls.join("\n")}` : "",
+    ]
+        .join("\n")
+        .trim();
+}

package/dist/src/server/mcp-server.js

@@ -0,0 +1,154 @@
+import { execFileSync } from "node:child_process";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { ProjectIndex } from "../indexer/index.js";
+import { packageInfo } from "../package-info.js";
+import { estimateTokens } from "../planner/budget.js";
+import { renderSignature, renderSkeleton } from "../render/compact-context.js";
+import { buildPreview } from "../workflow/preview.js";
+const result = (value) => ({
+    content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
+});
+export function gitDiffArgs(base, head) {
+    return base || head ? [base ?? "HEAD", ...(head ? [head] : [])] : ["HEAD"];
+}
+export async function startMcpServer(root = process.env.CONTEXT_SLICE_ROOT ?? process.cwd()) {
+    const index = new ProjectIndex(root);
+    const server = new McpServer({
+        name: packageInfo.name,
+        version: packageInfo.version,
+    });
+    const refresh = () => index.refresh();
+    const one = (symbol) => {
+        const candidates = index.resolveSymbol(symbol);
+        if (!candidates.length)
+            throw new Error(`Symbol not found: ${symbol}`);
+        if (candidates.length > 1)
+            throw new Error(`Ambiguous symbol: ${symbol}. Candidates: ${candidates.map((candidate) => candidate.id).join(", ")}`);
+        return candidates[0];
+    };
+    server.tool("context.search", "Find relevant Java symbols without reading every source file.", {
+        query: z.string(),
+        limit: z.number().int().positive().max(100).optional(),
+    }, async ({ query, limit }) => {
+        const refreshed = refresh();
+        return result({
+            refresh: refreshed,
+            results: index.search(query, limit ?? 10),
+        });
+    });
+    server.tool("context.symbol", "Read a Java symbol as a signature, skeleton, body, or full source.", {
+        symbol: z.string(),
+        detail: z.enum(["signature", "skeleton", "body", "full"]).optional(),
+    }, async ({ symbol, detail }) => {
+        const refreshed = refresh();
+        const target = one(symbol);
+        const level = detail ?? "skeleton";
+        const calls = index.calls
+            .filter((call) => call.callerId === target.id)
+            .map((call) => `${call.receiverText ? `${call.receiverText}.` : ""}${call.calleeName} [${call.confidence}]`);
+        let rendered = renderSignature(target);
+        if (level === "skeleton")
+            rendered = renderSkeleton(target, calls);
+        if (level === "body")
+            rendered = target.body ?? target.source;
+        if (level === "full")
+            rendered = target.source;
+        return result({
+            refresh: refreshed,
+            symbol: target,
+            detail: level,
+            rendered,
+        });
+    });
+    server.tool("context.callers", "Find callers with bounded traversal depth.", {
+        symbol: z.string(),
+        depth: z.number().int().min(1).max(5).optional(),
+        limit: z.number().int().positive().max(100).optional(),
+    }, async ({ symbol, depth, limit }) => {
+        const refreshed = refresh();
+        const target = one(symbol);
+        const actualDepth = depth ?? 1;
+        return result({
+            refresh: refreshed,
+            target: renderSignature(target),
+            depth: actualDepth,
+            callers: index
+                .callersAtDepth(target, actualDepth)
+                .slice(0, limit ?? 10)
+                .map((caller) => ({
+                id: caller.id,
+                signature: caller.signature,
+                filePath: caller.filePath,
+            })),
+        });
+    });
+    server.tool("context.preview", "Compose an explainable, budget-bounded developer context preview.", {
+        task: z.string(),
+        budget: z.number().int().positive().optional(),
+        depth: z.number().int().min(1).max(5).optional(),
+    }, async ({ task, budget, depth }) => {
+        const refreshed = refresh();
+        return result({
+            refresh: refreshed,
+            ...buildPreview(index, task, { budget, depth }),
+        });
+    });
+    server.tool("context.slice", "Compose a strict-budget context slice for a symbol.", {
+        symbol: z.string(),
+        intent: z.string().optional(),
+        budget: z.number().int().positive().optional(),
+        depth: z.number().int().min(1).max(5).optional(),
+    }, async ({ symbol, intent, budget, depth }) => {
+        const refreshed = refresh();
+        const target = one(symbol);
+        return result({
+            refresh: refreshed,
+            ...buildPreview(index, target.id, { budget, depth, intent }),
+            intent,
+        });
+    });
+    server.tool("context.diff", "Show a Git diff with a strict token budget.", {
+        base: z.string().optional(),
+        head: z.string().optional(),
+        budget: z.number().int().positive().optional(),
+    }, async ({ base, head, budget }) => {
+        const refreshed = refresh();
+        const args = gitDiffArgs(base, head);
+        let diff = "";
+        try {
+            diff = execFileSync("git", ["diff", ...args], {
+                cwd: root,
+                encoding: "utf8",
+                maxBuffer: 2_000_000,
+            });
+        }
+        catch (error) {
+            throw new Error(`Git unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const max = budget ?? estimateTokens(diff);
+        const truncated = estimateTokens(diff) > max;
+        if (truncated)
+            diff = diff.slice(0, Math.max(1, max * 4));
+        return result({
+            refresh: refreshed,
+            base: base ?? "HEAD",
+            head: head ?? "working tree",
+            budget: max,
+            truncated,
+            changedFiles: [
+                ...diff.matchAll(/^diff --git a\/(.*?) b\/(.*?)$/gm),
+            ].map((match) => match[2]),
+            estimatedTokens: estimateTokens(diff),
+            diff,
+        });
+    });
+    await server.connect(new StdioServerTransport());
+    return server;
+}
+if (process.argv[1] &&
+    resolve(process.argv[1]) === fileURLToPath(import.meta.url))
+    await startMcpServer();

package/dist/src/storage/sqlite.js

@@ -0,0 +1,105 @@
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { WorkflowError } from "../workflow/errors.js";
+// Bump whenever any language adapter's parse OR resolve output changes: unchanged files and their cached (resolved)
+// call edges are otherwise reused from cache. Rust parse and resolve output is guarded by tests/rust-parse-snapshot.test.ts,
+// which refuses to regenerate its snapshot for changed output without a bump here.
+export const INDEX_VERSION = "1.12.0";
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS files (path TEXT PRIMARY KEY, content_hash TEXT NOT NULL, language TEXT NOT NULL, parse_error INTEGER NOT NULL, indexing_version TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS symbols (id TEXT PRIMARY KEY, file_path TEXT NOT NULL, language TEXT NOT NULL, payload TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS calls (id INTEGER PRIMARY KEY AUTOINCREMENT, caller_id TEXT NOT NULL, callee_name TEXT NOT NULL, file_path TEXT NOT NULL, language TEXT NOT NULL, payload TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS imports (id INTEGER PRIMARY KEY AUTOINCREMENT, file_path TEXT NOT NULL, language TEXT NOT NULL, payload TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS exports (id INTEGER PRIMARY KEY AUTOINCREMENT, file_path TEXT NOT NULL, language TEXT NOT NULL, payload TEXT NOT NULL);
+`;
+export class IndexStorage {
+    db;
+    constructor(root) {
+        const directory = join(root, ".context-slice");
+        mkdirSync(directory, { recursive: true });
+        // Self-ignoring cache: keeps `git status` clean without editing the repository's own .gitignore.
+        if (!existsSync(join(directory, ".gitignore")))
+            writeFileSync(join(directory, ".gitignore"), "*\n");
+        this.db = new Database(join(directory, "index.sqlite"));
+        try {
+            this.db.pragma("schema_version");
+        }
+        catch (error) {
+            this.db.close();
+            throw new WorkflowError("INDEX_CORRUPT", `Unreadable index cache: ${join(directory, "index.sqlite")} (${error instanceof Error ? error.message : String(error)})`, "Delete the cache and rebuild it: rm -rf .context-slice && context-slice init");
+        }
+        this.db.exec("CREATE TABLE IF NOT EXISTS metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL);");
+        const version = this.db
+            .prepare("SELECT value FROM metadata WHERE key = 'schema_version'")
+            .get();
+        // A cache written by any other schema is dropped and rebuilt, never reused.
+        if (version?.value !== INDEX_VERSION)
+            this.db.exec("DROP TABLE IF EXISTS files; DROP TABLE IF EXISTS symbols; DROP TABLE IF EXISTS calls; DROP TABLE IF EXISTS imports; DROP TABLE IF EXISTS exports;");
+        this.db.exec(SCHEMA);
+        if (version?.value !== INDEX_VERSION)
+            this.db
+                .prepare("INSERT OR REPLACE INTO metadata(key, value) VALUES ('schema_version', ?)")
+                .run(INDEX_VERSION);
+    }
+    load() {
+        const files = new Map();
+        for (const row of this.db
+            .prepare("SELECT path, content_hash, language FROM files")
+            .all())
+            files.set(row.path, { hash: row.content_hash, language: row.language });
+        const rows = (table) => this.db.prepare(`SELECT payload FROM ${table}`).all().map((row) => {
+            try {
+                return JSON.parse(row.payload);
+            }
+            catch (error) {
+                throw new WorkflowError("INDEX_CORRUPT", `Unreadable index cache payload in ${table}: ${error instanceof Error ? error.message : String(error)}`, "Delete the cache and rebuild it: rm -rf .context-slice && context-slice init");
+            }
+        });
+        return {
+            files,
+            symbols: rows("symbols"),
+            calls: rows("calls"),
+            imports: rows("imports"),
+            exports: rows("exports"),
+        };
+    }
+    metadata() {
+        const rows = this.db
+            .prepare("SELECT key, value FROM metadata")
+            .all();
+        return Object.fromEntries(rows.map((row) => [row.key, row.value]));
+    }
+    save(files, symbols, calls, imports = [], exports = []) {
+        const transaction = this.db.transaction(() => {
+            this.db.prepare("DELETE FROM files").run();
+            this.db.prepare("DELETE FROM symbols").run();
+            this.db.prepare("DELETE FROM calls").run();
+            this.db.prepare("DELETE FROM imports").run();
+            this.db.prepare("DELETE FROM exports").run();
+            const fileStatement = this.db.prepare("INSERT OR REPLACE INTO files(path, content_hash, language, parse_error, indexing_version) VALUES (?, ?, ?, 0, ?)");
+            for (const [path, record] of files)
+                fileStatement.run(path, record.hash, record.language, INDEX_VERSION);
+            const symbolStatement = this.db.prepare("INSERT INTO symbols(id, file_path, language, payload) VALUES (?, ?, ?, ?)");
+            for (const symbol of symbols)
+                symbolStatement.run(symbol.id, symbol.filePath, symbol.language, JSON.stringify(symbol));
+            const callStatement = this.db.prepare("INSERT INTO calls(caller_id, callee_name, file_path, language, payload) VALUES (?, ?, ?, ?, ?)");
+            for (const call of calls)
+                callStatement.run(call.callerId, call.calleeName, call.filePath, call.language ?? "java", JSON.stringify(call));
+            const importStatement = this.db.prepare("INSERT INTO imports(file_path, language, payload) VALUES (?, ?, ?)");
+            for (const record of imports)
+                importStatement.run(record.filePath, record.language, JSON.stringify(record));
+            const exportStatement = this.db.prepare("INSERT INTO exports(file_path, language, payload) VALUES (?, ?, ?)");
+            for (const record of exports)
+                exportStatement.run(record.filePath, record.language, JSON.stringify(record));
+            this.db
+                .prepare("INSERT OR REPLACE INTO metadata(key, value) VALUES ('last_refreshed_at', ?)")
+                .run(new Date().toISOString());
+        });
+        transaction();
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/src/types/enterprise.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/model.js

@@ -0,0 +1 @@
+export {};

package/dist/src/workflow/errors.js

@@ -0,0 +1,10 @@
+export class WorkflowError extends Error {
+    code;
+    remediation;
+    constructor(code, message, remediation) {
+        super(message);
+        this.code = code;
+        this.remediation = remediation;
+        this.name = "WorkflowError";
+    }
+}