toolnet-memory 0.2.0

package/dist/src/code-intelligence/graph/graph-store.js

@@ -0,0 +1,57 @@
+export class CodeGraphStore {
+    symbols = new Map();
+    edges = new Map();
+    addSymbol(symbol) {
+        this.symbols.set(symbol.id, symbol);
+    }
+    addEdge(edge) {
+        this.edges.set(edge.id, edge);
+    }
+    getSymbol(id) {
+        return this.symbols.get(id);
+    }
+    findByName(projectId, name) {
+        return [
+            ...this.symbols.values(),
+        ].filter((symbol) => symbol.projectId ===
+            projectId &&
+            (symbol.name ===
+                name ||
+                symbol.qualifiedName ===
+                    name));
+    }
+    allSymbols(projectId) {
+        return [
+            ...this.symbols.values(),
+        ].filter((symbol) => symbol.projectId ===
+            projectId);
+    }
+    allEdges(projectId) {
+        return [
+            ...this.edges.values(),
+        ].filter((edge) => edge.projectId ===
+            projectId);
+    }
+    import(symbols, edges) {
+        for (const symbol of symbols) {
+            this.addSymbol(symbol);
+        }
+        for (const edge of edges) {
+            this.addEdge(edge);
+        }
+    }
+    clearProject(projectId) {
+        for (const [id, symbol] of this.symbols) {
+            if (symbol.projectId ===
+                projectId) {
+                this.symbols.delete(id);
+            }
+        }
+        for (const [id, edge] of this.edges) {
+            if (edge.projectId ===
+                projectId) {
+                this.edges.delete(id);
+            }
+        }
+    }
+}

package/dist/src/code-intelligence/graph/index.js

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

package/dist/src/code-intelligence/graph/relationships.js

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

package/dist/src/code-intelligence/graph/trace.js

@@ -0,0 +1,65 @@
+export class CallGraphTracer {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    callees(projectId, symbolId, maxDepth = 3) {
+        return this.walk(projectId, symbolId, "out", maxDepth);
+    }
+    callers(projectId, symbolId, maxDepth = 3) {
+        return this.walk(projectId, symbolId, "in", maxDepth);
+    }
+    walk(projectId, startId, direction, maxDepth) {
+        const result = [];
+        const visited = new Set([
+            startId,
+        ]);
+        const queue = [
+            {
+                id: startId,
+                depth: 0,
+            },
+        ];
+        const edges = this.graph
+            .allEdges(projectId)
+            .filter((edge) => edge.type === "CALLS" ||
+            edge.type === "CALL_REFERENCE");
+        while (queue.length) {
+            const current = queue.shift();
+            if (current.depth >=
+                maxDepth) {
+                continue;
+            }
+            const related = direction ===
+                "out"
+                ? edges.filter((edge) => edge.from ===
+                    current.id)
+                : edges.filter((edge) => edge.to ===
+                    current.id);
+            for (const edge of related) {
+                const nextId = direction ===
+                    "out"
+                    ? edge.to
+                    : edge.from;
+                if (visited.has(nextId)) {
+                    continue;
+                }
+                visited.add(nextId);
+                const symbol = this.graph.getSymbol(nextId);
+                if (!symbol) {
+                    continue;
+                }
+                const depth = current.depth + 1;
+                result.push({
+                    symbol,
+                    depth,
+                });
+                queue.push({
+                    id: nextId,
+                    depth,
+                });
+            }
+        }
+        return result;
+    }
+}

package/dist/src/code-intelligence/impact/blast-radius.js

@@ -0,0 +1,160 @@
+const RELATION_WEIGHT = {
+    CALLS: 4,
+    CALL_REFERENCE: 6,
+    USES_TYPE: 4,
+    TESTS: 2,
+    ROUTE: 4,
+    WRITES: 3,
+    IMPORTS: 3,
+    INHERITS: 5,
+    IMPLEMENTS: 5,
+    DEFINES: 1,
+};
+function riskLevel(score) {
+    if (score >= 30) {
+        return "CRITICAL";
+    }
+    if (score >= 16) {
+        return "HIGH";
+    }
+    if (score >= 6) {
+        return "MEDIUM";
+    }
+    return "LOW";
+}
+function isTestFile(path) {
+    const value = path
+        .toLowerCase()
+        .replaceAll("\\", "/");
+    return (value.startsWith("tests/") ||
+        value.includes("/tests/") ||
+        value.includes("__tests__") ||
+        /\.(test|spec)\.[^.]+$/
+            .test(value));
+}
+export class BlastRadiusAnalyzer {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    analyze(projectId, changedSymbols, maxDepth = 4) {
+        const edges = this.graph
+            .allEdges(projectId);
+        const impacted = new Map();
+        let score = 0;
+        for (const changed of changedSymbols) {
+            if (changed.fileStatus ===
+                "deleted") {
+                score += 8;
+            }
+            else if (changed.fileStatus ===
+                "renamed") {
+                score += 5;
+            }
+            else {
+                score += 2;
+            }
+            if (changed.symbol.type ===
+                "interface") {
+                score += 5;
+            }
+            if (changed.symbol.type ===
+                "class") {
+                score += 3;
+            }
+            const visited = new Set([
+                changed.symbol.id,
+            ]);
+            const queue = [
+                {
+                    id: changed.symbol.id,
+                    depth: 0,
+                },
+            ];
+            while (queue.length) {
+                const current = queue.shift();
+                if (current.depth >=
+                    maxDepth) {
+                    continue;
+                }
+                /*
+                 * Blast radius đi NGƯỢC dependency:
+                 *
+                 * B thay đổi
+                 * A CALLS B
+                 * => A có nguy cơ ảnh hưởng.
+                 */
+                const incoming = edges.filter((edge) => edge.to ===
+                    current.id &&
+                    [
+                        "CALLS",
+                        "CALL_REFERENCE",
+                        "USES_TYPE",
+                        "TESTS",
+                        "ROUTE",
+                        "WRITES",
+                        "IMPORTS",
+                        "INHERITS",
+                        "IMPLEMENTS",
+                        "DEFINES",
+                    ].includes(edge.type));
+                for (const edge of incoming) {
+                    if (visited.has(edge.from)) {
+                        continue;
+                    }
+                    visited.add(edge.from);
+                    const symbol = this.graph.getSymbol(edge.from);
+                    if (!symbol) {
+                        continue;
+                    }
+                    const depth = current.depth + 1;
+                    const key = `${changed.symbol.id}:${symbol.id}`;
+                    impacted.set(key, {
+                        symbol,
+                        relation: edge.type,
+                        depth,
+                        sourceSymbolId: changed.symbol.id,
+                    });
+                    const relationWeight = RELATION_WEIGHT[edge.type] ?? 1;
+                    score +=
+                        Math.max(1, relationWeight -
+                            (depth - 1));
+                    queue.push({
+                        id: symbol.id,
+                        depth,
+                    });
+                }
+            }
+        }
+        const impactedList = [...impacted.values()]
+            .sort((a, b) => a.depth -
+            b.depth);
+        const impactedFiles = [
+            ...new Set(impactedList.map((item) => item.symbol
+                .filePath)),
+        ];
+        /*
+         * Nếu graph đã index tests,
+         * ưu tiên đề nghị đúng test liên quan.
+         */
+        const suggestedTests = impactedFiles.filter(isTestFile);
+        /*
+         * Nếu không tìm thấy test trực tiếp,
+         * trả file production cần verify.
+         */
+        if (suggestedTests.length ===
+            0) {
+            suggestedTests.push(...impactedFiles
+                .filter((file) => !isTestFile(file))
+                .slice(0, 10));
+        }
+        return {
+            risk: riskLevel(score),
+            riskScore: score,
+            changedSymbols,
+            impacted: impactedList,
+            impactedFiles,
+            suggestedTests,
+        };
+    }
+}

package/dist/src/code-intelligence/impact/change-mapper.js

@@ -0,0 +1,69 @@
+function intersects(symbol, file) {
+    /*
+     * Nếu không lấy được line diff:
+     * coi toàn file bị thay đổi.
+     */
+    if (file.ranges.length === 0) {
+        return true;
+    }
+    if (typeof symbol.startLine !==
+        "number" ||
+        typeof symbol.endLine !==
+            "number") {
+        return false;
+    }
+    return file.ranges.some((range) => symbol.startLine <=
+        range.endLine &&
+        symbol.endLine >=
+            range.startLine);
+}
+export class ChangeMapper {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    map(projectId, changes) {
+        const symbols = this.graph.allSymbols(projectId);
+        const output = [];
+        for (const file of changes) {
+            const fileSymbols = symbols.filter((symbol) => symbol.filePath ===
+                file.filePath);
+            const semanticSymbols = fileSymbols.filter((symbol) => symbol.type !==
+                "file");
+            const direct = semanticSymbols.filter((symbol) => intersects(symbol, file));
+            /*
+             * Nếu diff nằm ngoài function/class,
+             * vẫn đưa file node vào blast radius.
+             */
+            if (direct.length === 0) {
+                const fileNode = fileSymbols.find((symbol) => symbol.type ===
+                    "file");
+                if (fileNode) {
+                    output.push({
+                        symbol: fileNode,
+                        fileStatus: file.status,
+                        direct: true,
+                    });
+                }
+                continue;
+            }
+            for (const symbol of direct) {
+                output.push({
+                    symbol,
+                    fileStatus: file.status,
+                    direct: true,
+                });
+            }
+        }
+        return output;
+    }
+    mapFile(projectId, filePath) {
+        return this.map(projectId, [
+            {
+                filePath,
+                status: "modified",
+                ranges: [],
+            },
+        ]);
+    }
+}

package/dist/src/code-intelligence/impact/edit-tool-detector.js

@@ -0,0 +1,92 @@
+const EDIT_TOOL = /(^|[_-])(write|edit|patch|replace|multiedit|create|delete|remove|rename|move)([_-]|$)/i;
+const PATH_KEYS = new Set([
+    "path",
+    "filepath",
+    "file_path",
+    "filename",
+    "file",
+    "target",
+    "targetpath",
+    "target_path",
+    "sourcepath",
+    "source_path",
+]);
+function normalizePath(value) {
+    return value
+        .trim()
+        .replace(/^["']|["']$/g, "")
+        .replace(/^a\//, "")
+        .replace(/^b\//, "")
+        .replaceAll("\\", "/");
+}
+function looksLikeFile(value) {
+    return (value.length > 0 &&
+        value.length < 500 &&
+        !value.includes("\n") &&
+        /(^|\/)[^/]+\.[A-Za-z0-9]+$/
+            .test(value));
+}
+function extractPatchPaths(patch) {
+    const output = [];
+    const patterns = [
+        /^\*\*\* (?:Update|Add|Delete) File:\s*(.+)$/gm,
+        /^\+\+\+\s+b\/(.+)$/gm,
+        /^---\s+a\/(.+)$/gm,
+    ];
+    for (const regex of patterns) {
+        for (const match of patch.matchAll(regex)) {
+            if (match[1]) {
+                output.push(normalizePath(match[1]));
+            }
+        }
+    }
+    return output;
+}
+function walk(value, output, key) {
+    if (typeof value === "string") {
+        const normalizedKey = key?.toLowerCase();
+        if (normalizedKey &&
+            PATH_KEYS.has(normalizedKey) &&
+            looksLikeFile(value)) {
+            output.add(normalizePath(value));
+        }
+        /*
+         * apply_patch thường nhét đường dẫn
+         * bên trong một chuỗi patch lớn.
+         */
+        if (value.includes("*** Update File:") ||
+            value.includes("*** Add File:") ||
+            value.includes("*** Delete File:") ||
+            value.includes("+++ b/")) {
+            for (const path of extractPatchPaths(value)) {
+                output.add(path);
+            }
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            walk(item, output, key);
+        }
+        return;
+    }
+    if (value &&
+        typeof value === "object") {
+        for (const [childKey, child] of Object.entries(value)) {
+            walk(child, output, childKey);
+        }
+    }
+}
+export function isCodeMutationTool(tool) {
+    return EDIT_TOOL.test(tool.toLowerCase());
+}
+export function extractEditedFiles(tool, input) {
+    if (!isCodeMutationTool(tool)) {
+        return [];
+    }
+    const output = new Set();
+    walk(input, output);
+    return [
+        ...output,
+    ];
+}

package/dist/src/code-intelligence/impact/impact-analyzer.js

@@ -0,0 +1,60 @@
+export class ImpactAnalyzer {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    analyze(projectId, symbolId, maxDepth = 4) {
+        const edges = this.graph
+            .allEdges(projectId);
+        const visited = new Set([
+            symbolId,
+        ]);
+        const queue = [
+            {
+                id: symbolId,
+                depth: 0,
+            },
+        ];
+        const result = [];
+        while (queue.length) {
+            const current = queue.shift();
+            if (current.depth >=
+                maxDepth) {
+                continue;
+            }
+            /*
+             * Reverse relationships:
+             * "Ai phụ thuộc vào symbol này?"
+             */
+            const incoming = edges.filter((edge) => edge.to ===
+                current.id &&
+                [
+                    "CALLS",
+                    "IMPORTS",
+                    "INHERITS",
+                    "IMPLEMENTS",
+                ].includes(edge.type));
+            for (const edge of incoming) {
+                if (visited.has(edge.from)) {
+                    continue;
+                }
+                visited.add(edge.from);
+                const symbol = this.graph.getSymbol(edge.from);
+                if (!symbol) {
+                    continue;
+                }
+                const depth = current.depth + 1;
+                result.push({
+                    symbol,
+                    depth,
+                    relation: edge.type,
+                });
+                queue.push({
+                    id: edge.from,
+                    depth,
+                });
+            }
+        }
+        return result;
+    }
+}

package/dist/src/code-intelligence/impact/impact-guard.js

@@ -0,0 +1,33 @@
+import { readGitChanges, } from "../git/git-diff.js";
+import { ChangeMapper, } from "./change-mapper.js";
+import { BlastRadiusAnalyzer, } from "./blast-radius.js";
+export class ImpactGuard {
+    graph;
+    mapper;
+    blast;
+    constructor(graph) {
+        this.graph = graph;
+        this.mapper =
+            new ChangeMapper(graph);
+        this.blast =
+            new BlastRadiusAnalyzer(graph);
+    }
+    async analyzeGitDiff(projectId, rootPath, options = {}) {
+        const changes = await readGitChanges(rootPath);
+        const changedSymbols = this.mapper.map(projectId, changes);
+        const result = this.blast.analyze(projectId, changedSymbols, options.maxDepth ?? 4);
+        return {
+            mode: "git_diff",
+            changes,
+            ...result,
+        };
+    }
+    analyzeFile(projectId, filePath, options = {}) {
+        const changedSymbols = this.mapper.mapFile(projectId, filePath);
+        return {
+            mode: "planned_file",
+            filePath,
+            ...this.blast.analyze(projectId, changedSymbols, options.maxDepth ?? 4),
+        };
+    }
+}

package/dist/src/code-intelligence/impact/index.js

@@ -0,0 +1,5 @@
+export * from "./impact-analyzer.js";
+export * from "./change-mapper.js";
+export * from "./blast-radius.js";
+export * from "./impact-guard.js";
+export * from "./edit-tool-detector.js";

package/dist/src/code-intelligence/incremental/file-hash.js

@@ -0,0 +1,8 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+export async function hashFile(path) {
+    const content = await readFile(path);
+    return createHash("sha256")
+        .update(content)
+        .digest("hex");
+}

package/dist/src/code-intelligence/incremental/incremental-indexer.js

@@ -0,0 +1,106 @@
+import { PersistentCodeGraphStore, } from "../../storage/code-graph-store.js";
+import { PersistentCodeManifestStore, } from "../../storage/code-manifest-store.js";
+import { buildManifest } from "./manifest-builder.js";
+import { diffManifest } from "./manifest.js";
+import { parseTypeScriptFile } from "../parsers/typescript-parser.js";
+import { GraphBuilder } from "../graph/graph-builder.js";
+import { CodeGraphStore } from "../graph/graph-store.js";
+export class IncrementalRepositoryIndexer {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async index(projectId, rootPath) {
+        const manifestStore = new PersistentCodeManifestStore(this.storage);
+        const graphStore = new PersistentCodeGraphStore(this.storage);
+        const previousManifest = await manifestStore.load(projectId);
+        const previousGraph = await graphStore.load(projectId);
+        const currentManifest = await buildManifest(projectId, rootPath);
+        const diff = diffManifest(previousManifest, currentManifest);
+        const changed = [
+            ...diff.added,
+            ...diff.modified,
+        ];
+        // Nothing changed.
+        if (previousManifest &&
+            previousGraph &&
+            changed.length === 0 &&
+            diff.deleted.length === 0) {
+            return {
+                firstRun: false,
+                scanned: Object.keys(currentManifest.files).length,
+                parsed: 0,
+                added: 0,
+                modified: 0,
+                deleted: 0,
+                unchanged: diff.unchanged.length,
+                symbols: previousGraph.symbols.length,
+                edges: previousGraph.edges.length,
+                saved: false,
+            };
+        }
+        /*
+         * Preserve parsed symbol data from unchanged files.
+         * Reparse only ADDED / MODIFIED files.
+         */
+        const preservedSymbols = previousGraph?.symbols.filter((symbol) => diff.unchanged.includes(symbol.filePath)) ?? [];
+        const parsed = [];
+        for (const filePath of changed) {
+            parsed.push(await parseTypeScriptFile(projectId, rootPath, filePath));
+        }
+        /*
+         * Build graph for changed files.
+         */
+        const changedGraph = new GraphBuilder().build(projectId, parsed);
+        /*
+         * Rebuild final graph from preserved + changed symbols.
+         *
+         * CALL relationships can cross file boundaries, so after collecting
+         * current symbols we reconstruct CALL edges from parsed data where
+         * available and preserve valid unchanged edges.
+         */
+        const finalGraph = new CodeGraphStore();
+        for (const symbol of preservedSymbols) {
+            finalGraph.addSymbol(symbol);
+        }
+        for (const symbol of changedGraph.allSymbols(projectId)) {
+            finalGraph.addSymbol(symbol);
+        }
+        const validIds = new Set(finalGraph
+            .allSymbols(projectId)
+            .map((symbol) => symbol.id));
+        for (const edge of previousGraph?.edges ?? []) {
+            if (validIds.has(edge.from) &&
+                validIds.has(edge.to) &&
+                !changed.includes(previousGraph.symbols.find((symbol) => symbol.id === edge.from)?.filePath ?? "") &&
+                !changed.includes(previousGraph.symbols.find((symbol) => symbol.id === edge.to)?.filePath ?? "")) {
+                finalGraph.addEdge(edge);
+            }
+        }
+        for (const edge of changedGraph.allEdges(projectId)) {
+            finalGraph.addEdge(edge);
+        }
+        const snapshot = {
+            version: 1,
+            projectId,
+            updatedAt: new Date().toISOString(),
+            files: Object.keys(currentManifest.files).length,
+            symbols: finalGraph.allSymbols(projectId),
+            edges: finalGraph.allEdges(projectId),
+        };
+        await graphStore.save(snapshot);
+        await manifestStore.save(currentManifest);
+        return {
+            firstRun: previousManifest === null,
+            scanned: Object.keys(currentManifest.files).length,
+            parsed: changed.length,
+            added: diff.added.length,
+            modified: diff.modified.length,
+            deleted: diff.deleted.length,
+            unchanged: diff.unchanged.length,
+            symbols: snapshot.symbols.length,
+            edges: snapshot.edges.length,
+            saved: true,
+        };
+    }
+}

package/dist/src/code-intelligence/incremental/manifest-builder.js

@@ -0,0 +1,19 @@
+import { join } from "node:path";
+import { scanRepository } from "../indexer/repository-scanner.js";
+import { hashFile } from "./file-hash.js";
+export async function buildManifest(projectId, rootPath) {
+    const paths = await scanRepository(rootPath);
+    const files = {};
+    for (const path of paths) {
+        files[path] = {
+            path,
+            hash: await hashFile(join(rootPath, path)),
+        };
+    }
+    return {
+        version: 1,
+        projectId,
+        updatedAt: new Date().toISOString(),
+        files,
+    };
+}