toolnet-memory 0.2.0

package/dist/src/code-intelligence/architecture/layers.js

@@ -0,0 +1,197 @@
+function normalize(value) {
+    return value
+        .replaceAll("\\", "/")
+        .toLowerCase();
+}
+const EDGE_WEIGHT = {
+    CALL_REFERENCE: 6,
+    CALLS: 4,
+    IMPORTS: 4,
+    USES_TYPE: 4,
+    WRITES: 5,
+    INHERITS: 6,
+    IMPLEMENTS: 6,
+    ROUTE: 3,
+    TESTS: 1,
+};
+export class LayerDetector {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    detect(projectId) {
+        const symbols = this.graph.allSymbols(projectId);
+        const edges = this.graph.allEdges(projectId);
+        const symbolById = new Map(symbols.map((symbol) => [
+            symbol.id,
+            symbol,
+        ]));
+        const files = [
+            ...new Set(symbols.map((symbol) => symbol.filePath)),
+        ].sort();
+        const result = new Map();
+        /*
+         * Phase 1:
+         * deterministic path classification.
+         */
+        for (const filePath of files) {
+            result.set(filePath, this.classifyPath(filePath));
+        }
+        /*
+         * Phase 2:
+         * propagate known layers through
+         * dependency graph.
+         *
+         * Multiple passes giúp unknown -> known
+         * lan truyền nhưng vẫn deterministic.
+         */
+        for (let pass = 0; pass < 3; pass++) {
+            let changed = false;
+            for (const filePath of files) {
+                const current = result.get(filePath);
+                if (!current ||
+                    current.layer !==
+                        "unknown") {
+                    continue;
+                }
+                const votes = new Map();
+                for (const edge of edges) {
+                    const from = symbolById.get(edge.from);
+                    const to = symbolById.get(edge.to);
+                    if (!from ||
+                        !to ||
+                        from.filePath ===
+                            to.filePath) {
+                        continue;
+                    }
+                    let neighbor = null;
+                    if (from.filePath ===
+                        filePath) {
+                        neighbor =
+                            to.filePath;
+                    }
+                    else if (to.filePath ===
+                        filePath) {
+                        neighbor =
+                            from.filePath;
+                    }
+                    if (!neighbor) {
+                        continue;
+                    }
+                    const neighborLayer = result.get(neighbor);
+                    if (!neighborLayer ||
+                        neighborLayer.layer ===
+                            "unknown" ||
+                        neighborLayer.layer ===
+                            "tests") {
+                        continue;
+                    }
+                    const weight = EDGE_WEIGHT[edge.type] ?? 1;
+                    votes.set(neighborLayer.layer, (votes.get(neighborLayer.layer) ?? 0) + weight);
+                }
+                const best = [
+                    ...votes.entries(),
+                ]
+                    .sort((a, b) => b[1] -
+                    a[1] ||
+                    a[0].localeCompare(b[0]))[0];
+                if (best &&
+                    best[1] >= 4) {
+                    result.set(filePath, {
+                        filePath,
+                        layer: best[0],
+                        confidence: 0.65,
+                        reasons: [
+                            `graph-neighbor vote=${best[1]}`,
+                        ],
+                    });
+                    changed =
+                        true;
+                }
+            }
+            if (!changed) {
+                break;
+            }
+        }
+        return files.map((filePath) => result.get(filePath));
+    }
+    classifyPath(filePath) {
+        const path = normalize(filePath);
+        if (path.startsWith("tests/") ||
+            path.includes("/tests/") ||
+            path.includes("__tests__") ||
+            /\.(test|spec)\.[^.]+$/
+                .test(path)) {
+            return {
+                filePath,
+                layer: "tests",
+                confidence: 1,
+                reasons: [
+                    "test path",
+                ],
+            };
+        }
+        if (path.startsWith("bin/") ||
+            path.includes("/mcp/") ||
+            path.includes("/cli/") ||
+            path.includes("/api/") ||
+            path.includes("/routes/") ||
+            path.includes("/hooks/")) {
+            return {
+                filePath,
+                layer: "interface",
+                confidence: 0.9,
+                reasons: [
+                    "interface boundary",
+                ],
+            };
+        }
+        if (path.includes("/runtime/") ||
+            path.includes("/processor/") ||
+            path.includes("/retrieval/") ||
+            path.includes("/snapshot/") ||
+            path.includes("/code-intelligence/")) {
+            return {
+                filePath,
+                layer: "application",
+                confidence: 0.85,
+                reasons: [
+                    "application orchestration",
+                ],
+            };
+        }
+        if (path.includes("/core/") ||
+            path.includes("/memory/") ||
+            /(^|\/)types\.[^.]+$/
+                .test(path)) {
+            return {
+                filePath,
+                layer: "domain",
+                confidence: 0.9,
+                reasons: [
+                    "domain/core logic",
+                ],
+            };
+        }
+        if (path.includes("/storage/") ||
+            path.includes("/production/") ||
+            path.includes("/security/") ||
+            path.includes("/config/") ||
+            path.includes("/utils/")) {
+            return {
+                filePath,
+                layer: "infrastructure",
+                confidence: 0.85,
+                reasons: [
+                    "infrastructure boundary",
+                ],
+            };
+        }
+        return {
+            filePath,
+            layer: "unknown",
+            confidence: 0.35,
+            reasons: [],
+        };
+    }
+}

package/dist/src/code-intelligence/architecture/types.js

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

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

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./smart-chunker.js";

package/dist/src/code-intelligence/chunks/smart-chunker.js

@@ -0,0 +1,125 @@
+import { createHash, } from "node:crypto";
+import { readFile, } from "node:fs/promises";
+import { join, } from "node:path";
+import { Sanitizer, } from "../../security/sanitizer.js";
+function hash(value) {
+    return createHash("sha256")
+        .update(value)
+        .digest("hex");
+}
+export class SmartCodeChunker {
+    sanitizer = new Sanitizer();
+    async build(projectId, rootPath, symbols, options = {}) {
+        const maxLines = options.maxLines ?? 80;
+        const overlapLines = options.overlapLines ?? 10;
+        const byFile = new Map();
+        for (const symbol of symbols) {
+            const list = byFile.get(symbol.filePath) ?? [];
+            list.push(symbol);
+            byFile.set(symbol.filePath, list);
+        }
+        const chunks = [];
+        for (const [filePath, fileSymbols] of byFile) {
+            let text;
+            try {
+                text =
+                    await readFile(join(rootPath, filePath), "utf8");
+            }
+            catch {
+                continue;
+            }
+            const lines = text.split(/\r?\n/);
+            const semanticSymbols = fileSymbols.filter((symbol) => symbol.type !==
+                "file" &&
+                typeof symbol.startLine ===
+                    "number" &&
+                typeof symbol.endLine ===
+                    "number");
+            /*
+             * Có symbol -> chunk theo symbol.
+             * Không có symbol -> fallback chia file theo cửa sổ.
+             */
+            if (semanticSymbols.length >
+                0) {
+                for (const symbol of semanticSymbols) {
+                    chunks.push(...this.chunkRange({
+                        projectId,
+                        filePath,
+                        lines,
+                        symbol,
+                        startLine: symbol.startLine,
+                        endLine: symbol.endLine,
+                        maxLines,
+                        overlapLines,
+                    }));
+                }
+            }
+            else {
+                chunks.push(...this.chunkRange({
+                    projectId,
+                    filePath,
+                    lines,
+                    startLine: 1,
+                    endLine: Math.max(1, lines.length),
+                    maxLines,
+                    overlapLines,
+                }));
+            }
+        }
+        return chunks;
+    }
+    chunkRange(input) {
+        const { projectId, filePath, lines, symbol, maxLines, } = input;
+        const overlapLines = Math.min(input.overlapLines, Math.max(0, maxLines - 1));
+        const start = Math.max(1, input.startLine);
+        const end = Math.min(lines.length, Math.max(start, input.endLine));
+        const output = [];
+        let cursor = start;
+        let part = 0;
+        while (cursor <= end) {
+            const chunkEnd = Math.min(end, cursor +
+                maxLines -
+                1);
+            const raw = lines
+                .slice(cursor - 1, chunkEnd)
+                .join("\n")
+                .trim();
+            if (raw) {
+                const content = this.sanitizer
+                    .sanitize(raw)
+                    .text;
+                const contentHash = hash(content);
+                const identity = [
+                    projectId,
+                    filePath,
+                    symbol?.id ?? "file",
+                    String(part),
+                    contentHash,
+                ].join(":");
+                output.push({
+                    id: hash(identity)
+                        .slice(0, 32),
+                    projectId,
+                    filePath,
+                    symbolId: symbol?.id,
+                    symbolName: symbol?.qualifiedName ??
+                        symbol?.name,
+                    symbolType: symbol?.type,
+                    startLine: cursor,
+                    endLine: chunkEnd,
+                    content,
+                    contentHash,
+                });
+            }
+            if (chunkEnd >= end) {
+                break;
+            }
+            cursor =
+                chunkEnd -
+                    overlapLines +
+                    1;
+            part++;
+        }
+        return output;
+    }
+}

package/dist/src/code-intelligence/chunks/types.js

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

package/dist/src/code-intelligence/git/git-diff.js

@@ -0,0 +1,109 @@
+import { execFile, } from "node:child_process";
+import { promisify, } from "node:util";
+const execFileAsync = promisify(execFile);
+function parseRanges(patch) {
+    const ranges = [];
+    const regex = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/gm;
+    for (const match of patch.matchAll(regex)) {
+        const start = Number(match[1]);
+        const count = Number(match[2] ?? 1);
+        ranges.push({
+            startLine: start,
+            endLine: Math.max(start, start + count - 1),
+        });
+    }
+    return ranges;
+}
+function mapStatus(value) {
+    if (value.startsWith("A")) {
+        return "added";
+    }
+    if (value.startsWith("D")) {
+        return "deleted";
+    }
+    if (value.startsWith("R")) {
+        return "renamed";
+    }
+    return "modified";
+}
+export async function readGitChanges(rootPath) {
+    let names = "";
+    try {
+        const result = await execFileAsync("git", [
+            "diff",
+            "HEAD",
+            "--name-status",
+            "--no-renames",
+        ], {
+            cwd: rootPath,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        names =
+            result.stdout;
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const line of names
+        .split(/\r?\n/)
+        .filter(Boolean)) {
+        const [rawStatus, ...parts] = line.split("\t");
+        const filePath = parts.at(-1);
+        if (!filePath) {
+            continue;
+        }
+        let patch = "";
+        try {
+            const result = await execFileAsync("git", [
+                "diff",
+                "HEAD",
+                "--unified=0",
+                "--",
+                filePath,
+            ], {
+                cwd: rootPath,
+                maxBuffer: 20 * 1024 * 1024,
+            });
+            patch =
+                result.stdout;
+        }
+        catch {
+            patch = "";
+        }
+        files.push({
+            filePath,
+            status: mapStatus(rawStatus),
+            ranges: parseRanges(patch),
+        });
+    }
+    /*
+     * Git diff HEAD không bao gồm untracked.
+     */
+    try {
+        const result = await execFileAsync("git", [
+            "ls-files",
+            "--others",
+            "--exclude-standard",
+        ], {
+            cwd: rootPath,
+        });
+        for (const filePath of result.stdout
+            .split(/\r?\n/)
+            .filter(Boolean)) {
+            if (files.some((item) => item.filePath ===
+                filePath)) {
+                continue;
+            }
+            files.push({
+                filePath,
+                status: "added",
+                ranges: [],
+            });
+        }
+    }
+    catch {
+        // Not fatal.
+    }
+    return files;
+}

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

@@ -0,0 +1 @@
+export * from "./git-diff.js";

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

@@ -0,0 +1,26 @@
+export function getArchitecture(graph, projectId) {
+    const symbols = graph.allSymbols(projectId);
+    const edges = graph.allEdges(projectId);
+    const symbol = (type) => symbols.filter((item) => item.type === type).length;
+    const edge = (type) => edges.filter((item) => item.type === type).length;
+    return {
+        files: symbol("file"),
+        classes: symbol("class"),
+        interfaces: symbol("interface"),
+        functions: symbol("function"),
+        methods: symbol("method"),
+        properties: symbol("property"),
+        routes: symbol("route"),
+        symbols: symbols.length,
+        edges: edges.length,
+        calls: edge("CALLS"),
+        callReferences: edge("CALL_REFERENCE"),
+        imports: edge("IMPORTS"),
+        inherits: edge("INHERITS"),
+        implements: edge("IMPLEMENTS"),
+        usesType: edge("USES_TYPE"),
+        tests: edge("TESTS"),
+        routeEdges: edge("ROUTE"),
+        writes: edge("WRITES"),
+    };
+}

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

@@ -0,0 +1,213 @@
+import { createHash, } from "node:crypto";
+import { dirname, extname, normalize, posix, } from "node:path";
+import { CodeGraphStore, } from "./graph-store.js";
+function edgeId(projectId, from, type, to) {
+    return createHash("sha256")
+        .update(`${projectId}:${from}:${type}:${to}`)
+        .digest("hex")
+        .slice(0, 24);
+}
+function cleanPath(value) {
+    return normalize(value).replaceAll("\\", "/");
+}
+function resolveImportFile(fromFile, source, availableFiles) {
+    if (!source.startsWith(".")) {
+        return undefined;
+    }
+    const base = cleanPath(posix.join(dirname(fromFile), source));
+    const extension = extname(base);
+    let candidates;
+    if (extension === ".js") {
+        const stem = base.slice(0, -3);
+        candidates = [
+            `${stem}.ts`,
+            `${stem}.tsx`,
+            `${stem}.js`,
+            `${stem}.jsx`,
+        ];
+    }
+    else if (extension === ".mjs") {
+        const stem = base.slice(0, -4);
+        candidates = [
+            `${stem}.mts`,
+            `${stem}.ts`,
+            `${stem}.mjs`,
+        ];
+    }
+    else if (extension === ".cjs") {
+        const stem = base.slice(0, -4);
+        candidates = [
+            `${stem}.cts`,
+            `${stem}.ts`,
+            `${stem}.cjs`,
+        ];
+    }
+    else if (extension) {
+        candidates = [base];
+    }
+    else {
+        candidates = [
+            `${base}.ts`,
+            `${base}.tsx`,
+            `${base}.mts`,
+            `${base}.cts`,
+            `${base}.js`,
+            `${base}.jsx`,
+            `${base}.mjs`,
+            `${base}.cjs`,
+            `${base}/index.ts`,
+            `${base}/index.tsx`,
+            `${base}/index.js`,
+            `${base}/index.jsx`,
+        ];
+    }
+    return candidates.find((candidate) => availableFiles.has(cleanPath(candidate)));
+}
+export class GraphBuilder {
+    build(projectId, parsed) {
+        const graph = new CodeGraphStore();
+        const files = new Map();
+        for (const file of parsed) {
+            for (const symbol of file.symbols) {
+                graph.addSymbol(symbol);
+                if (symbol.type ===
+                    "file") {
+                    files.set(cleanPath(file.filePath), symbol);
+                }
+            }
+        }
+        const availableFiles = new Set(files.keys());
+        for (const file of parsed) {
+            const filePath = cleanPath(file.filePath);
+            const fileNode = files.get(filePath);
+            if (!fileNode) {
+                continue;
+            }
+            // DEFINES
+            for (const symbol of file.symbols) {
+                if (symbol.id ===
+                    fileNode.id) {
+                    continue;
+                }
+                graph.addEdge(this.edge(projectId, fileNode.id, "DEFINES", symbol.id));
+            }
+            // IMPORTS
+            for (const item of file.imports) {
+                const targetPath = resolveImportFile(filePath, item.source, availableFiles);
+                if (!targetPath) {
+                    continue;
+                }
+                const targetFile = files.get(targetPath);
+                if (!targetFile) {
+                    continue;
+                }
+                graph.addEdge(this.edge(projectId, fileNode.id, "IMPORTS", targetFile.id, {
+                    source: item.source,
+                }));
+            }
+            // INHERITS / IMPLEMENTS
+            for (const relation of file.heritage) {
+                const targets = graph.findByName(projectId, relation.targetName)
+                    .filter((symbol) => symbol.type ===
+                    "class" ||
+                    symbol.type ===
+                        "interface");
+                for (const target of targets) {
+                    graph.addEdge(this.edge(projectId, relation.fromId, relation.type, target.id));
+                }
+            }
+            // CALLS
+            for (const call of file.calls) {
+                if (!call.callerId) {
+                    continue;
+                }
+                const targets = this.resolveCallTargets(projectId, file, call.calleeName, call.qualifier, parsed, graph, availableFiles);
+                for (const target of targets) {
+                    if (target.id ===
+                        call.callerId) {
+                        continue;
+                    }
+                    graph.addEdge(this.edge(projectId, call.callerId, "CALLS", target.id, {
+                        line: call.line,
+                        qualifier: call.qualifier,
+                    }));
+                }
+            }
+        }
+        return graph;
+    }
+    resolveCallTargets(projectId, file, calleeName, qualifier, parsed, graph, availableFiles) {
+        const filePath = cleanPath(file.filePath);
+        // Same-file symbol first.
+        const sameFile = graph
+            .findByName(projectId, calleeName)
+            .filter((symbol) => cleanPath(symbol.filePath) ===
+            filePath);
+        if (!qualifier &&
+            sameFile.length) {
+            return sameFile;
+        }
+        // Namespace import: api.login()
+        if (qualifier) {
+            for (const imported of file.imports) {
+                const namespace = imported.bindings
+                    .find((binding) => binding.kind ===
+                    "namespace" &&
+                    binding.localName ===
+                        qualifier);
+                if (!namespace) {
+                    continue;
+                }
+                const targetPath = resolveImportFile(filePath, imported.source, availableFiles);
+                if (!targetPath) {
+                    continue;
+                }
+                return graph
+                    .findByName(projectId, calleeName)
+                    .filter((symbol) => cleanPath(symbol.filePath) ===
+                    targetPath);
+            }
+        }
+        // Named/default imported function.
+        for (const imported of file.imports) {
+            const binding = imported.bindings
+                .find((item) => item.localName ===
+                calleeName);
+            if (!binding) {
+                continue;
+            }
+            const targetPath = resolveImportFile(filePath, imported.source, availableFiles);
+            if (!targetPath) {
+                continue;
+            }
+            const targetName = binding.importedName ===
+                "default"
+                ? calleeName
+                : binding.importedName;
+            const target = graph
+                .findByName(projectId, targetName)
+                .filter((symbol) => cleanPath(symbol.filePath) ===
+                targetPath);
+            if (target.length) {
+                return target;
+            }
+        }
+        // Last fallback.
+        return graph
+            .findByName(projectId, calleeName)
+            .filter((symbol) => symbol.type ===
+            "function" ||
+            symbol.type ===
+                "method");
+    }
+    edge(projectId, from, type, to, metadata) {
+        return {
+            id: edgeId(projectId, from, type, to),
+            projectId,
+            from,
+            to,
+            type,
+            metadata,
+        };
+    }
+}