hyacinth-ai 0.9.6

package/dist/dependency/analyzer.js

@@ -0,0 +1,242 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { DependencyParser } from './parser.js';
+import { toProjectKey } from '../utils/misc.js';
+/** 缓存格式版本号，升级时自动失效重建 */
+const CACHE_VERSION = 1;
+/** 获取依赖图缓存文件路径 */
+function getCachePath() {
+    return path.join(os.homedir(), '.agent', 'cache', 'dependency-graph.json');
+}
+/** 计算文件内容的哈希（用于增量更新检测） */
+function contentHash(content) {
+    return crypto.createHash('md5').update(content).digest('hex').slice(0, 12);
+}
+export class DependencyAnalyzer {
+    parser = new DependencyParser();
+    graph = null;
+    fileHashes = new Map(); // 绝对路径 → content hash
+    rootDir = '';
+    projectKey = '';
+    cachePath = '';
+    /** 分析项目，构建依赖图（优先加载缓存） */
+    async analyze(rootDir) {
+        this.rootDir = rootDir;
+        this.projectKey = toProjectKey(rootDir);
+        this.cachePath = getCachePath();
+        // 尝试加载缓存
+        const cached = await this.loadCache();
+        if (cached && cached.rootDir === rootDir) {
+            this.graph = this.deserialize(cached);
+            this.fileHashes = new Map(Object.entries(cached.fileHashes));
+            return this.graph;
+        }
+        // 缓存不存在或无效，全量构建
+        await this.fullBuild();
+        return this.graph;
+    }
+    /** 全量构建依赖图 */
+    async fullBuild() {
+        const files = await this.parser.scanFiles(this.rootDir);
+        const allDeps = [];
+        for (const file of files) {
+            const deps = await this.parser.parseFile(file, this.rootDir);
+            allDeps.push(...deps);
+            // 计算文件哈希
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                this.fileHashes.set(file, contentHash(content));
+            }
+            catch {
+                // 读取失败，跳过哈希
+            }
+        }
+        this.graph = this.buildIndexes(this.rootDir, files, allDeps);
+        await this.saveCache();
+    }
+    /** 增量更新：重新解析变更文件，更新依赖图 */
+    async incrementalUpdate(changedFiles, gitManager) {
+        if (!this.graph)
+            return;
+        // 如果提供了 gitManager，尝试通过 git diff 获取变更文件列表
+        if (gitManager) {
+            try {
+                const gitChanged = await gitManager.diffNames('HEAD~1');
+                if (gitChanged.length > 0) {
+                    changedFiles = gitChanged;
+                }
+            }
+            catch {
+                // git diff 失败，降级使用传入的 changedFiles
+            }
+        }
+        if (!changedFiles || changedFiles.length === 0)
+            return;
+        // 检测哪些文件实际发生了变化
+        const actuallyChanged = [];
+        for (const file of changedFiles) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const newHash = contentHash(content);
+                const oldHash = this.fileHashes.get(file);
+                if (newHash !== oldHash) {
+                    actuallyChanged.push(file);
+                    this.fileHashes.set(file, newHash);
+                }
+            }
+            catch {
+                // 文件可能被删除
+                actuallyChanged.push(file);
+                this.fileHashes.delete(file);
+            }
+        }
+        if (actuallyChanged.length === 0)
+            return;
+        // 移除变更文件的旧依赖边
+        for (const file of actuallyChanged) {
+            this.graph.dependencies = this.graph.dependencies.filter(d => d.from !== file);
+        }
+        // 重新解析变更文件
+        for (const file of actuallyChanged) {
+            try {
+                const deps = await this.parser.parseFile(file, this.rootDir);
+                this.graph.dependencies.push(...deps);
+            }
+            catch {
+                // 文件可能不存在，跳过
+            }
+        }
+        // 重新构建索引
+        const files = Array.from(this.graph.files);
+        // 检查是否有新文件被引入（解析结果中的 to 可能是新文件）
+        for (const dep of this.graph.dependencies) {
+            files.push(dep.from, dep.to);
+        }
+        const uniqueFiles = [...new Set(files)];
+        this.graph = this.buildIndexes(this.graph.rootDir, uniqueFiles, this.graph.dependencies);
+        await this.saveCache();
+    }
+    /** 构建正向和反向索引 */
+    buildIndexes(rootDir, files, allDeps) {
+        const dependents = new Map();
+        const dependees = new Map();
+        const fileSet = new Set(files);
+        for (const dep of allDeps) {
+            const fromList = dependents.get(dep.from) ?? [];
+            if (!fromList.includes(dep.to))
+                fromList.push(dep.to);
+            dependents.set(dep.from, fromList);
+            const toList = dependees.get(dep.to) ?? [];
+            if (!toList.includes(dep.from))
+                toList.push(dep.from);
+            dependees.set(dep.to, toList);
+        }
+        return { rootDir, files: fileSet, dependencies: allDeps, dependents, dependees };
+    }
+    /** 查询影响面：修改 file 后，哪些文件会受影响 */
+    getImpact(file, symbol) {
+        if (!this.graph) {
+            return { sourceFile: file, symbol, directImpacts: [], indirectImpacts: [], allImpacts: [] };
+        }
+        const normalizedFile = file.replace(/\\/g, '/');
+        const directImpacts = [];
+        const indirectImpacts = [];
+        const visited = new Set();
+        const queue = [{ file: normalizedFile, depth: 0 }];
+        visited.add(normalizedFile);
+        while (queue.length > 0) {
+            const { file: current, depth } = queue.shift();
+            const dependees = this.graph.dependees.get(current) ?? [];
+            for (const dep of dependees) {
+                const normalizedDep = dep.replace(/\\/g, '/');
+                if (visited.has(normalizedDep))
+                    continue;
+                visited.add(normalizedDep);
+                if (symbol) {
+                    const relevantDeps = this.graph.dependencies.filter(d => d.from.replace(/\\/g, '/') === normalizedDep && d.symbols.includes(symbol));
+                    if (relevantDeps.length === 0)
+                        continue;
+                }
+                if (depth === 0) {
+                    directImpacts.push(normalizedDep);
+                }
+                else {
+                    indirectImpacts.push(normalizedDep);
+                }
+                queue.push({ file: normalizedDep, depth: depth + 1 });
+            }
+        }
+        return {
+            sourceFile: normalizedFile,
+            symbol,
+            directImpacts,
+            indirectImpacts,
+            allImpacts: [...directImpacts, ...indirectImpacts],
+        };
+    }
+    /** 获取依赖图（只读） */
+    getGraph() {
+        return this.graph;
+    }
+    /** 获取 projectKey */
+    getProjectKey() {
+        return this.projectKey;
+    }
+    // ─── 序列化 / 反序列化 ──────────────────────────────────────────
+    /** 序列化 DependencyGraph 为可存储的 JSON 格式 */
+    serialize() {
+        if (!this.graph)
+            throw new Error('No graph to serialize');
+        return {
+            version: CACHE_VERSION,
+            rootDir: this.graph.rootDir,
+            builtAt: new Date().toISOString(),
+            files: Array.from(this.graph.files),
+            dependencies: this.graph.dependencies,
+            dependents: Object.fromEntries(this.graph.dependents),
+            dependees: Object.fromEntries(this.graph.dependees),
+            fileHashes: Object.fromEntries(this.fileHashes),
+        };
+    }
+    /** 反序列化 JSON 为 DependencyGraph */
+    deserialize(data) {
+        return {
+            rootDir: data.rootDir,
+            files: new Set(data.files),
+            dependencies: data.dependencies,
+            dependents: new Map(Object.entries(data.dependents)),
+            dependees: new Map(Object.entries(data.dependees)),
+        };
+    }
+    // ─── 缓存读写 ──────────────────────────────────────────────────
+    /** 从磁盘加载缓存 */
+    async loadCache() {
+        try {
+            const content = await fs.readFile(this.cachePath, 'utf-8');
+            const data = JSON.parse(content);
+            // 版本不匹配，缓存无效
+            if (data.version !== CACHE_VERSION)
+                return null;
+            return data;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** 保存缓存到磁盘 */
+    async saveCache() {
+        if (!this.graph)
+            return;
+        try {
+            const dir = path.dirname(this.cachePath);
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(this.cachePath, JSON.stringify(this.serialize(), null, 2), 'utf-8');
+        }
+        catch {
+            // 缓存写入失败不影响主流程
+        }
+    }
+}
+//# sourceMappingURL=analyzer.js.map

package/dist/dependency/data-flow-tracker.d.ts

@@ -0,0 +1,12 @@
+export interface DataFlowPoint {
+    file: string;
+    line: number;
+    kind: 'declaration' | 'assignment' | 'read' | 'argument' | 'return' | 'destructuring';
+    text: string;
+    context: string[];
+}
+export declare class DataFlowTracker {
+    trace(variableName: string, file: string): Promise<DataFlowPoint[]>;
+    private getContext;
+}
+//# sourceMappingURL=data-flow-tracker.d.ts.map

package/dist/dependency/data-flow-tracker.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs/promises';
+const CONTEXT_LINES = 2;
+const MAX_RESULTS = 50;
+export class DataFlowTracker {
+    async trace(variableName, file) {
+        const escaped = variableName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const declRegex = new RegExp(`\\b(?:const|let|var)\\s+(?:\\{[^}]*\\b${escaped}\\b[^}]*\\}|\\b${escaped}\\b)\\s*[=:]`);
+        const destructRegex = new RegExp(`\\b(?:const|let|var)\\s*\\{[^}]*\\b${escaped}\\b[^}]*\\}\\s*=`);
+        const assignRegex = new RegExp(`\\b${escaped}\\s*(?:\\[|\\.)?[\\s]*=(?!=)`);
+        const returnRegex = new RegExp(`\\breturn\\b[^;]*\\b${escaped}\\b`);
+        const argRegex = new RegExp(`\\(.*\\b${escaped}\\b.*\\)`);
+        const readRegex = new RegExp(`\\b${escaped}\\b`);
+        try {
+            const content = await fs.readFile(file, 'utf-8');
+            const lines = content.split('\n');
+            const points = [];
+            for (let i = 0; i < lines.length; i++) {
+                if (points.length >= MAX_RESULTS)
+                    break;
+                const line = lines[i];
+                const trimmed = line.trim();
+                if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*'))
+                    continue;
+                if (destructRegex.test(line)) {
+                    points.push({
+                        file,
+                        line: i + 1,
+                        kind: 'destructuring',
+                        text: trimmed,
+                        context: this.getContext(lines, i),
+                    });
+                }
+                else if (declRegex.test(line)) {
+                    points.push({
+                        file,
+                        line: i + 1,
+                        kind: 'declaration',
+                        text: trimmed,
+                        context: this.getContext(lines, i),
+                    });
+                }
+                else if (returnRegex.test(line)) {
+                    points.push({
+                        file,
+                        line: i + 1,
+                        kind: 'return',
+                        text: trimmed,
+                        context: this.getContext(lines, i),
+                    });
+                }
+                else if (assignRegex.test(line) && !declRegex.test(line) && !destructRegex.test(line)) {
+                    points.push({
+                        file,
+                        line: i + 1,
+                        kind: 'assignment',
+                        text: trimmed,
+                        context: this.getContext(lines, i),
+                    });
+                }
+                else if (argRegex.test(line) && !declRegex.test(line)) {
+                    points.push({
+                        file,
+                        line: i + 1,
+                        kind: 'argument',
+                        text: trimmed,
+                        context: this.getContext(lines, i),
+                    });
+                }
+                else if (readRegex.test(line) && !declRegex.test(line) && !assignRegex.test(line) && !destructRegex.test(line)) {
+                    points.push({
+                        file,
+                        line: i + 1,
+                        kind: 'read',
+                        text: trimmed,
+                        context: this.getContext(lines, i),
+                    });
+                }
+            }
+            return points;
+        }
+        catch {
+            return [];
+        }
+    }
+    getContext(lines, index) {
+        const context = [];
+        const start = Math.max(0, index - CONTEXT_LINES);
+        const end = Math.min(lines.length - 1, index + CONTEXT_LINES);
+        for (let i = start; i <= end; i++) {
+            if (i !== index) {
+                context.push(`  ${i + 1}: ${lines[i].trimEnd()}`);
+            }
+        }
+        return context;
+    }
+}
+//# sourceMappingURL=data-flow-tracker.js.map

package/dist/dependency/function-parser.d.ts

@@ -0,0 +1,34 @@
+export interface FunctionDef {
+    name: string;
+    file: string;
+    line: number;
+    kind: 'function' | 'method' | 'arrow' | 'class' | 'interface' | 'type';
+    signature: string;
+    isAsync: boolean;
+    isExported: boolean;
+}
+export interface CallSite {
+    name: string;
+    file: string;
+    line: number;
+    text: string;
+    receiver?: string;
+    isNew: boolean;
+}
+export declare class FunctionParser {
+    findDefinitions(symbol: string, files: string[]): Promise<FunctionDef[]>;
+    findCallees(functionName: string, file: string): Promise<CallSite[]>;
+    findFunctionBodyRange(functionName: string, file: string): Promise<{
+        startLine: number;
+        endLine: number;
+    } | null>;
+    private parseLineForDefinition;
+    extractBlock(lines: string[], startLine: number): {
+        startLine: number;
+        endLine: number;
+    } | null;
+    private findFirstBrace;
+    private skipBlockComment;
+    private parseLineForCalls;
+}
+//# sourceMappingURL=function-parser.d.ts.map

package/dist/dependency/function-parser.js

@@ -0,0 +1,295 @@
+import fs from 'node:fs/promises';
+const KEYWORDS = new Set([
+    'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue',
+    'return', 'throw', 'try', 'catch', 'finally', 'class', 'function', 'const',
+    'let', 'var', 'import', 'export', 'from', 'as', 'type', 'interface', 'extends',
+    'implements', 'new', 'typeof', 'instanceof', 'void', 'delete', 'in', 'of',
+    'async', 'await', 'yield', 'static', 'get', 'set', 'public', 'private',
+    'protected', 'readonly', 'abstract', 'override', 'declare', 'module',
+    'require', 'console', 'process', 'Math', 'JSON', 'Object', 'Array',
+    'String', 'Number', 'Boolean', 'Promise', 'Map', 'Set', 'Error',
+    'true', 'false', 'null', 'undefined', 'this', 'super',
+]);
+export class FunctionParser {
+    async findDefinitions(symbol, files) {
+        const results = [];
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const lines = content.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    const def = this.parseLineForDefinition(lines[i], file, i + 1);
+                    if (def && def.name === symbol) {
+                        results.push(def);
+                    }
+                }
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+        return results;
+    }
+    async findCallees(functionName, file) {
+        try {
+            const content = await fs.readFile(file, 'utf-8');
+            const lines = content.split('\n');
+            let startLine = -1;
+            for (let i = 0; i < lines.length; i++) {
+                const def = this.parseLineForDefinition(lines[i], file, i + 1);
+                if (def && def.name === functionName) {
+                    startLine = i;
+                    break;
+                }
+            }
+            if (startLine === -1)
+                return [];
+            const block = this.extractBlock(lines, startLine);
+            if (!block)
+                return [];
+            const calls = [];
+            const seen = new Set();
+            for (let i = block.startLine; i <= block.endLine; i++) {
+                const lineCalls = this.parseLineForCalls(lines[i], file, i + 1);
+                for (const call of lineCalls) {
+                    const key = `${call.name}:${call.line}`;
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        calls.push(call);
+                    }
+                }
+            }
+            return calls;
+        }
+        catch {
+            return [];
+        }
+    }
+    async findFunctionBodyRange(functionName, file) {
+        try {
+            const content = await fs.readFile(file, 'utf-8');
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                const def = this.parseLineForDefinition(lines[i], file, i + 1);
+                if (def && def.name === functionName) {
+                    return this.extractBlock(lines, i);
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    parseLineForDefinition(line, file, lineNum) {
+        let match;
+        match = line.match(/^(export\s+)?(async\s+)?function\s+(\w+)/);
+        if (match) {
+            return {
+                name: match[3],
+                file,
+                line: lineNum,
+                kind: 'function',
+                signature: line.trim(),
+                isAsync: !!match[2],
+                isExported: !!match[1],
+            };
+        }
+        match = line.match(/^(export\s+)?(abstract\s+)?class\s+(\w+)/);
+        if (match) {
+            return {
+                name: match[3],
+                file,
+                line: lineNum,
+                kind: 'class',
+                signature: line.trim(),
+                isAsync: false,
+                isExported: !!match[1],
+            };
+        }
+        match = line.match(/^(export\s+)?interface\s+(\w+)/);
+        if (match) {
+            return {
+                name: match[2],
+                file,
+                line: lineNum,
+                kind: 'interface',
+                signature: line.trim(),
+                isAsync: false,
+                isExported: !!match[1],
+            };
+        }
+        match = line.match(/^(export\s+)?type\s+(\w+)/);
+        if (match) {
+            return {
+                name: match[2],
+                file,
+                line: lineNum,
+                kind: 'type',
+                signature: line.trim(),
+                isAsync: false,
+                isExported: !!match[1],
+            };
+        }
+        match = line.match(/^(export\s+)?(const|let|var)\s+(\w+)[^=]*=\s*(async\s+)?(?:function\b|\([^)]*\)\s*=>)/);
+        if (match) {
+            return {
+                name: match[3],
+                file,
+                line: lineNum,
+                kind: 'arrow',
+                signature: line.trim(),
+                isAsync: !!match[4],
+                isExported: !!match[1],
+            };
+        }
+        match = line.match(/^\s+(?:(?:public|private|protected|static|async|abstract|override|readonly)\s+)+(\w+)\s*[<(]/);
+        if (match && !KEYWORDS.has(match[1])) {
+            return {
+                name: match[1],
+                file,
+                line: lineNum,
+                kind: 'method',
+                signature: line.trim(),
+                isAsync: /\basync\b/.test(line),
+                isExported: false,
+            };
+        }
+        return null;
+    }
+    extractBlock(lines, startLine) {
+        let braceLine = -1;
+        let braceCol = -1;
+        for (let i = startLine; i < lines.length && i <= startLine + 5; i++) {
+            const col = this.findFirstBrace(lines[i], i === startLine ? 0 : 0);
+            if (col !== -1) {
+                braceLine = i;
+                braceCol = col;
+                break;
+            }
+        }
+        if (braceCol === -1)
+            return null;
+        let depth = 0;
+        let inString = null;
+        let inTemplate = false;
+        for (let i = braceLine; i < lines.length; i++) {
+            const line = lines[i];
+            const startCol = (i === braceLine) ? braceCol : 0;
+            for (let j = startCol; j < line.length; j++) {
+                const ch = line[j];
+                const next = line[j + 1];
+                if (inString) {
+                    if (ch === '\\') {
+                        j++;
+                        continue;
+                    }
+                    if (inTemplate && ch === '$' && next === '{') {
+                        depth++;
+                        j++;
+                        continue;
+                    }
+                    if (ch === inString) {
+                        if (inTemplate && ch === '`')
+                            inTemplate = false;
+                        inString = null;
+                    }
+                    continue;
+                }
+                if (ch === '/' && next === '/')
+                    break;
+                if (ch === '/' && next === '*') {
+                    j = this.skipBlockComment(line, j + 1) - 1;
+                    continue;
+                }
+                if (ch === '"' || ch === "'" || ch === '`') {
+                    inString = ch;
+                    if (ch === '`')
+                        inTemplate = true;
+                    continue;
+                }
+                if (ch === '{')
+                    depth++;
+                if (ch === '}') {
+                    depth--;
+                    if (depth === 0)
+                        return { startLine: braceLine, endLine: i };
+                }
+            }
+        }
+        return null;
+    }
+    findFirstBrace(line, startCol) {
+        let inString = null;
+        for (let j = startCol; j < line.length; j++) {
+            const ch = line[j];
+            if (inString) {
+                if (ch === '\\') {
+                    j++;
+                    continue;
+                }
+                if (ch === inString)
+                    inString = null;
+                continue;
+            }
+            if (ch === '"' || ch === "'" || ch === '`') {
+                inString = ch;
+                continue;
+            }
+            if (ch === '/' && line[j + 1] === '/')
+                return -1;
+            if (ch === '{')
+                return j;
+        }
+        return -1;
+    }
+    skipBlockComment(line, start) {
+        for (let j = start; j < line.length - 1; j++) {
+            if (line[j] === '*' && line[j + 1] === '/')
+                return j + 2;
+        }
+        return line.length;
+    }
+    parseLineForCalls(line, file, lineNum) {
+        const calls = [];
+        const trimmed = line.trim();
+        if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*'))
+            return calls;
+        if (/^(export\s+)?(async\s+)?function\s+\w/.test(trimmed))
+            return calls;
+        if (/^(export\s+)?(abstract\s+)?class\s+\w/.test(trimmed))
+            return calls;
+        const callRegex = /(?:(\w+)\.)?(\w+)\s*\(/g;
+        let match;
+        while ((match = callRegex.exec(line)) !== null) {
+            const receiver = match[1];
+            const name = match[2];
+            if (KEYWORDS.has(name))
+                continue;
+            if (receiver && KEYWORDS.has(receiver))
+                continue;
+            calls.push({
+                name,
+                file,
+                line: lineNum,
+                text: trimmed,
+                receiver: receiver || undefined,
+                isNew: false,
+            });
+        }
+        const newRegex = /new\s+(\w+)\s*[\(<]/g;
+        while ((match = newRegex.exec(line)) !== null) {
+            if (KEYWORDS.has(match[1]))
+                continue;
+            calls.push({
+                name: match[1],
+                file,
+                line: lineNum,
+                text: trimmed,
+                isNew: true,
+            });
+        }
+        return calls;
+    }
+}
+//# sourceMappingURL=function-parser.js.map

package/dist/dependency/index.d.ts

@@ -0,0 +1,14 @@
+export { DependencyAnalyzer } from './analyzer.js';
+export { DependencyParser } from './parser.js';
+export { FunctionParser } from './function-parser.js';
+export { DataFlowTracker } from './data-flow-tracker.js';
+export type { DependencyGraph, FileDependency, ImpactResult, SerializedDependencyGraph } from './types.js';
+export type { FunctionDef, CallSite } from './function-parser.js';
+export type { DataFlowPoint } from './data-flow-tracker.js';
+import { DependencyAnalyzer } from './analyzer.js';
+/**
+ * 初始化依赖图谱分析器（共享函数，供 CLI/TUI 调用）
+ * 优先加载缓存，缓存无效时全量构建
+ */
+export declare function initDependencyAnalyzer(rootDir: string): Promise<DependencyAnalyzer | undefined>;
+//# sourceMappingURL=index.d.ts.map