@yuaone/core 0.3.2 → 0.4.0

package/dist/repo-knowledge-graph.d.ts

@@ -0,0 +1,112 @@
+/**
+ * @module repo-knowledge-graph
+ * @description Repo Knowledge Graph — Code structure as a queryable graph.
+ *
+ * Nodes: File, Class, Function, Variable, Interface, Type, Module
+ * Edges: imports, calls, extends, implements, depends_on, exports, contains
+ *
+ * Enables: impact analysis, refactor safety, dependency tracing, dead code detection.
+ *
+ * Uses lightweight regex-based parsing (not full AST) for speed.
+ */
+export type NodeType = "file" | "class" | "function" | "variable" | "interface" | "type" | "module";
+export type EdgeType = "imports" | "calls" | "extends" | "implements" | "depends_on" | "exports" | "contains";
+export interface GraphNode {
+    /** Unique: "file:src/index.ts" or "fn:src/index.ts:myFunc" */
+    id: string;
+    type: NodeType;
+    name: string;
+    filePath: string;
+    line?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface GraphEdge {
+    from: string;
+    to: string;
+    type: EdgeType;
+    metadata?: Record<string, unknown>;
+}
+export interface ImpactReport {
+    /** Directly affected nodes */
+    direct: GraphNode[];
+    /** Transitively affected (2+ hops) */
+    transitive: GraphNode[];
+    /** Total impact radius */
+    radius: number;
+    /** Risk level based on affected node count */
+    risk: "low" | "medium" | "high" | "critical";
+    /** Files that need to be checked/updated */
+    affectedFiles: string[];
+}
+/**
+ * RepoKnowledgeGraph — queryable code structure graph.
+ *
+ * Builds a lightweight graph from TypeScript/JavaScript source files
+ * using regex-based parsing. Supports impact analysis, dead code detection,
+ * dependency tracing, and incremental updates.
+ */
+export declare class RepoKnowledgeGraph {
+    private nodes;
+    private edges;
+    private storagePath;
+    constructor(projectRoot: string);
+    /**
+     * Load persisted graph from disk.
+     */
+    init(): Promise<void>;
+    /** Add a node to the graph */
+    addNode(node: GraphNode): void;
+    /** Add an edge (deduplicates) */
+    addEdge(edge: GraphEdge): void;
+    /** Find all callers of a function/method */
+    findCallers(nodeId: string): GraphNode[];
+    /** Find all dependents of a file/module */
+    findDependents(nodeId: string): GraphNode[];
+    /** Analyze impact of changing a node (BFS traversal) */
+    analyzeImpact(nodeId: string, maxDepth?: number): ImpactReport;
+    /**
+     * Find dead code — nodes with no incoming edges (except file nodes).
+     * File nodes are always "alive". Only exported symbols that are never
+     * imported elsewhere are considered dead.
+     */
+    findDeadCode(): GraphNode[];
+    /** Get subgraph for a specific file */
+    getFileGraph(filePath: string): {
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    };
+    /**
+     * Build graph from TypeScript source files (regex-based parsing).
+     * Scans .ts/.tsx files under projectRoot, extracts imports, exports,
+     * classes, functions, interfaces, and types.
+     */
+    buildFromProject(projectRoot: string, filePatterns?: string[]): Promise<void>;
+    /**
+     * Incrementally update graph for changed files.
+     * Removes old nodes/edges for the file, then re-indexes.
+     */
+    updateFiles(changedFiles: string[]): Promise<void>;
+    /** Persist graph to disk */
+    save(): Promise<void>;
+    /** Get graph statistics */
+    getStats(): {
+        nodes: number;
+        edges: number;
+        files: number;
+    };
+    /** Get a node by ID */
+    getNode(id: string): GraphNode | undefined;
+    /** Get all nodes */
+    getAllNodes(): GraphNode[];
+    /** Get all edges */
+    getAllEdges(): GraphEdge[];
+    private load;
+    private collectFiles;
+    private indexFile;
+    private parseImports;
+    private parseDeclarations;
+    private getLineNumber;
+    private findNodeByName;
+    private inferNodeType;
+}
+//# sourceMappingURL=repo-knowledge-graph.d.ts.map

package/dist/repo-knowledge-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-knowledge-graph.d.ts","sourceRoot":"","sources":["../src/repo-knowledge-graph.ts"],"names":[],"mappings":"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"}

package/dist/repo-knowledge-graph.js

@@ -0,0 +1,561 @@
+/**
+ * @module repo-knowledge-graph
+ * @description Repo Knowledge Graph — Code structure as a queryable graph.
+ *
+ * Nodes: File, Class, Function, Variable, Interface, Type, Module
+ * Edges: imports, calls, extends, implements, depends_on, exports, contains
+ *
+ * Enables: impact analysis, refactor safety, dependency tracing, dead code detection.
+ *
+ * Uses lightweight regex-based parsing (not full AST) for speed.
+ */
+import { readFile, writeFile, readdir, stat, mkdir } from "node:fs/promises";
+import { join, relative, dirname, extname, basename } from "node:path";
+// ─── Regex Patterns for Parsing ───
+const IMPORT_PATTERN = /^import\s+(?:(?:type\s+)?(?:\{[^}]*\}|[\w*]+(?:\s+as\s+\w+)?|\*\s+as\s+\w+)(?:\s*,\s*(?:\{[^}]*\}|[\w*]+))*\s+from\s+)?['"]([^'"]+)['"]/gm;
+const EXPORT_NAMED_PATTERN = /^export\s+(?:type\s+)?(?:interface|type|class|function|const|let|var|enum|abstract\s+class)\s+(\w+)/gm;
+const EXPORT_DEFAULT_PATTERN = /^export\s+default\s+(?:class|function|abstract\s+class)\s+(\w+)/gm;
+const CLASS_PATTERN = /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?/gm;
+const FUNCTION_PATTERN = /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/gm;
+const INTERFACE_PATTERN = /^(?:export\s+)?interface\s+(\w+)(?:\s+extends\s+([\w,\s]+))?/gm;
+const TYPE_ALIAS_PATTERN = /^(?:export\s+)?type\s+(\w+)\s*=/gm;
+const CONST_EXPORT_PATTERN = /^(?:export\s+)?(?:const|let|var)\s+(\w+)/gm;
+// ─── RepoKnowledgeGraph ───
+/**
+ * RepoKnowledgeGraph — queryable code structure graph.
+ *
+ * Builds a lightweight graph from TypeScript/JavaScript source files
+ * using regex-based parsing. Supports impact analysis, dead code detection,
+ * dependency tracing, and incremental updates.
+ */
+export class RepoKnowledgeGraph {
+    nodes = new Map();
+    edges = [];
+    storagePath;
+    constructor(projectRoot) {
+        this.storagePath = join(projectRoot, ".yuan", "knowledge-graph.json");
+    }
+    /**
+     * Load persisted graph from disk.
+     */
+    async init() {
+        await this.load();
+    }
+    /** Add a node to the graph */
+    addNode(node) {
+        this.nodes.set(node.id, node);
+    }
+    /** Add an edge (deduplicates) */
+    addEdge(edge) {
+        const exists = this.edges.some((e) => e.from === edge.from && e.to === edge.to && e.type === edge.type);
+        if (!exists) {
+            this.edges.push(edge);
+        }
+    }
+    /** Find all callers of a function/method */
+    findCallers(nodeId) {
+        const callerIds = this.edges
+            .filter((e) => e.to === nodeId && e.type === "calls")
+            .map((e) => e.from);
+        return callerIds
+            .map((id) => this.nodes.get(id))
+            .filter((n) => n !== undefined);
+    }
+    /** Find all dependents of a file/module */
+    findDependents(nodeId) {
+        const depIds = new Set();
+        for (const edge of this.edges) {
+            if (edge.to === nodeId && (edge.type === "imports" || edge.type === "depends_on")) {
+                depIds.add(edge.from);
+            }
+        }
+        return Array.from(depIds)
+            .map((id) => this.nodes.get(id))
+            .filter((n) => n !== undefined);
+    }
+    /** Analyze impact of changing a node (BFS traversal) */
+    analyzeImpact(nodeId, maxDepth = 3) {
+        const direct = [];
+        const transitive = [];
+        const visited = new Set();
+        visited.add(nodeId);
+        const queue = [];
+        // Seed with direct dependents
+        for (const edge of this.edges) {
+            if (edge.to === nodeId &&
+                (edge.type === "imports" ||
+                    edge.type === "depends_on" ||
+                    edge.type === "calls" ||
+                    edge.type === "extends" ||
+                    edge.type === "implements")) {
+                if (!visited.has(edge.from)) {
+                    visited.add(edge.from);
+                    queue.push({ id: edge.from, depth: 1 });
+                }
+            }
+        }
+        while (queue.length > 0) {
+            const item = queue.shift();
+            const node = this.nodes.get(item.id);
+            if (!node)
+                continue;
+            if (item.depth === 1) {
+                direct.push(node);
+            }
+            else {
+                transitive.push(node);
+            }
+            // Continue BFS if within depth limit
+            if (item.depth < maxDepth) {
+                for (const edge of this.edges) {
+                    if (edge.to === item.id &&
+                        !visited.has(edge.from) &&
+                        (edge.type === "imports" ||
+                            edge.type === "depends_on" ||
+                            edge.type === "calls")) {
+                        visited.add(edge.from);
+                        queue.push({ id: edge.from, depth: item.depth + 1 });
+                    }
+                }
+            }
+        }
+        // Collect unique affected files
+        const affectedFiles = new Set();
+        for (const n of [...direct, ...transitive]) {
+            affectedFiles.add(n.filePath);
+        }
+        const totalAffected = direct.length + transitive.length;
+        let risk;
+        if (totalAffected === 0)
+            risk = "low";
+        else if (totalAffected <= 3)
+            risk = "medium";
+        else if (totalAffected <= 10)
+            risk = "high";
+        else
+            risk = "critical";
+        return {
+            direct,
+            transitive,
+            radius: visited.size - 1,
+            risk,
+            affectedFiles: Array.from(affectedFiles),
+        };
+    }
+    /**
+     * Find dead code — nodes with no incoming edges (except file nodes).
+     * File nodes are always "alive". Only exported symbols that are never
+     * imported elsewhere are considered dead.
+     */
+    findDeadCode() {
+        const nodesWithIncoming = new Set();
+        for (const edge of this.edges) {
+            nodesWithIncoming.add(edge.to);
+        }
+        const dead = [];
+        for (const [id, node] of this.nodes) {
+            // Skip file/module nodes — they're always roots
+            if (node.type === "file" || node.type === "module")
+                continue;
+            if (!nodesWithIncoming.has(id)) {
+                dead.push(node);
+            }
+        }
+        return dead;
+    }
+    /** Get subgraph for a specific file */
+    getFileGraph(filePath) {
+        const fileNodes = [];
+        const fileEdges = [];
+        const nodeIds = new Set();
+        for (const [id, node] of this.nodes) {
+            if (node.filePath === filePath) {
+                fileNodes.push(node);
+                nodeIds.add(id);
+            }
+        }
+        for (const edge of this.edges) {
+            if (nodeIds.has(edge.from) || nodeIds.has(edge.to)) {
+                fileEdges.push(edge);
+            }
+        }
+        return { nodes: fileNodes, edges: fileEdges };
+    }
+    /**
+     * Build graph from TypeScript source files (regex-based parsing).
+     * Scans .ts/.tsx files under projectRoot, extracts imports, exports,
+     * classes, functions, interfaces, and types.
+     */
+    async buildFromProject(projectRoot, filePatterns) {
+        const extensions = new Set([".ts", ".tsx", ".js", ".jsx"]);
+        const ignorePatterns = [
+            "node_modules",
+            "dist",
+            ".git",
+            ".next",
+            "coverage",
+            "__pycache__",
+        ];
+        const files = await this.collectFiles(projectRoot, extensions, ignorePatterns);
+        // Apply file pattern filter if provided
+        const filtered = filePatterns
+            ? files.filter((f) => filePatterns.some((p) => {
+                try {
+                    return new RegExp(p).test(f);
+                }
+                catch {
+                    return f.includes(p);
+                }
+            }))
+            : files;
+        for (const filePath of filtered) {
+            await this.indexFile(projectRoot, filePath);
+        }
+    }
+    /**
+     * Incrementally update graph for changed files.
+     * Removes old nodes/edges for the file, then re-indexes.
+     */
+    async updateFiles(changedFiles) {
+        for (const filePath of changedFiles) {
+            // Remove old nodes for this file
+            const oldNodeIds = [];
+            for (const [id, node] of this.nodes) {
+                if (node.filePath === filePath) {
+                    oldNodeIds.push(id);
+                }
+            }
+            for (const id of oldNodeIds) {
+                this.nodes.delete(id);
+            }
+            // Remove old edges involving these nodes
+            const oldIdSet = new Set(oldNodeIds);
+            this.edges = this.edges.filter((e) => !oldIdSet.has(e.from) && !oldIdSet.has(e.to));
+            // Determine project root from storage path
+            const projectRoot = dirname(dirname(this.storagePath)); // .yuan/../..
+            // Re-index if file still exists
+            try {
+                await stat(filePath);
+                await this.indexFile(projectRoot, filePath);
+            }
+            catch {
+                // File was deleted — removal above is sufficient
+            }
+        }
+    }
+    /** Persist graph to disk */
+    async save() {
+        const dir = dirname(this.storagePath);
+        await mkdir(dir, { recursive: true });
+        const data = {
+            nodes: Array.from(this.nodes.values()),
+            edges: this.edges,
+            version: 1,
+            updatedAt: Date.now(),
+        };
+        await writeFile(this.storagePath, JSON.stringify(data), "utf-8");
+    }
+    /** Get graph statistics */
+    getStats() {
+        const files = new Set();
+        for (const node of this.nodes.values()) {
+            files.add(node.filePath);
+        }
+        return {
+            nodes: this.nodes.size,
+            edges: this.edges.length,
+            files: files.size,
+        };
+    }
+    /** Get a node by ID */
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    /** Get all nodes */
+    getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    /** Get all edges */
+    getAllEdges() {
+        return [...this.edges];
+    }
+    // ─── Private: Persistence ───
+    async load() {
+        try {
+            const raw = await readFile(this.storagePath, "utf-8");
+            const data = JSON.parse(raw);
+            this.nodes.clear();
+            this.edges = [];
+            for (const node of data.nodes) {
+                this.nodes.set(node.id, node);
+            }
+            this.edges = data.edges ?? [];
+        }
+        catch {
+            // No persisted graph — start fresh
+        }
+    }
+    // ─── Private: File Collection ───
+    async collectFiles(dir, extensions, ignore) {
+        const results = [];
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (ignore.includes(entry.name))
+                    continue;
+                const fullPath = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    const sub = await this.collectFiles(fullPath, extensions, ignore);
+                    results.push(...sub);
+                }
+                else if (entry.isFile() && extensions.has(extname(entry.name))) {
+                    results.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Permission error or similar — skip
+        }
+        return results;
+    }
+    // ─── Private: Indexing ───
+    async indexFile(projectRoot, filePath) {
+        let content;
+        try {
+            content = await readFile(filePath, "utf-8");
+        }
+        catch {
+            return;
+        }
+        const relPath = relative(projectRoot, filePath);
+        const fileId = `file:${relPath}`;
+        // Add file node
+        this.addNode({
+            id: fileId,
+            type: "file",
+            name: basename(filePath),
+            filePath: relPath,
+        });
+        // Parse imports
+        this.parseImports(content, relPath, fileId, projectRoot);
+        // Parse exports and declarations
+        this.parseDeclarations(content, relPath, fileId);
+    }
+    parseImports(content, relPath, fileId, _projectRoot) {
+        // Reset lastIndex for global regex
+        IMPORT_PATTERN.lastIndex = 0;
+        let match;
+        while ((match = IMPORT_PATTERN.exec(content)) !== null) {
+            const importPath = match[1];
+            // Resolve relative imports to file nodes
+            if (importPath.startsWith(".")) {
+                const dir = dirname(relPath);
+                let resolved = join(dir, importPath);
+                // Normalize extension
+                if (!extname(resolved)) {
+                    resolved += ".ts"; // Default assumption
+                }
+                // Remove leading ./ and normalize
+                resolved = resolved.replace(/\\/g, "/");
+                const targetId = `file:${resolved}`;
+                this.addEdge({
+                    from: fileId,
+                    to: targetId,
+                    type: "imports",
+                    metadata: { importPath },
+                });
+            }
+            else {
+                // External module — create module node
+                const moduleId = `module:${importPath}`;
+                if (!this.nodes.has(moduleId)) {
+                    this.addNode({
+                        id: moduleId,
+                        type: "module",
+                        name: importPath,
+                        filePath: "",
+                    });
+                }
+                this.addEdge({
+                    from: fileId,
+                    to: moduleId,
+                    type: "imports",
+                    metadata: { importPath },
+                });
+            }
+        }
+    }
+    parseDeclarations(content, relPath, fileId) {
+        const lines = content.split("\n");
+        // Track which patterns we're using with their node types
+        const patterns = [
+            { regex: CLASS_PATTERN, nodeType: "class", prefix: "class" },
+            { regex: FUNCTION_PATTERN, nodeType: "function", prefix: "fn" },
+            { regex: INTERFACE_PATTERN, nodeType: "interface", prefix: "iface" },
+            { regex: TYPE_ALIAS_PATTERN, nodeType: "type", prefix: "type" },
+        ];
+        for (const { regex, nodeType, prefix } of patterns) {
+            regex.lastIndex = 0;
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                const name = match[1];
+                const nodeId = `${prefix}:${relPath}:${name}`;
+                const line = this.getLineNumber(content, match.index);
+                this.addNode({
+                    id: nodeId,
+                    type: nodeType,
+                    name,
+                    filePath: relPath,
+                    line,
+                });
+                // File contains this declaration
+                this.addEdge({
+                    from: fileId,
+                    to: nodeId,
+                    type: "contains",
+                });
+                // Handle class extends
+                if (nodeType === "class" && match[2]) {
+                    const parentName = match[2].trim();
+                    // Create a tentative edge — target might be resolved later
+                    this.addEdge({
+                        from: nodeId,
+                        to: `class:*:${parentName}`,
+                        type: "extends",
+                        metadata: { parentName },
+                    });
+                }
+                // Handle class implements
+                if (nodeType === "class" && match[3]) {
+                    const ifaces = match[3]
+                        .split(",")
+                        .map((s) => s.trim())
+                        .filter(Boolean);
+                    for (const iface of ifaces) {
+                        this.addEdge({
+                            from: nodeId,
+                            to: `iface:*:${iface}`,
+                            type: "implements",
+                            metadata: { interfaceName: iface },
+                        });
+                    }
+                }
+                // Handle interface extends
+                if (nodeType === "interface" && match[2]) {
+                    const parents = match[2]
+                        .split(",")
+                        .map((s) => s.trim())
+                        .filter(Boolean);
+                    for (const parent of parents) {
+                        this.addEdge({
+                            from: nodeId,
+                            to: `iface:*:${parent}`,
+                            type: "extends",
+                            metadata: { parentName: parent },
+                        });
+                    }
+                }
+            }
+        }
+        // Parse exported constants/variables
+        CONST_EXPORT_PATTERN.lastIndex = 0;
+        let constMatch;
+        while ((constMatch = CONST_EXPORT_PATTERN.exec(content)) !== null) {
+            const name = constMatch[1];
+            // Only track exports (not internal variables)
+            if (constMatch[0].startsWith("export")) {
+                const nodeId = `var:${relPath}:${name}`;
+                const line = this.getLineNumber(content, constMatch.index);
+                this.addNode({
+                    id: nodeId,
+                    type: "variable",
+                    name,
+                    filePath: relPath,
+                    line,
+                });
+                this.addEdge({
+                    from: fileId,
+                    to: nodeId,
+                    type: "exports",
+                });
+            }
+        }
+        // Parse export default
+        EXPORT_DEFAULT_PATTERN.lastIndex = 0;
+        let defaultMatch;
+        while ((defaultMatch = EXPORT_DEFAULT_PATTERN.exec(content)) !== null) {
+            const name = defaultMatch[1];
+            const nodeId = `default:${relPath}:${name}`;
+            const line = this.getLineNumber(content, defaultMatch.index);
+            this.addNode({
+                id: nodeId,
+                type: "class",
+                name,
+                filePath: relPath,
+                line,
+                metadata: { isDefault: true },
+            });
+            this.addEdge({
+                from: fileId,
+                to: nodeId,
+                type: "exports",
+            });
+        }
+        // Parse named exports
+        EXPORT_NAMED_PATTERN.lastIndex = 0;
+        let namedMatch;
+        while ((namedMatch = EXPORT_NAMED_PATTERN.exec(content)) !== null) {
+            const name = namedMatch[1];
+            // Check if we already have this node (from class/function parsing above)
+            const existingId = this.findNodeByName(relPath, name);
+            const nodeId = existingId ?? `export:${relPath}:${name}`;
+            if (!existingId) {
+                const line = this.getLineNumber(content, namedMatch.index);
+                this.addNode({
+                    id: nodeId,
+                    type: this.inferNodeType(namedMatch[0]),
+                    name,
+                    filePath: relPath,
+                    line,
+                });
+            }
+            this.addEdge({
+                from: fileId,
+                to: nodeId,
+                type: "exports",
+            });
+        }
+    }
+    // ─── Private: Utilities ───
+    getLineNumber(content, index) {
+        let line = 1;
+        for (let i = 0; i < index; i++) {
+            if (content[i] === "\n")
+                line++;
+        }
+        return line;
+    }
+    findNodeByName(filePath, name) {
+        const prefixes = ["class", "fn", "iface", "type", "var", "default"];
+        for (const prefix of prefixes) {
+            const id = `${prefix}:${filePath}:${name}`;
+            if (this.nodes.has(id))
+                return id;
+        }
+        return undefined;
+    }
+    inferNodeType(declaration) {
+        if (/\bclass\b/.test(declaration))
+            return "class";
+        if (/\bfunction\b/.test(declaration))
+            return "function";
+        if (/\binterface\b/.test(declaration))
+            return "interface";
+        if (/\btype\b/.test(declaration))
+            return "type";
+        if (/\b(?:const|let|var)\b/.test(declaration))
+            return "variable";
+        return "variable";
+    }
+}
+//# sourceMappingURL=repo-knowledge-graph.js.map