toolnet-memory 0.2.1 → 0.2.2

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

@@ -1,197 +0,0 @@
-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

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

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

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

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

@@ -1,125 +0,0 @@
-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

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

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

@@ -1,109 +0,0 @@
-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

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

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

@@ -1,26 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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,
-        };
-    }
-}