@trench-craft/sds 1.0.0

package/dist/src/commands/graph.js

@@ -0,0 +1,783 @@
+import { Command } from 'commander';
+import os from 'os';
+import { resolve } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { GraphEngine } from '../graph/index.js';
+import yaml from 'yaml';
+const graph = new Command('graph')
+    .description('代码图谱管理（结构索引 + 语义增强）');
+// sds graph init
+graph
+    .command('init')
+    .description('初始化图谱数据库，检测项目语言')
+    .option('--lang <lang>', '强制指定语言（ts / python / go / rust / java）', 'auto')
+    .option('--db-path <path>', '图谱数据库路径', '.sds/codegraph.db')
+    .option('--include <dirs>', '额外包含目录（逗号分隔）')
+    .option('--exclude <dirs>', '排除目录（逗号分隔）', 'node_modules,dist,.git')
+    .option('--platform <platform>', '目标平台（claude-code / opencode / codex）', 'auto')
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    const configPath = resolve(projectDir, '.sds/graph.config.yaml');
+    console.log('\n  sds graph init — 初始化图谱数据库\n');
+    console.log(`  项目目录: ${projectDir}\n`);
+    // 检测项目语言
+    let lang = options.lang;
+    if (lang === 'auto') {
+        lang = detectProjectLanguage(projectDir);
+        console.log(`  检测到语言: ${lang}`);
+    }
+    else {
+        console.log(`  指定语言: ${lang}`);
+    }
+    // 检测平台
+    let platform = options.platform;
+    if (platform === 'auto') {
+        if (existsSync(resolve(projectDir, '.codex'))) {
+            platform = 'codex';
+        }
+        else if (existsSync(resolve(projectDir, '.opencode'))) {
+            platform = 'opencode';
+        }
+        else if (existsSync(resolve(projectDir, '.claude'))) {
+            platform = 'claude-code';
+        }
+        else {
+            platform = 'claude-code'; // 默认
+        }
+        console.log(`  检测到平台: ${platform}`);
+    }
+    else {
+        console.log(`  指定平台: ${platform}`);
+    }
+    // 解析 include/exclude
+    const include = options.include
+        ? options.include.split(',').map((s) => s.trim())
+        : ['src', 'lib'];
+    const exclude = options.exclude
+        ? options.exclude.split(',').map((s) => s.trim())
+        : ['node_modules', 'dist', '.git', 'build', 'coverage'];
+    // 生成配置
+    const config = {
+        project: {
+            name: getProjectName(projectDir),
+            lang,
+            root: '.'
+        },
+        graph: {
+            db_path: options.dbPath,
+            semantic_path: '.sds/semantic-graph.json',
+            include,
+            exclude
+        },
+        enhance: {
+            enabled: 'auto',
+            provider: 'openai',
+            model: 'gpt-4o',
+            depth: 'standard',
+            max_files: 50,
+            budget_tokens: 100000
+        },
+        cache: {
+            l1_ttl: 3600,
+            l2_path: '~/.sds/graph-cache/'
+        },
+        platform: {
+            target: platform
+        }
+    };
+    // 确保 .sds 目录存在
+    const sdsDir = resolve(projectDir, '.sds');
+    if (!existsSync(sdsDir)) {
+        mkdirSync(sdsDir, { recursive: true });
+    }
+    // 写入配置文件
+    writeFileSync(configPath, yaml.stringify(config), 'utf-8');
+    console.log(`\n  ✅ 配置文件已生成: .sds/graph.config.yaml`);
+    // 初始化数据库
+    const dbPath = resolve(projectDir, options.dbPath);
+    const engine = new GraphEngine(projectDir, {
+        graph: {
+            dbPath: options.dbPath,
+            semanticPath: '.sds/semantic-graph.json',
+            include,
+            exclude
+        }
+    });
+    await engine.init();
+    engine.close();
+    console.log(`  ✅ 数据库已初始化: ${options.dbPath}`);
+    console.log(`\n  下一步: 运行 'sds graph index' 进行全量索引\n`);
+});
+/**
+ * 检测项目语言
+ */
+function detectProjectLanguage(projectDir) {
+    // 检查常见配置文件
+    const langIndicators = {
+        'typescript': ['tsconfig.json', 'package.json'],
+        'python': ['pyproject.toml', 'setup.py', 'requirements.txt', 'Pipfile'],
+        'go': ['go.mod', 'go.sum'],
+        'rust': ['Cargo.toml', 'Cargo.lock'],
+        'java': ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+        'ruby': ['Gemfile', 'Rakefile'],
+        'php': ['composer.json'],
+        'c': ['Makefile', 'CMakeLists.txt'],
+        'cpp': ['Makefile', 'CMakeLists.txt'],
+    };
+    for (const [lang, files] of Object.entries(langIndicators)) {
+        for (const file of files) {
+            if (existsSync(resolve(projectDir, file))) {
+                // 对于 package.json，进一步检查是否是 TypeScript
+                if (file === 'package.json') {
+                    if (existsSync(resolve(projectDir, 'tsconfig.json'))) {
+                        return 'typescript';
+                    }
+                    return 'javascript';
+                }
+                return lang;
+            }
+        }
+    }
+    return 'unknown';
+}
+/**
+ * 获取项目名称
+ */
+function getProjectName(projectDir) {
+    const packageJsonPath = resolve(projectDir, 'package.json');
+    if (existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+            return packageJson.name || 'unknown';
+        }
+        catch {
+            // ignore
+        }
+    }
+    const pyprojectPath = resolve(projectDir, 'pyproject.toml');
+    if (existsSync(pyprojectPath)) {
+        try {
+            const content = readFileSync(pyprojectPath, 'utf-8');
+            const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+            if (nameMatch)
+                return nameMatch[1];
+        }
+        catch {
+            // ignore
+        }
+    }
+    const cargoPath = resolve(projectDir, 'Cargo.toml');
+    if (existsSync(cargoPath)) {
+        try {
+            const content = readFileSync(cargoPath, 'utf-8');
+            const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+            if (nameMatch)
+                return nameMatch[1];
+        }
+        catch {
+            // ignore
+        }
+    }
+    // 使用目录名
+    return projectDir.split(/[/\\]/).pop() || 'unknown';
+}
+// sds graph index
+graph
+    .command('index')
+    .description('全量索引（CodeGraph Tree-sitter）')
+    .option('--incremental', '增量模式（对比上次索引的 hash）', false)
+    .option('--tiered', '分层索引（大型项目优化）', false)
+    .option('--workers <number>', '并行 Worker 数', String(os.cpus().length))
+    .option('--output-format <format>', '输出格式（sqlite / json / mcp）', 'sqlite')
+    .option('--verbose', '显示详细进度', false)
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    const configPath = resolve(projectDir, '.sds/graph.config.yaml');
+    // 检查配置文件
+    if (!existsSync(configPath)) {
+        console.error('\n  ❌ 未找到配置文件，请先运行: sds graph init\n');
+        process.exit(1);
+    }
+    // 读取配置
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = yaml.parse(configContent);
+    console.log('\n  sds graph index — 全量索引\n');
+    console.log(`  项目目录: ${projectDir}`);
+    console.log(`  增量模式: ${options.incremental ? '是' : '否'}`);
+    console.log(`  分层索引: ${options.tiered ? '是' : '否'}\n`);
+    // 创建引擎
+    const engine = new GraphEngine(projectDir, {
+        graph: {
+            dbPath: config.graph.db_path,
+            semanticPath: config.graph.semantic_path,
+            include: config.graph.include,
+            exclude: config.graph.exclude
+        }
+    });
+    await engine.init();
+    // 执行索引
+    const startTime = Date.now();
+    let stats;
+    if (options.tiered) {
+        // 分层索引
+        console.log('  使用分层索引策略...\n');
+        const progressCallback = (progress) => {
+            if (options.verbose) {
+                const bar = '█'.repeat(Math.floor(progress.percentage / 5)) + '░'.repeat(20 - Math.floor(progress.percentage / 5));
+                process.stdout.write(`\r  ${bar} ${progress.percentage}% | ${progress.phase} | ${progress.current}/${progress.total} | ${progress.speed.toFixed(1)} 文件/秒`);
+            }
+        };
+        stats = await engine.tieredIndex(progressCallback);
+        if (options.verbose) {
+            process.stdout.write('\n');
+        }
+    }
+    else {
+        // 普通索引
+        stats = await engine.index({
+            incremental: options.incremental,
+            verbose: options.verbose
+        });
+    }
+    const durationMs = Date.now() - startTime;
+    // 输出统计
+    console.log('\n  索引完成!\n');
+    console.log(`  文件数: ${stats.filesIndexed}`);
+    console.log(`  函数: ${stats.functions}`);
+    console.log(`  类: ${stats.classes}`);
+    console.log(`  接口: ${stats.interfaces}`);
+    console.log(`  类型: ${stats.types}`);
+    console.log(`  变量: ${stats.variables}`);
+    console.log(`  调用关系: ${stats.callEdges}`);
+    console.log(`  导入关系: ${stats.importEdges}`);
+    console.log(`  耗时: ${durationMs}ms`);
+    console.log(`  缓存命中: ${stats.cacheHit ? '是' : '否'}\n`);
+    engine.close();
+});
+// sds graph enhance
+graph
+    .command('enhance')
+    .description('语义增强（Understand Anything LLM）')
+    .option('--files <files>', '指定文件路径（逗号分隔），不传则自动采样')
+    .option('--depth <depth>', 'lite / standard / deep', 'standard')
+    .option('--model <model>', '覆盖模型')
+    .option('--output <path>', '语义图谱输出路径', '.sds/semantic-graph.json')
+    .option('--dry-run', '预览将分析哪些文件，不实际调用 LLM', false)
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    const configPath = resolve(projectDir, '.sds/graph.config.yaml');
+    // 检查配置文件
+    if (!existsSync(configPath)) {
+        console.error('\n  ❌ 未找到配置文件，请先运行: sds graph init\n');
+        process.exit(1);
+    }
+    // 读取配置
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = yaml.parse(configContent);
+    console.log('\n  sds graph enhance — 语义增强\n');
+    // 创建引擎
+    const engine = new GraphEngine(projectDir, {
+        graph: {
+            dbPath: config.graph.db_path,
+            semanticPath: config.graph.semantic_path,
+            include: config.graph.include,
+            exclude: config.graph.exclude
+        },
+        enhance: {
+            enabled: config.enhance.enabled,
+            provider: config.enhance.provider,
+            model: config.enhance.model,
+            depth: options.depth,
+            maxFiles: config.enhance.max_files,
+            budgetTokens: config.enhance.budget_tokens
+        }
+    });
+    await engine.init();
+    // 检查是否可用
+    if (!engine.isSemanticAvailable()) {
+        console.log('  ⚠️  语义增强不可用\n');
+        console.log('  请设置环境变量:');
+        console.log('    - OPENAI_API_KEY (for OpenAI)');
+        console.log('    - ANTHROPIC_API_KEY (for Anthropic)\n');
+        engine.close();
+        process.exit(1);
+    }
+    // 解析文件列表
+    const files = options.files ? options.files.split(',').map((s) => s.trim()) : undefined;
+    // 构建选项
+    const enhanceOptions = {
+        files,
+        depth: options.depth,
+        model: options.model,
+        budgetTokens: config.enhance.budget_tokens,
+        dryRun: options.dryRun
+    };
+    // 预览采样
+    const preview = engine.previewEnhance(enhanceOptions);
+    console.log(`  采样文件数: ${preview.files.length}`);
+    console.log(`  预估 Token: ${preview.estimatedTokens}`);
+    console.log(`  预估成本: $${preview.estimatedCost.toFixed(4)}`);
+    console.log('');
+    if (options.dryRun) {
+        console.log('  预览模式，不执行实际分析\n');
+        console.log('  采样文件:');
+        for (const file of preview.files) {
+            console.log(`    - ${file.path} (${file.lines} 行)`);
+        }
+        console.log('');
+        engine.close();
+        return;
+    }
+    // 执行增强
+    console.log('  开始语义分析...\n');
+    const result = await engine.enhance(enhanceOptions);
+    if (result.status === 'completed') {
+        console.log('  ✅ 语义增强完成!\n');
+        console.log(`  分析文件数: ${result.filesAnalyzed}`);
+        console.log(`  Token 消耗: ${result.tokensUsed}`);
+        console.log(`  耗时: ${result.durationMs}ms`);
+        console.log(`  输出路径: ${result.outputPath}\n`);
+    }
+    else {
+        console.error('  ❌ 语义增强失败\n');
+        for (const error of result.errors) {
+            console.error(`    - ${error}`);
+        }
+        console.log('');
+    }
+    engine.close();
+});
+// sds graph query
+graph
+    .command('query')
+    .description('查询图谱（SQL / 自然语言）')
+    .option('--sql <query>', 'SQL 查询语句')
+    .option('--nl <query>', '自然语言查询')
+    .option('--template <template>', '预定义查询模板（dead-code / circular-deps / entry-points）')
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    const configPath = resolve(projectDir, '.sds/graph.config.yaml');
+    // 检查配置文件
+    if (!existsSync(configPath)) {
+        console.error('\n  ❌ 未找到配置文件，请先运行: sds graph init\n');
+        process.exit(1);
+    }
+    // 读取配置
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = yaml.parse(configContent);
+    // 创建引擎
+    const engine = new GraphEngine(projectDir, {
+        graph: {
+            dbPath: config.graph.db_path,
+            semanticPath: config.graph.semantic_path,
+            include: config.graph.include,
+            exclude: config.graph.exclude
+        }
+    });
+    await engine.init();
+    let sql = options.sql;
+    // 处理模板查询
+    if (options.template) {
+        sql = getTemplateQuery(options.template);
+        if (!sql) {
+            console.error(`\n  ❌ 未知模板: ${options.template}`);
+            console.error('  可用模板: dead-code, circular-deps, entry-points\n');
+            engine.close();
+            process.exit(1);
+        }
+    }
+    // 处理自然语言查询（简化实现，后续可集成 LLM）
+    if (options.nl) {
+        console.log('\n  ⚠️  自然语言查询暂未实现，请使用 --sql 或 --template\n');
+        engine.close();
+        process.exit(1);
+    }
+    if (!sql) {
+        console.error('\n  ❌ 请指定查询: --sql, --nl, 或 --template\n');
+        engine.close();
+        process.exit(1);
+    }
+    console.log('\n  sds graph query\n');
+    console.log(`  SQL: ${sql}\n`);
+    try {
+        const result = engine.query(sql);
+        // 输出结果
+        if (result.rows.length === 0) {
+            console.log('  没有结果\n');
+        }
+        else {
+            // 格式化输出
+            const maxColWidths = {};
+            // 计算列宽
+            for (const col of result.columns) {
+                maxColWidths[col] = col.length;
+            }
+            for (const row of result.rows) {
+                for (const col of result.columns) {
+                    const val = String(row[col] ?? '');
+                    maxColWidths[col] = Math.max(maxColWidths[col], val.length);
+                }
+            }
+            // 输出表头
+            const header = result.columns.map(col => col.padEnd(maxColWidths[col])).join(' | ');
+            const separator = result.columns.map(col => '-'.repeat(maxColWidths[col])).join('-+-');
+            console.log(`  ${header}`);
+            console.log(`  ${separator}`);
+            // 输出行
+            for (const row of result.rows) {
+                const line = result.columns.map(col => {
+                    const val = String(row[col] ?? '');
+                    return val.padEnd(maxColWidths[col]);
+                }).join(' | ');
+                console.log(`  ${line}`);
+            }
+            console.log(`\n  ${result.rowCount} 行结果，耗时 ${result.durationMs}ms\n`);
+        }
+    }
+    catch (error) {
+        console.error(`\n  ❌ 查询失败: ${error.message}\n`);
+    }
+    engine.close();
+});
+/**
+ * 获取预定义查询模板
+ */
+function getTemplateQuery(template) {
+    const templates = {
+        'dead-code': `
+      SELECT f.path, s.name, s.type
+      FROM symbols s
+      JOIN files f ON s.file_id = f.id
+      WHERE s.id NOT IN (
+        SELECT DISTINCT callee_symbol_id FROM call_graph WHERE callee_symbol_id > 0
+      )
+      AND s.type IN ('function', 'class')
+      ORDER BY f.path, s.name
+    `,
+        'circular-deps': `
+      SELECT 
+        f1.path as file1,
+        f2.path as file2,
+        COUNT(*) as dep_count
+      FROM call_graph cg
+      JOIN files f1 ON cg.caller_file_id = f1.id
+      JOIN files f2 ON cg.callee_file_id = f2.id
+      WHERE cg.relation_type = 'import'
+      AND EXISTS (
+        SELECT 1 FROM call_graph cg2
+        WHERE cg2.caller_file_id = f2.id
+        AND cg2.callee_file_id = f1.id
+        AND cg2.relation_type = 'import'
+      )
+      GROUP BY f1.path, f2.path
+      ORDER BY dep_count DESC
+    `,
+        'entry-points': `
+      SELECT f.path, f.lang, f.lines
+      FROM files f
+      WHERE f.id NOT IN (
+        SELECT DISTINCT callee_file_id FROM call_graph WHERE callee_file_id > 0
+      )
+      OR f.path LIKE '%main%'
+      OR f.path LIKE '%index%'
+      OR f.path LIKE '%app%'
+      ORDER BY f.path
+    `
+    };
+    return templates[template] || null;
+}
+// sds graph diff
+graph
+    .command('diff')
+    .description('增量更新（基于 Git Diff）')
+    .action(async () => {
+    const projectDir = process.cwd();
+    const configPath = resolve(projectDir, '.sds/graph.config.yaml');
+    // 检查配置文件
+    if (!existsSync(configPath)) {
+        console.error('\n  ❌ 未找到配置文件，请先运行: sds graph init\n');
+        process.exit(1);
+    }
+    // 读取配置
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = yaml.parse(configContent);
+    console.log('\n  sds graph diff — 增量更新\n');
+    // 创建引擎
+    const engine = new GraphEngine(projectDir, {
+        graph: {
+            dbPath: config.graph.db_path,
+            semanticPath: config.graph.semantic_path,
+            include: config.graph.include,
+            exclude: config.graph.exclude
+        }
+    });
+    await engine.init();
+    // 执行增量更新
+    const result = await engine.diff();
+    if (result.status === 'no_changes') {
+        console.log('  没有检测到变更文件\n');
+    }
+    else {
+        console.log(`  变更文件数: ${result.changedFiles}`);
+        console.log(`  重新索引节点: ${result.reindexedNodes}`);
+        console.log(`  重新索引关系: ${result.reindexedEdges}`);
+        if (result.semanticInvalidated.length > 0) {
+            console.log(`\n  语义失效文件:`);
+            for (const file of result.semanticInvalidated) {
+                console.log(`    - ${file}`);
+            }
+        }
+        if (result.suggestion) {
+            console.log(`\n  建议: ${result.suggestion}`);
+        }
+    }
+    console.log('');
+    engine.close();
+});
+// sds graph export
+graph
+    .command('export')
+    .description('导出为 AI 助手引导文件片段')
+    .option('--format <format>', '导出格式（claude-md / agents-md / json）', 'claude-md')
+    .option('--output <path>', '输出路径')
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    const configPath = resolve(projectDir, '.sds/graph.config.yaml');
+    // 检查配置文件
+    if (!existsSync(configPath)) {
+        console.error('\n  ❌ 未找到配置文件，请先运行: sds graph init\n');
+        process.exit(1);
+    }
+    // 读取配置
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = yaml.parse(configContent);
+    console.log('\n  sds graph export — 导出图谱\n');
+    // 创建引擎
+    const engine = new GraphEngine(projectDir, {
+        graph: {
+            dbPath: config.graph.db_path,
+            semanticPath: config.graph.semantic_path,
+            include: config.graph.include,
+            exclude: config.graph.exclude
+        }
+    });
+    await engine.init();
+    // 导出图谱
+    const result = await engine.exportGraph({
+        format: options.format,
+        outputPath: options.output
+    });
+    if (result.status === 'completed') {
+        console.log('  ✅ 导出完成!\n');
+        console.log(`  格式: ${result.format}`);
+        console.log(`  输出路径: ${result.outputPath}`);
+        console.log(`  耗时: ${result.durationMs}ms\n`);
+    }
+    else {
+        console.error('  ❌ 导出失败\n');
+        for (const error of result.errors) {
+            console.error(`    - ${error}`);
+        }
+        console.log('');
+    }
+    engine.close();
+});
+// sds graph status
+graph
+    .command('status')
+    .description('查看索引状态、覆盖率、最后更新')
+    .action(async () => {
+    const projectDir = process.cwd();
+    const configPath = resolve(projectDir, '.sds/graph.config.yaml');
+    console.log('\n  sds graph status\n');
+    // 检查配置文件
+    if (!existsSync(configPath)) {
+        console.log('  状态: 未初始化\n');
+        console.log('  运行 \'sds graph init\' 初始化图谱数据库\n');
+        return;
+    }
+    // 读取配置
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = yaml.parse(configContent);
+    // 创建引擎
+    const engine = new GraphEngine(projectDir, {
+        graph: {
+            dbPath: config.graph.db_path,
+            semanticPath: config.graph.semantic_path,
+            include: config.graph.include,
+            exclude: config.graph.exclude
+        }
+    });
+    await engine.init();
+    // 获取状态
+    const status = await engine.getStatus();
+    if (!status.exists) {
+        console.log('  状态: 数据库不存在\n');
+        console.log('  运行 \'sds graph index\' 进行索引\n');
+    }
+    else {
+        console.log('  状态: 已初始化\n');
+        console.log(`  数据库路径: ${status.dbPath}`);
+        console.log(`  文件数: ${status.filesCount}`);
+        console.log(`  符号数: ${status.symbolsCount}`);
+        console.log(`  关系数: ${status.edgesCount}`);
+        console.log(`  覆盖率: ${status.coveragePercent}%`);
+        if (status.lastUpdated) {
+            console.log(`  最后更新: ${status.lastUpdated}`);
+        }
+        if (status.semanticEnabled) {
+            console.log(`  语义增强: 已启用`);
+            if (status.semanticLastUpdated) {
+                console.log(`  语义更新: ${status.semanticLastUpdated}`);
+            }
+        }
+        else {
+            console.log(`  语义增强: 未启用`);
+        }
+    }
+    console.log('');
+    engine.close();
+});
+// sds graph cache
+graph
+    .command('cache')
+    .description('管理 L1/L2 缓存')
+    .option('--clear', '清除所有缓存', false)
+    .option('--info', '显示缓存信息', false)
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    const configPath = resolve(projectDir, '.sds/graph.config.yaml');
+    console.log('\n  sds graph cache — 缓存管理\n');
+    // 检查配置文件
+    if (!existsSync(configPath)) {
+        console.log('  状态: 未初始化\n');
+        console.log('  运行 \'sds graph init\' 初始化图谱数据库\n');
+        return;
+    }
+    // 读取配置
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = yaml.parse(configContent);
+    const dbPath = resolve(projectDir, config.graph.db_path);
+    const semanticPath = resolve(projectDir, config.graph.semantic_path);
+    const l2Path = resolve(projectDir, config.cache.l2_path);
+    if (options.clear) {
+        // 清除缓存
+        console.log('  清除缓存...\n');
+        // 清除 L1 内存缓存（重新加载即可）
+        console.log('  ✅ L1 内存缓存已清除');
+        // 清除 L2 磁盘缓存
+        if (existsSync(l2Path)) {
+            const { rmSync } = await import('fs');
+            rmSync(l2Path, { recursive: true, force: true });
+            console.log('  ✅ L2 磁盘缓存已清除');
+        }
+        else {
+            console.log('  ℹ️  L2 磁盘缓存不存在');
+        }
+        console.log('');
+    }
+    else if (options.info) {
+        // 显示缓存信息
+        console.log('  缓存信息:\n');
+        // L1 内存缓存
+        console.log('  L1 内存缓存:');
+        console.log('    - 状态: 活跃（进程级）');
+        console.log('    - TTL: 配置值');
+        // L2 磁盘缓存
+        console.log('\n  L2 磁盘缓存:');
+        console.log(`    - 路径: ${l2Path}`);
+        if (existsSync(l2Path)) {
+            const { statSync } = await import('fs');
+            const stat = statSync(l2Path);
+            console.log(`    - 状态: 存在`);
+            console.log(`    - 最后修改: ${stat.mtime.toISOString()}`);
+        }
+        else {
+            console.log('    - 状态: 不存在');
+        }
+        // L3 项目本地
+        console.log('\n  L3 项目本地:');
+        console.log(`    - 数据库: ${dbPath}`);
+        console.log(`    - 语义图谱: ${semanticPath}`);
+        if (existsSync(dbPath)) {
+            const { statSync } = await import('fs');
+            const stat = statSync(dbPath);
+            console.log(`    - 数据库大小: ${(stat.size / 1024).toFixed(2)} KB`);
+        }
+        if (existsSync(semanticPath)) {
+            const { statSync } = await import('fs');
+            const stat = statSync(semanticPath);
+            console.log(`    - 语义图谱大小: ${(stat.size / 1024).toFixed(2)} KB`);
+        }
+        console.log('');
+    }
+    else {
+        console.log('  请指定操作:\n');
+        console.log('    --clear  清除所有缓存');
+        console.log('    --info   显示缓存信息\n');
+    }
+});
+// sds graph viz
+graph
+    .command('viz')
+    .description('生成 HTML 交互图谱')
+    .option('--format <format>', '输出格式（html / svg）', 'html')
+    .option('--output <path>', '输出路径')
+    .option('--max-nodes <number>', '最大节点数', '100')
+    .option('--max-edges <number>', '最大边数', '500')
+    .option('--theme <theme>', '主题（light / dark）', 'light')
+    .option('--layout <layout>', '布局算法（hierarchical / circular / force-directed / grid / tree）', 'force-directed')
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    const configPath = resolve(projectDir, '.sds/graph.config.yaml');
+    // 检查配置文件
+    if (!existsSync(configPath)) {
+        console.error('\n  ❌ 未找到配置文件，请先运行: sds graph init\n');
+        process.exit(1);
+    }
+    // 读取配置
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = yaml.parse(configContent);
+    console.log('\n  sds graph viz — 生成交互图谱\n');
+    // 创建引擎
+    const engine = new GraphEngine(projectDir, {
+        graph: {
+            dbPath: config.graph.db_path,
+            semanticPath: config.graph.semantic_path,
+            include: config.graph.include,
+            exclude: config.graph.exclude
+        }
+    });
+    await engine.init();
+    // 生成可视化
+    const result = await engine.visualize({
+        format: options.format,
+        outputPath: options.output,
+        includeCode: false,
+        maxNodes: parseInt(options.maxNodes),
+        maxEdges: parseInt(options.maxEdges),
+        theme: options.theme,
+        layout: options.layout,
+    });
+    if (result.status === 'completed') {
+        console.log('  ✅ 图谱生成完成!\n');
+        console.log(`  格式: ${result.format}`);
+        console.log(`  节点数: ${result.nodesCount}`);
+        console.log(`  边数: ${result.edgesCount}`);
+        console.log(`  输出路径: ${result.outputPath}`);
+        console.log(`  耗时: ${result.durationMs}ms\n`);
+        if (result.format === 'html') {
+            console.log('  在浏览器中打开 HTML 文件查看交互图谱\n');
+        }
+    }
+    else {
+        console.error('  ❌ 图谱生成失败\n');
+        for (const error of result.errors) {
+            console.error(`    - ${error}`);
+        }
+        console.log('');
+    }
+    engine.close();
+});
+export default graph;
+//# sourceMappingURL=graph.js.map