toolnet-memory 0.2.0

package/dist/src/code-intelligence/resolution/typescript-resolver.js

@@ -0,0 +1,316 @@
+import { createHash, } from "node:crypto";
+import { dirname, relative, resolve, } from "node:path";
+import ts from "typescript";
+function normalize(value) {
+    return value
+        .replaceAll("\\", "/")
+        .replace(/^\.\//, "");
+}
+function hash(value) {
+    return createHash("sha256")
+        .update(value)
+        .digest("hex")
+        .slice(0, 24);
+}
+function lineOf(source, node) {
+    return source
+        .getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+}
+function declarationName(declaration) {
+    const named = declaration;
+    if (named.name &&
+        ts.isIdentifier(named.name)) {
+        return named.name.text;
+    }
+    return undefined;
+}
+export class TypeScriptTypeResolver {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+    async resolveProject(projectId, rootPath) {
+        const config = this.loadConfig(rootPath);
+        const program = ts.createProgram({
+            rootNames: config.fileNames,
+            options: config.options,
+        });
+        const checker = program.getTypeChecker();
+        const output = [];
+        for (const source of program.getSourceFiles()) {
+            if (source.isDeclarationFile) {
+                continue;
+            }
+            const absolute = resolve(source.fileName);
+            const relativePath = normalize(relative(rootPath, absolute));
+            /*
+             * Không index node_modules hoặc file ngoài project.
+             */
+            if (relativePath.startsWith("../") ||
+                relativePath.includes("node_modules/")) {
+                continue;
+            }
+            const visit = (node) => {
+                if (ts.isCallExpression(node)) {
+                    const result = this.resolveCall({
+                        projectId,
+                        rootPath,
+                        source,
+                        node,
+                        checker,
+                    });
+                    if (result) {
+                        output.push(result);
+                    }
+                }
+                if (ts.isClassDeclaration(node)) {
+                    output.push(...this.resolveHeritage({
+                        projectId,
+                        rootPath,
+                        source,
+                        node,
+                        checker,
+                    }));
+                }
+                ts.forEachChild(node, visit);
+            };
+            visit(source);
+        }
+        return {
+            version: 1,
+            projectId,
+            updatedAt: new Date()
+                .toISOString(),
+            total: output.length,
+            exact: output.filter((item) => item.confidence ===
+                "exact").length,
+            high: output.filter((item) => item.confidence ===
+                "high").length,
+            fallback: output.filter((item) => item.confidence ===
+                "fallback").length,
+            resolutions: output,
+        };
+    }
+    resolveCall(input) {
+        const { projectId, rootPath, source, node, checker, } = input;
+        let declaration;
+        /*
+         * Đây là phần quan trọng:
+         * TypeChecker resolve signature thực tế của obj.method().
+         */
+        const signature = checker.getResolvedSignature(node);
+        declaration =
+            signature?.declaration;
+        if (!declaration) {
+            const symbol = checker.getSymbolAtLocation(node.expression);
+            declaration =
+                symbol
+                    ?.valueDeclaration ??
+                    symbol
+                        ?.declarations?.[0];
+        }
+        if (!declaration) {
+            return this.fallbackCall(projectId, rootPath, source, node);
+        }
+        return this.fromDeclaration({
+            projectId,
+            rootPath,
+            source,
+            sourceNode: node,
+            declaration,
+            expression: node.expression
+                .getText(source),
+            kind: "CALL",
+        });
+    }
+    resolveHeritage(input) {
+        const { projectId, rootPath, source, node, checker, } = input;
+        const output = [];
+        for (const clause of node.heritageClauses ??
+            []) {
+            for (const item of clause.types) {
+                const symbol = checker.getSymbolAtLocation(item.expression);
+                const declaration = symbol
+                    ?.valueDeclaration ??
+                    symbol
+                        ?.declarations?.[0];
+                if (!declaration) {
+                    continue;
+                }
+                const result = this.fromDeclaration({
+                    projectId,
+                    rootPath,
+                    source,
+                    sourceNode: item,
+                    declaration,
+                    expression: item.getText(source),
+                    kind: clause.token ===
+                        ts.SyntaxKind
+                            .ExtendsKeyword
+                        ? "EXTENDS"
+                        : "IMPLEMENTS",
+                });
+                if (result) {
+                    output.push(result);
+                }
+            }
+        }
+        return output;
+    }
+    fromDeclaration(input) {
+        const declarationSource = input.declaration
+            .getSourceFile();
+        if (declarationSource
+            .isDeclarationFile) {
+            return null;
+        }
+        const targetFile = normalize(relative(input.rootPath, resolve(declarationSource
+            .fileName)));
+        if (targetFile.startsWith("../") ||
+            targetFile.includes("node_modules/")) {
+            return null;
+        }
+        const targetLine = lineOf(declarationSource, input.declaration);
+        const targetName = declarationName(input.declaration) ??
+            input.expression
+                .split(".")
+                .at(-1);
+        const graphSymbol = this.findGraphSymbol(input.projectId, targetFile, targetLine, targetName);
+        const sourceFile = normalize(relative(input.rootPath, resolve(input.source
+            .fileName)));
+        return {
+            id: hash([
+                input.projectId,
+                sourceFile,
+                lineOf(input.source, input.sourceNode),
+                input.kind,
+                targetFile,
+                targetLine,
+            ].join(":")),
+            projectId: input.projectId,
+            kind: input.kind,
+            sourceFile,
+            sourceLine: lineOf(input.source, input.sourceNode),
+            expression: input.expression,
+            targetFile,
+            targetLine,
+            targetName,
+            targetQualifiedName: graphSymbol
+                ?.qualifiedName,
+            targetSymbolId: graphSymbol?.id,
+            confidence: graphSymbol
+                ? "exact"
+                : "high",
+            resolver: "typescript-checker",
+        };
+    }
+    fallbackCall(projectId, rootPath, source, node) {
+        const name = node.expression
+            .getText(source)
+            .split(".")
+            .at(-1);
+        if (!name) {
+            return null;
+        }
+        const candidates = this.graph
+            .findByName(projectId, name)
+            .filter((symbol) => symbol.type ===
+            "function" ||
+            symbol.type ===
+                "method");
+        if (candidates.length !== 1) {
+            return null;
+        }
+        const target = candidates[0];
+        const sourceFile = normalize(relative(rootPath, resolve(source.fileName)));
+        return {
+            id: hash(`${projectId}:${sourceFile}:${lineOf(source, node)}:${target.id}`),
+            projectId,
+            kind: "CALL",
+            sourceFile,
+            sourceLine: lineOf(source, node),
+            expression: node.expression
+                .getText(source),
+            targetFile: target.filePath,
+            targetLine: target.startLine,
+            targetName: target.name,
+            targetQualifiedName: target.qualifiedName,
+            targetSymbolId: target.id,
+            confidence: "fallback",
+            resolver: "graph-fallback",
+        };
+    }
+    findGraphSymbol(projectId, filePath, line, name) {
+        const symbols = this.graph
+            .allSymbols(projectId)
+            .filter((symbol) => normalize(symbol.filePath) ===
+            normalize(filePath));
+        /*
+         * Ưu tiên symbol chứa declaration line.
+         */
+        const containing = symbols.filter((symbol) => typeof symbol.startLine ===
+            "number" &&
+            typeof symbol.endLine ===
+                "number" &&
+            symbol.startLine <=
+                line &&
+            symbol.endLine >=
+                line);
+        if (name) {
+            const named = containing.find((symbol) => symbol.name ===
+                name ||
+                (symbol.qualifiedName
+                    ?.endsWith(`.${name}`) ?? false));
+            if (named) {
+                return named;
+            }
+        }
+        return containing
+            .sort((a, b) => ((a.endLine ?? 0) -
+            (a.startLine ?? 0)) -
+            ((b.endLine ?? 0) -
+                (b.startLine ?? 0)))[0];
+    }
+    loadConfig(rootPath) {
+        const configPath = ts.findConfigFile(rootPath, ts.sys.fileExists, "tsconfig.json");
+        if (configPath) {
+            const config = ts.readConfigFile(configPath, ts.sys.readFile);
+            if (config.error) {
+                throw new Error(ts.flattenDiagnosticMessageText(config.error.messageText, "\n"));
+            }
+            return ts.parseJsonConfigFileContent(config.config, ts.sys, dirname(configPath));
+        }
+        /*
+         * Repo không có tsconfig vẫn chạy JS/TS.
+         */
+        const fileNames = ts.sys.readDirectory(rootPath, [
+            ".ts",
+            ".tsx",
+            ".js",
+            ".jsx",
+            ".mts",
+            ".cts",
+            ".mjs",
+            ".cjs",
+        ], [
+            "node_modules",
+            ".git",
+            "dist",
+            "build",
+            "coverage",
+        ]);
+        return {
+            fileNames,
+            options: {
+                allowJs: true,
+                checkJs: false,
+                target: ts.ScriptTarget.ES2022,
+                module: ts.ModuleKind.NodeNext,
+                moduleResolution: ts.ModuleResolutionKind
+                    .NodeNext,
+                skipLibCheck: true,
+                noEmit: true,
+            },
+        };
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./rich-graph-enricher.js";