context-slice 1.8.2

package/dist/src/indexer/index.js

@@ -0,0 +1,325 @@
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync } from "node:fs";
+import { extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { rankSymbol } from "../planner/rank.js";
+import { INDEX_VERSION, IndexStorage, } from "../storage/sqlite.js";
+import { adapterFor, ignoredDirectories, languages, } from "../languages/adapter.js";
+import { extractEnterpriseRelations, resolveEnterpriseRelations, } from "../languages/java/enterprise/registry.js";
+import "../languages/java.js";
+import "../languages/typescript/index.js";
+import "../languages/javascript/index.js";
+import "../languages/python/index.js";
+import "../languages/rust/index.js";
+import "../languages/go/index.js";
+import "../languages/java/enterprise/spring-mvc.js";
+import "../languages/java/enterprise/dependency-injection.js";
+import "../languages/java/enterprise/transactions.js";
+import "../languages/java/enterprise/jpa-entity.js";
+import "../languages/java/enterprise/spring-data.js";
+const coreIgnored = new Set([
+    ".git",
+    "node_modules",
+    "build",
+    "dist",
+    "out",
+    ".idea",
+    ".vscode",
+    ".context-slice",
+]);
+const ignored = new Set([...coreIgnored, ...ignoredDirectories()]);
+/** Display suffix: `.d.ts` and `.tsx` are counted separately from `.ts`. */
+function fileSuffix(filePath) {
+    const lower = filePath.toLowerCase();
+    return lower.endsWith(".d.ts") ? ".d.ts" : extname(lower);
+}
+export class ProjectIndex {
+    root;
+    symbols = [];
+    calls = [];
+    imports = [];
+    exports = [];
+    enterpriseRelations = [];
+    hashes = new Map();
+    storage;
+    constructor(root) {
+        this.root = resolve(root);
+        this.storage = new IndexStorage(this.root);
+    }
+    files(dir) {
+        return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+            if (ignored.has(entry.name))
+                return [];
+            const path = join(dir, entry.name);
+            return entry.isDirectory()
+                ? this.files(path)
+                : entry.isFile() && adapterFor(entry.name)
+                    ? [path]
+                    : [];
+        });
+    }
+    counts(files) {
+        const byExtension = {};
+        const byLanguage = {};
+        for (const file of files) {
+            const suffix = fileSuffix(file);
+            byExtension[suffix] = (byExtension[suffix] ?? 0) + 1;
+            const language = adapterFor(file)?.label ?? "unknown";
+            byLanguage[language] = (byLanguage[language] ?? 0) + 1;
+        }
+        return { byExtension, byLanguage };
+    }
+    inspect() {
+        const files = this.files(this.root);
+        const previous = this.storage.load();
+        const hashes = new Map();
+        for (const file of files) {
+            const filePath = relative(this.root, file);
+            hashes.set(filePath, createHash("sha256").update(readFileSync(file, "utf8")).digest("hex"));
+        }
+        const hasIndex = previous.files.size > 0;
+        const stale = hasIndex &&
+            (hashes.size !== previous.files.size ||
+                [...hashes].some(([path, hash]) => previous.files.get(path)?.hash !== hash));
+        const metadata = this.storage.metadata();
+        const counts = this.counts(files);
+        return {
+            state: hasIndex
+                ? stale
+                    ? "STALE"
+                    : "CURRENT"
+                : "UNINITIALIZED",
+            sourceFiles: files.length,
+            filesByExtension: counts.byExtension,
+            filesByLanguage: counts.byLanguage,
+            languages: Object.keys(counts.byLanguage),
+            indexedFiles: previous.files.size,
+            schemaVersion: metadata.schema_version ?? INDEX_VERSION,
+            lastRefreshedAt: metadata.last_refreshed_at,
+        };
+    }
+    refresh() {
+        const summary = this.rebuild();
+        return { summary, freshness: this.inspect() };
+    }
+    rebuild() {
+        const started = Date.now();
+        const files = this.files(this.root);
+        const previous = this.storage.load();
+        this.symbols = [];
+        this.calls = [];
+        this.imports = [];
+        this.exports = [];
+        this.enterpriseRelations = [];
+        this.hashes = new Map();
+        let filesParsed = 0;
+        let cacheHits = 0;
+        let parseErrors = 0;
+        for (const file of files) {
+            const filePath = relative(this.root, file);
+            const adapter = adapterFor(filePath);
+            if (!adapter)
+                continue;
+            const source = readFileSync(file, "utf8");
+            const hash = createHash("sha256").update(source).digest("hex");
+            this.hashes.set(filePath, { hash, language: adapter.id });
+            let fileSymbols;
+            if (previous.files.get(filePath)?.hash === hash) {
+                fileSymbols = previous.symbols.filter((symbol) => symbol.filePath === filePath);
+                this.symbols.push(...fileSymbols);
+                this.calls.push(...previous.calls.filter((call) => call.filePath === filePath));
+                this.imports.push(...previous.imports.filter((record) => record.filePath === filePath));
+                this.exports.push(...previous.exports.filter((record) => record.filePath === filePath));
+                cacheHits++;
+            }
+            else {
+                const parsed = adapter.parse(filePath, source);
+                fileSymbols = parsed.symbols;
+                this.symbols.push(...parsed.symbols);
+                this.calls.push(...parsed.calls);
+                this.imports.push(...parsed.imports);
+                this.exports.push(...parsed.exports);
+                if (parsed.parseError)
+                    parseErrors++;
+                filesParsed++;
+            }
+            if (adapter.id === "java") {
+                this.enterpriseRelations.push(...extractEnterpriseRelations(fileSymbols, filePath, source));
+            }
+        }
+        this.enterpriseRelations = resolveEnterpriseRelations(this.enterpriseRelations, this.symbols.filter((symbol) => symbol.language === "java"));
+        // Each language resolves only its own edges; cross-language calls stay unresolved.
+        for (const adapter of languages()) {
+            const context = {
+                root: this.root,
+                symbols: this.symbols.filter((symbol) => symbol.language === adapter.id),
+                calls: this.calls.filter((call) => (call.language ?? "java") === adapter.id && !call.resolvedTargetId),
+                imports: this.imports.filter((record) => record.language === adapter.id),
+                exports: this.exports.filter((record) => record.language === adapter.id),
+                sourceOf: (symbol) => this.sourceFor(symbol),
+            };
+            if (context.symbols.length)
+                adapter.resolveCalls(context);
+        }
+        this.storage.save(this.hashes, this.symbols, this.calls, this.imports, this.exports);
+        const counts = this.counts(files);
+        return {
+            files: files.length,
+            filesScanned: files.length,
+            filesParsed,
+            parseErrors,
+            cacheHits,
+            filesByExtension: counts.byExtension,
+            filesByLanguage: counts.byLanguage,
+            symbols: this.symbols.length,
+            symbolsUpdated: this.symbols.length,
+            calls: this.calls.length,
+            imports: this.imports.length,
+            exports: this.exports.length,
+            elapsedMs: Date.now() - started,
+        };
+    }
+    search(query, limit = 10) {
+        return this.symbols
+            .map((symbol) => ({
+            id: symbol.id,
+            kind: symbol.kind,
+            language: symbol.language,
+            name: symbol.name,
+            qualifiedName: symbol.qualifiedName,
+            signature: symbol.signature,
+            filePath: symbol.filePath,
+            score: rankSymbol(symbol, query),
+        }))
+            .filter((item) => item.score > 0)
+            .sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
+            .slice(0, limit);
+    }
+    resolveSymbol(input) {
+        // An overload signature is API surface; the implementation is the target.
+        const preferImplementation = (matches) => {
+            const implementations = matches.filter((symbol) => !symbol.metadata?.overloadSignature);
+            return implementations.length ? implementations : matches;
+        };
+        const exact = this.symbols.filter((s) => s.id === input ||
+            s.canonicalIdentity === input ||
+            s.qualifiedName === input ||
+            s.signature === input);
+        if (exact.length)
+            return preferImplementation(exact);
+        const qualifiedSuffix = this.symbols.filter((s) => s.qualifiedName?.endsWith(`.${input}`));
+        return preferImplementation(qualifiedSuffix.length
+            ? qualifiedSuffix
+            : this.symbols.filter((s) => s.name === input));
+    }
+    callers(target) {
+        // A cfg-gated call (spec §40) carries every alternative in runtimeTargetIds, not just the
+        // resolvedTargetId it settled on — a non-first alternative must still be reachable as a
+        // caller/dependency edge, or context composition can never include it (see docs/rust-support.md).
+        return this.calls
+            .filter((call) => (call.runtimeTargetIds ?? [call.resolvedTargetId]).includes(target.id))
+            .map((call) => this.symbols.find((s) => s.id === call.callerId))
+            .filter((s) => Boolean(s));
+    }
+    callersAtDepth(target, depth) {
+        let frontier = [target];
+        const found = new Map();
+        for (let level = 0; level < depth; level++) {
+            const next = frontier
+                .flatMap((symbol) => this.callers(symbol))
+                .filter((symbol) => !found.has(symbol.id));
+            for (const symbol of next)
+                found.set(symbol.id, symbol);
+            frontier = next;
+        }
+        return [...found.values()];
+    }
+    dependencies(target) {
+        return this.calls
+            .filter((call) => call.callerId === target.id)
+            .flatMap((call) => call.runtimeTargetIds ?? (call.resolvedTargetId ? [call.resolvedTargetId] : []))
+            .map((id) => this.symbols.find((s) => s.id === id))
+            .filter((s) => Boolean(s));
+    }
+    dependenciesAtDepth(target, depth) {
+        let frontier = [target];
+        const found = new Map();
+        for (let level = 0; level < depth; level++) {
+            const next = frontier
+                .flatMap((symbol) => this.dependencies(symbol))
+                .filter((symbol) => !found.has(symbol.id));
+            for (const symbol of next)
+                found.set(symbol.id, symbol);
+            frontier = next;
+        }
+        return [...found.values()];
+    }
+    ambiguousCalls() {
+        return this.calls.filter((call) => !call.resolvedTargetId &&
+            this.symbols.filter((symbol) => symbol.kind === "method" && symbol.name === call.calleeName).length > 1);
+    }
+    diagnostics() {
+        const simpleNames = new Map();
+        for (const symbol of this.symbols)
+            simpleNames.set(symbol.name, (simpleNames.get(symbol.name) ?? 0) + 1);
+        const ids = new Set();
+        let collisions = 0;
+        for (const symbol of this.symbols) {
+            if (ids.has(symbol.id))
+                collisions++;
+            ids.add(symbol.id);
+        }
+        const resolutionKindCounts = Object.fromEntries([...new Set(this.calls.map((call) => call.resolutionKind))].map((kind) => [
+            kind,
+            this.calls.filter((call) => call.resolutionKind === kind).length,
+        ]));
+        const byLanguage = Object.fromEntries(languages().map((adapter) => [
+            adapter.id,
+            {
+                symbols: this.symbols.filter((symbol) => symbol.language === adapter.id).length,
+                calls: this.calls.filter((call) => (call.language ?? "java") === adapter.id).length,
+                imports: this.imports.filter((record) => record.language === adapter.id).length,
+                exports: this.exports.filter((record) => record.language === adapter.id).length,
+            },
+        ]));
+        const kindCount = (kind) => this.symbols.filter((symbol) => symbol.kind === kind).length;
+        return {
+            filesIndexed: new Set(this.symbols.map((symbol) => symbol.filePath)).size,
+            symbolsIndexed: this.symbols.length,
+            methodsIndexed: kindCount("method"),
+            constructorsIndexed: kindCount("constructor"),
+            classesIndexed: kindCount("class"),
+            interfacesIndexed: kindCount("interface"),
+            recordsIndexed: kindCount("record"),
+            enumsIndexed: kindCount("enum"),
+            functionsIndexed: kindCount("function"),
+            typesIndexed: kindCount("type"),
+            componentsIndexed: this.symbols.filter((symbol) => symbol.metadata?.reactComponent).length,
+            duplicateSimpleNames: [...simpleNames.values()].filter((count) => count > 1).length,
+            ambiguousLookups: 0,
+            symbolIdCollisions: collisions,
+            callEdgesTotal: this.calls.length,
+            callEdgesExact: this.calls.filter((call) => call.confidence === "exact")
+                .length,
+            callEdgesProbable: this.calls.filter((call) => call.confidence === "probable").length,
+            callEdgesUnresolved: this.calls.filter((call) => call.confidence === "unresolved").length,
+            externalCallEdges: this.calls.filter((call) => call.externalPackage)
+                .length,
+            importsTotal: this.imports.length,
+            importsResolved: this.imports.filter((record) => record.resolvedFile)
+                .length,
+            externalImports: this.imports.filter((record) => record.externalPackage)
+                .length,
+            reexportsTotal: this.exports.filter((record) => record.fromModule).length,
+            reexportsResolved: this.exports.filter((record) => record.fromModule && record.resolvedFile).length,
+            byLanguage,
+            resolutionKindCounts,
+        };
+    }
+    sourceFor(symbol) {
+        const full = resolve(this.root, symbol.filePath);
+        const fromRoot = relative(this.root, full);
+        if (fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || isAbsolute(fromRoot))
+            throw new Error("Path nằm ngoài repository root");
+        return readFileSync(full, "utf8");
+    }
+}

package/dist/src/languages/adapter.js

@@ -0,0 +1,23 @@
+const registry = [];
+export function registerLanguage(adapter) {
+    registry.push(adapter);
+    return adapter;
+}
+export function languages() {
+    return registry;
+}
+export function adapterFor(filePath) {
+    const lower = filePath.toLowerCase();
+    let best;
+    for (const adapter of registry)
+        for (const extension of adapter.extensions)
+            if (lower.endsWith(extension) && (best?.length ?? 0) < extension.length)
+                best = { adapter, length: extension.length };
+    return best?.adapter;
+}
+export function supportedExtensions() {
+    return registry.flatMap((adapter) => adapter.extensions);
+}
+export function ignoredDirectories() {
+    return new Set(registry.flatMap((adapter) => adapter.ignoredDirectories ?? []));
+}

package/dist/src/languages/go/index.js

@@ -0,0 +1,15 @@
+import { registerLanguage } from "../adapter.js";
+import { LANGUAGE_ID, parseGo } from "./parse.js";
+import { resolveGoCalls } from "./resolve.js";
+export const goAdapter = {
+    id: LANGUAGE_ID,
+    label: "Go",
+    extensions: [".go"],
+    ignoredDirectories: ["vendor"],
+    parse: parseGo,
+    resolveCalls: (context) => {
+        resolveGoCalls(context);
+    },
+};
+registerLanguage(goAdapter);
+export { LANGUAGE_ID as GO_LANGUAGE_ID };