toolnet-memory 0.2.0

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

@@ -0,0 +1,31 @@
+export function diffManifest(previous, current) {
+    const oldFiles = previous?.files ?? {};
+    const newFiles = current.files;
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    const unchanged = [];
+    for (const [path, entry] of Object.entries(newFiles)) {
+        const old = oldFiles[path];
+        if (!old) {
+            added.push(path);
+        }
+        else if (old.hash !== entry.hash) {
+            modified.push(path);
+        }
+        else {
+            unchanged.push(path);
+        }
+    }
+    for (const path of Object.keys(oldFiles)) {
+        if (!newFiles[path]) {
+            deleted.push(path);
+        }
+    }
+    return {
+        added: added.sort(),
+        modified: modified.sort(),
+        deleted: deleted.sort(),
+        unchanged: unchanged.sort(),
+    };
+}

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

@@ -0,0 +1,23 @@
+export * from "./types.js";
+export * from "./indexer/repository-scanner.js";
+export * from "./indexer/repository-indexer.js";
+export * from "./parsers/typescript-parser.js";
+export * from "./graph/graph-store.js";
+export * from "./graph/graph-builder.js";
+export * from "./graph/architecture.js";
+export * from "./graph/trace.js";
+export * from "./symbols/reference-resolver.js";
+export * from "./impact/index.js";
+export * from "./incremental/file-hash.js";
+export * from "./incremental/manifest.js";
+export * from "./incremental/manifest-builder.js";
+export * from "./incremental/incremental-indexer.js";
+export * from "./chunks/index.js";
+export * from "./semantic/index.js";
+export * from "./git/index.js";
+export * from "./resolution/index.js";
+export * from "./rich/index.js";
+export * from "./architecture/index.js";
+export * from "./query/index.js";
+export * from "./analysis/index.js";
+export * from "./visualization/index.js";

package/dist/src/code-intelligence/indexer/file-watcher.js

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

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

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

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

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

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

@@ -0,0 +1,31 @@
+import { scanRepository, } from "./repository-scanner.js";
+import { parseTypeScriptFile, } from "../parsers/typescript-parser.js";
+import { GraphBuilder, } from "../graph/graph-builder.js";
+export class RepositoryIndexer {
+    async index(projectId, rootPath) {
+        const files = await scanRepository(rootPath);
+        const parsed = [];
+        for (const file of files) {
+            try {
+                parsed.push(await parseTypeScriptFile(projectId, rootPath, file));
+            }
+            catch (error) {
+                console.warn(`[indexer] skipped ${file}:`, error instanceof Error
+                    ? error.message
+                    : error);
+            }
+        }
+        const graph = new GraphBuilder()
+            .build(projectId, parsed);
+        return {
+            files: parsed.length,
+            symbols: graph
+                .allSymbols(projectId)
+                .length,
+            edges: graph
+                .allEdges(projectId)
+                .length,
+            graph,
+        };
+    }
+}

package/dist/src/code-intelligence/indexer/repository-scanner.js

@@ -0,0 +1,50 @@
+import { readdir, } from "node:fs/promises";
+import { extname, join, relative, } from "node:path";
+import { isSensitiveFile } from "../../security/file-filter.js";
+const EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+]);
+const IGNORED = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".cache",
+    ".toolnet-memory",
+]);
+export async function scanRepository(rootPath) {
+    const files = [];
+    async function walk(dir) {
+        const entries = await readdir(dir, {
+            withFileTypes: true,
+        });
+        for (const entry of entries) {
+            if (IGNORED.has(entry.name)) {
+                continue;
+            }
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full);
+                continue;
+            }
+            if (!EXTENSIONS.has(extname(entry.name))) {
+                continue;
+            }
+            if (isSensitiveFile(full)) {
+                continue;
+            }
+            files.push(relative(rootPath, full));
+        }
+    }
+    await walk(rootPath);
+    return files.sort();
+}

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

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

package/dist/src/code-intelligence/parsers/tree-sitter/index.js

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

package/dist/src/code-intelligence/parsers/tree-sitter/languages.js

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

package/dist/src/code-intelligence/parsers/tree-sitter/parser.js

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

package/dist/src/code-intelligence/parsers/typescript-parser.js

@@ -0,0 +1,190 @@
+import { readFile, } from "node:fs/promises";
+import { join, } from "node:path";
+import { createHash, } from "node:crypto";
+import ts from "typescript";
+function makeId(projectId, value) {
+    return createHash("sha256")
+        .update(`${projectId}:${value}`)
+        .digest("hex")
+        .slice(0, 24);
+}
+function lineOf(source, node) {
+    return source
+        .getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+}
+export async function parseTypeScriptFile(projectId, rootPath, filePath) {
+    const absolute = join(rootPath, filePath);
+    const text = await readFile(absolute, "utf8");
+    const source = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ||
+        filePath.endsWith(".jsx")
+        ? ts.ScriptKind.TSX
+        : ts.ScriptKind.TS);
+    const symbols = [];
+    const imports = [];
+    const calls = [];
+    const heritage = [];
+    const fileSymbol = {
+        id: makeId(projectId, `file:${filePath}`),
+        projectId,
+        name: filePath,
+        qualifiedName: filePath,
+        type: "file",
+        filePath,
+        startLine: 1,
+        endLine: source
+            .getLineAndCharacterOfPosition(source.end).line + 1,
+    };
+    symbols.push(fileSymbol);
+    const callableStack = [];
+    const classStack = [];
+    function addSymbol(node, name, type, qualifiedName) {
+        const symbolId = makeId(projectId, `${filePath}:${type}:${qualifiedName ?? name}:${node.pos}`);
+        symbols.push({
+            id: symbolId,
+            projectId,
+            name,
+            qualifiedName: qualifiedName ??
+                name,
+            type,
+            filePath,
+            startLine: lineOf(source, node),
+            endLine: source
+                .getLineAndCharacterOfPosition(node.end).line + 1,
+        });
+        return symbolId;
+    }
+    function parseImport(node) {
+        if (!ts.isStringLiteral(node.moduleSpecifier)) {
+            return;
+        }
+        const bindings = [];
+        const clause = node.importClause;
+        if (clause?.name) {
+            bindings.push({
+                localName: clause.name.text,
+                importedName: "default",
+                kind: "default",
+            });
+        }
+        if (clause?.namedBindings &&
+            ts.isNamedImports(clause.namedBindings)) {
+            for (const element of clause.namedBindings.elements) {
+                bindings.push({
+                    localName: element.name.text,
+                    importedName: element.propertyName
+                        ?.text ??
+                        element.name.text,
+                    kind: "named",
+                });
+            }
+        }
+        if (clause?.namedBindings &&
+            ts.isNamespaceImport(clause.namedBindings)) {
+            bindings.push({
+                localName: clause.namedBindings
+                    .name.text,
+                importedName: "*",
+                kind: "namespace",
+            });
+        }
+        imports.push({
+            source: node.moduleSpecifier.text,
+            bindings,
+        });
+    }
+    function addHeritage(node, classId) {
+        for (const clause of node.heritageClauses ?? []) {
+            for (const type of clause.types) {
+                const targetName = type.expression
+                    .getText(source)
+                    .split(".")
+                    .at(-1) ?? "";
+                if (!targetName) {
+                    continue;
+                }
+                heritage.push({
+                    fromId: classId,
+                    targetName,
+                    type: clause.token ===
+                        ts.SyntaxKind.ExtendsKeyword
+                        ? "INHERITS"
+                        : "IMPLEMENTS",
+                });
+            }
+        }
+    }
+    function visit(node) {
+        let pushedCallable = false;
+        let pushedClass = false;
+        if (ts.isImportDeclaration(node)) {
+            parseImport(node);
+        }
+        if (ts.isInterfaceDeclaration(node)) {
+            addSymbol(node, node.name.text, "interface", node.name.text);
+        }
+        if (ts.isClassDeclaration(node) &&
+            node.name) {
+            const classId = addSymbol(node, node.name.text, "class", node.name.text);
+            addHeritage(node, classId);
+            classStack.push({
+                id: classId,
+                name: node.name.text,
+            });
+            pushedClass =
+                true;
+        }
+        if (ts.isFunctionDeclaration(node) &&
+            node.name) {
+            const symbolId = addSymbol(node, node.name.text, "function", node.name.text);
+            callableStack.push(symbolId);
+            pushedCallable =
+                true;
+        }
+        if (ts.isMethodDeclaration(node) &&
+            node.name) {
+            const name = node.name.getText(source);
+            const owner = classStack.at(-1)
+                ?.name;
+            const symbolId = addSymbol(node, name, "method", owner
+                ? `${owner}.${name}`
+                : name);
+            callableStack.push(symbolId);
+            pushedCallable =
+                true;
+        }
+        if (ts.isCallExpression(node)) {
+            if (ts.isIdentifier(node.expression)) {
+                calls.push({
+                    callerId: callableStack.at(-1),
+                    calleeName: node.expression.text,
+                    line: lineOf(source, node),
+                });
+            }
+            if (ts.isPropertyAccessExpression(node.expression)) {
+                const expression = node.expression;
+                calls.push({
+                    callerId: callableStack.at(-1),
+                    qualifier: expression.expression
+                        .getText(source),
+                    calleeName: expression.name.text,
+                    line: lineOf(source, node),
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+        if (pushedCallable) {
+            callableStack.pop();
+        }
+        if (pushedClass) {
+            classStack.pop();
+        }
+    }
+    visit(source);
+    return {
+        filePath,
+        symbols,
+        imports,
+        calls,
+        heritage,
+    };
+}

package/dist/src/code-intelligence/query/graph-query-engine.js

@@ -0,0 +1,275 @@
+const DEPENDENCY_EDGES = new Set([
+    "CALLS",
+    "CALL_REFERENCE",
+    "IMPORTS",
+    "USES_TYPE",
+    "WRITES",
+    "INHERITS",
+    "IMPLEMENTS",
+    "ROUTE",
+]);
+const CALL_EDGES = new Set([
+    "CALLS",
+    "CALL_REFERENCE",
+]);
+export class GraphQueryEngine {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    findSymbols(projectId, query) {
+        const normalized = query
+            .trim()
+            .toLowerCase();
+        if (!normalized) {
+            return [];
+        }
+        return this.graph
+            .allSymbols(projectId)
+            .filter((symbol) => symbol.name
+            .toLowerCase()
+            .includes(normalized) ||
+            (symbol.qualifiedName
+                ?.toLowerCase()
+                .includes(normalized) ??
+                false) ||
+            symbol.filePath
+                .toLowerCase()
+                .includes(normalized))
+            .sort((a, b) => {
+            const aExact = a.name
+                .toLowerCase() ===
+                normalized;
+            const bExact = b.name
+                .toLowerCase() ===
+                normalized;
+            if (aExact !==
+                bExact) {
+                return aExact
+                    ? -1
+                    : 1;
+            }
+            return (a.filePath
+                .localeCompare(b.filePath));
+        });
+    }
+    callers(projectId, symbolId) {
+        return this.relatedIncoming(projectId, symbolId, CALL_EDGES);
+    }
+    callees(projectId, symbolId) {
+        return this.relatedOutgoing(projectId, symbolId, CALL_EDGES);
+    }
+    dependents(projectId, symbolId) {
+        return this.relatedIncoming(projectId, symbolId, DEPENDENCY_EDGES);
+    }
+    dependencies(projectId, symbolId) {
+        return this.relatedOutgoing(projectId, symbolId, DEPENDENCY_EDGES);
+    }
+    neighborhood(projectId, symbolId, depth = 1) {
+        const center = this.graph.getSymbol(symbolId);
+        if (!center ||
+            center.projectId !==
+                projectId) {
+            return null;
+        }
+        return {
+            center,
+            incoming: this.walk(projectId, symbolId, "incoming", depth),
+            outgoing: this.walk(projectId, symbolId, "outgoing", depth),
+        };
+    }
+    shortestPath(projectId, fromId, toId, maxDepth = 12) {
+        const from = this.graph.getSymbol(fromId);
+        const to = this.graph.getSymbol(toId);
+        if (!from ||
+            !to ||
+            from.projectId !==
+                projectId ||
+            to.projectId !==
+                projectId) {
+            return {
+                found: false,
+                distance: -1,
+                symbols: [],
+                edges: [],
+            };
+        }
+        if (fromId ===
+            toId) {
+            return {
+                found: true,
+                distance: 0,
+                symbols: [from],
+                edges: [],
+            };
+        }
+        const edges = this.graph
+            .allEdges(projectId)
+            .filter((edge) => DEPENDENCY_EDGES.has(edge.type));
+        const outgoing = new Map();
+        for (const edge of edges) {
+            const list = outgoing.get(edge.from) ?? [];
+            list.push(edge);
+            outgoing.set(edge.from, list);
+        }
+        const queue = [
+            {
+                id: fromId,
+                depth: 0,
+            },
+        ];
+        const visited = new Set([
+            fromId,
+        ]);
+        const previous = new Map();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current.depth >=
+                maxDepth) {
+                continue;
+            }
+            for (const edge of outgoing.get(current.id) ?? []) {
+                if (visited.has(edge.to)) {
+                    continue;
+                }
+                visited.add(edge.to);
+                previous.set(edge.to, {
+                    node: current.id,
+                    edge,
+                });
+                if (edge.to ===
+                    toId) {
+                    return this.buildPath(fromId, toId, previous);
+                }
+                queue.push({
+                    id: edge.to,
+                    depth: current.depth + 1,
+                });
+            }
+        }
+        return {
+            found: false,
+            distance: -1,
+            symbols: [],
+            edges: [],
+        };
+    }
+    buildPath(fromId, toId, previous) {
+        const symbolIds = [
+            toId,
+        ];
+        const edges = [];
+        let current = toId;
+        while (current !==
+            fromId) {
+            const previousNode = previous.get(current);
+            if (!previousNode) {
+                return {
+                    found: false,
+                    distance: -1,
+                    symbols: [],
+                    edges: [],
+                };
+            }
+            edges.push(previousNode.edge);
+            current =
+                previousNode.node;
+            symbolIds.push(current);
+        }
+        symbolIds.reverse();
+        edges.reverse();
+        const symbols = symbolIds
+            .map((id) => this.graph.getSymbol(id))
+            .filter((symbol) => Boolean(symbol));
+        return {
+            found: true,
+            distance: edges.length,
+            symbols,
+            edges,
+        };
+    }
+    walk(projectId, symbolId, direction, maxDepth) {
+        const edges = this.graph
+            .allEdges(projectId)
+            .filter((edge) => DEPENDENCY_EDGES.has(edge.type));
+        const queue = [
+            {
+                id: symbolId,
+                depth: 0,
+            },
+        ];
+        const visited = new Set([
+            symbolId,
+        ]);
+        const output = [];
+        while (queue.length >
+            0) {
+            const current = queue.shift();
+            if (current.depth >=
+                maxDepth) {
+                continue;
+            }
+            for (const edge of edges) {
+                const matches = direction ===
+                    "incoming"
+                    ? edge.to ===
+                        current.id
+                    : edge.from ===
+                        current.id;
+                if (!matches) {
+                    continue;
+                }
+                const nextId = direction ===
+                    "incoming"
+                    ? edge.from
+                    : edge.to;
+                if (visited.has(nextId)) {
+                    continue;
+                }
+                const symbol = this.graph.getSymbol(nextId);
+                if (!symbol) {
+                    continue;
+                }
+                visited.add(nextId);
+                output.push({
+                    symbol,
+                    depth: current.depth +
+                        1,
+                    via: edge,
+                });
+                queue.push({
+                    id: nextId,
+                    depth: current.depth +
+                        1,
+                });
+            }
+        }
+        return output;
+    }
+    relatedIncoming(projectId, symbolId, types) {
+        const ids = new Set(this.graph
+            .allEdges(projectId)
+            .filter((edge) => edge.to ===
+            symbolId &&
+            types.has(edge.type))
+            .map((edge) => edge.from));
+        return [
+            ...ids,
+        ]
+            .map((id) => this.graph.getSymbol(id))
+            .filter((symbol) => Boolean(symbol));
+    }
+    relatedOutgoing(projectId, symbolId, types) {
+        const ids = new Set(this.graph
+            .allEdges(projectId)
+            .filter((edge) => edge.from ===
+            symbolId &&
+            types.has(edge.type))
+            .map((edge) => edge.to));
+        return [
+            ...ids,
+        ]
+            .map((id) => this.graph.getSymbol(id))
+            .filter((symbol) => Boolean(symbol));
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./graph-query-engine.js";

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

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

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

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

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

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