toolnet-memory 0.2.1 → 0.2.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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