@limo-labs/limo-cli 0.1.0-alpha.0

package/dist/commands/analyze.js

@@ -0,0 +1,562 @@
+/**
+ * Analyze command - Main entry point for codebase analysis
+ */
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import * as url from 'url';
+import chalk from 'chalk';
+import ora from 'ora';
+import { runWorkflow, createSequenceNode, createStepNode, createEnhancedContext, InMemoryStore, InMemoryTrace, compileAgent } from '@limo-labs/deity';
+import { CopilotSDKAdapter } from '@limo-labs/deity-adapter-copilot';
+import { createPlannerAgent } from '../agents/planner.js';
+import { createAnalystAgent } from '../agents/analyst.js';
+import { createWriterAgent } from '../agents/writer.js';
+import { createEditorAgent } from '../agents/editor.js';
+import { createAllTools } from '../tools/index.js';
+import { debug } from '../utils/debug.js';
+import { parseLimoConfig } from '../utils/limoConfigParser.js';
+// ES modules compatibility
+const __filename = url.fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function analyze(targetPath, options) {
+    // In debug or verbose mode, disable spinner to show full output
+    const useSpinner = !options.debug && !options.debugApi && !options.verbose;
+    const spinner = useSpinner ? ora('Initializing Limo CLI...').start() : null;
+    if (!useSpinner) {
+        console.log(chalk.blue('Initializing Limo CLI...'));
+    }
+    try {
+        debug.section('LIMO CLI INITIALIZATION');
+        // Resolve paths
+        const workspaceRoot = path.resolve(targetPath);
+        const outputDir = path.resolve(options.output || '.limo');
+        const promptsDir = path.join(__dirname, '../../prompts');
+        debug.debug('Workspace root:', workspaceRoot);
+        debug.debug('Output directory:', outputDir);
+        debug.debug('Prompts directory:', promptsDir);
+        // Verify workspace exists
+        try {
+            await fs.access(workspaceRoot);
+            debug.success('Workspace directory exists');
+        }
+        catch {
+            throw new Error(`Directory not found: ${workspaceRoot}`);
+        }
+        if (useSpinner) {
+            spinner.text = 'Verifying GitHub Copilot access...';
+        }
+        debug.debug('Checking GitHub Copilot access...');
+        // Parse LIMO.md configuration (if exists)
+        if (useSpinner) {
+            spinner.text = 'Checking for LIMO.md configuration...';
+        }
+        debug.debug('Parsing LIMO.md configuration...');
+        const limoConfig = await parseLimoConfig(workspaceRoot);
+        if (limoConfig) {
+            debug.success('Found LIMO.md configuration');
+            if (limoConfig.focusAreas) {
+                debug.info('Focus areas:', limoConfig.focusAreas);
+            }
+            if (limoConfig.excludeModules) {
+                debug.info('Excluded modules:', limoConfig.excludeModules);
+            }
+            if (limoConfig.scopeDescription) {
+                debug.info('Scope description:', limoConfig.scopeDescription.substring(0, 100) + '...');
+            }
+        }
+        else {
+            debug.info('No LIMO.md file found - using default configuration');
+        }
+        // Parse modules - Apply LIMO.md configuration
+        let modules = options.modules?.split(',') || [
+            'architecture',
+            'dependencies',
+            'code-quality',
+            'security',
+            'database',
+            'testing',
+            'migration'
+        ];
+        // Apply LIMO.md focus areas (if specified)
+        if (limoConfig?.focusAreas && limoConfig.focusAreas.length > 0) {
+            modules = limoConfig.focusAreas;
+            debug.info('Using LIMO.md focus areas:', modules);
+        }
+        // Apply LIMO.md excludes (remove from modules)
+        if (limoConfig?.excludeModules && limoConfig.excludeModules.length > 0) {
+            modules = modules.filter(m => !limoConfig.excludeModules.includes(m));
+            debug.info('After excluding modules:', modules);
+        }
+        debug.debug('Final analysis modules:', modules);
+        if (useSpinner) {
+            spinner.text = 'Setting up analysis environment...';
+        }
+        // Create output directory
+        const analysisId = generateId();
+        const reportDir = path.join(outputDir, 'reports', analysisId);
+        await fs.mkdir(reportDir, { recursive: true });
+        debug.success('Report directory created:', reportDir);
+        // Create tool context
+        const toolContext = {
+            workspaceRoot,
+            outputDir: reportDir,
+            memory: new Map(), // Internal runtime state (not AI semantic memory)
+            reportSections: new Map(),
+            diagrams: new Map()
+        };
+        debug.debug('Tool context initialized');
+        // Create ExecutionContext with memory enabled for Deity's built-in memory tools
+        const executionContext = await createEnhancedContext({
+            inputs: { workspaceRoot, modules },
+            store: new InMemoryStore(),
+            trace: new InMemoryTrace(),
+            enableMemory: true
+        });
+        debug.debug('Execution context with memory initialized');
+        // Create tools (passing ExecutionContext for Deity's memory tools)
+        const allTools = createAllTools(toolContext, executionContext);
+        // Filter tools for Planner (only needs basic file operations, memory, and planning)
+        const plannerToolNames = ['file_list', 'file_read', 'memory_store', 'planning_create', 'file_search_content'];
+        const plannerTools = allTools.filter((t) => plannerToolNames.includes(t.name));
+        debug.success(`Created ${allTools.length} total tools (${plannerTools.length} for planner)`);
+        if (options.debug) {
+            debug.object('Planner tools', plannerTools.map((t) => t.name));
+        }
+        // Create LLM adapter using Copilot SDK (better performance than gh CLI)
+        const model = options.model || 'claude-opus-4.6'; // Use Claude Opus for best quality
+        // Streaming callback to show AI thinking in real-time
+        let currentLine = '';
+        const llmAdapter = new CopilotSDKAdapter({
+            model,
+            onStreamChunk: (chunk) => {
+                // Display streaming tokens in real-time
+                if (!useSpinner) {
+                    process.stdout.write(chalk.gray(chunk));
+                }
+                else {
+                    // When using spinner, update spinner text with current line
+                    currentLine += chunk;
+                    if (chunk.includes('\n')) {
+                        const lines = currentLine.split('\n');
+                        currentLine = lines[lines.length - 1];
+                        if (lines[0].trim()) {
+                            spinner.text = chalk.gray(lines[0].substring(0, 80));
+                        }
+                    }
+                }
+            },
+            onReasoningChunk: (chunk) => {
+                // Display reasoning/thinking process
+                if (!useSpinner) {
+                    process.stdout.write(chalk.dim.italic(chunk));
+                }
+            }
+        });
+        // Initialize the adapter
+        debug.debug('Initializing Copilot SDK adapter...');
+        await llmAdapter.initialize();
+        debug.debug('LLM adapter initialized:', model);
+        console.log('');
+        console.log(chalk.blue('🤖 AI Configuration'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(chalk.cyan('Model:'), model);
+        console.log(chalk.cyan('Provider:'), 'GitHub Copilot SDK (native)');
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log('');
+        if (useSpinner) {
+            spinner.text = 'Creating analysis plan...';
+        }
+        // Create Planner agent
+        const plannerAgent = compileAgent(createPlannerAgent(promptsDir));
+        // Add tools to agent
+        const plannerWithTools = {
+            ...plannerAgent,
+            tools: plannerTools // Only pass planner-specific tools
+        };
+        // Run Planner
+        const plannerWorkflow = {
+            name: 'limo-planner',
+            graph: createSequenceNode([createStepNode(plannerWithTools)]),
+            defaultModel: { adapter: llmAdapter }
+        };
+        console.log(''); // New line after spinner
+        console.log(chalk.blue('🚀 Starting Limo Analysis'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(chalk.cyan('Workspace:'), workspaceRoot);
+        console.log(chalk.cyan('Output:'), reportDir);
+        console.log(chalk.cyan('Modules:'), modules.join(', '));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log('');
+        if (useSpinner) {
+            spinner.start('AI is creating analysis plan...');
+        }
+        else {
+            console.log(chalk.blue('🤖 AI is creating analysis plan...'));
+            console.log(chalk.gray('─'.repeat(50)));
+        }
+        debug.section('PLANNER AGENT EXECUTION');
+        debug.agentStart('planner', { workspaceRoot, modules });
+        let planResult;
+        try {
+            debug.debug('Running planner workflow...');
+            planResult = await runWorkflow(plannerWorkflow, {
+                workspaceRoot,
+                modules,
+                limoConfig // Pass LIMO.md configuration to Planner
+            });
+            debug.agentEnd('planner', planResult);
+            toolContext.plan = planResult;
+            if (useSpinner) {
+                spinner.succeed(chalk.green(`Plan created: ${planResult.total_tasks} tasks`));
+            }
+            else {
+                console.log(chalk.green(`✓ Plan created: ${planResult.total_tasks} tasks`));
+            }
+            debug.success('Planning completed successfully');
+            debug.object('Plan summary', {
+                complexity: planResult.project_complexity,
+                files: planResult.estimated_files,
+                loc: planResult.estimated_loc,
+                tasks: planResult.total_tasks
+            });
+        }
+        catch (error) {
+            if (useSpinner) {
+                spinner.fail(chalk.red('Planning failed'));
+            }
+            else {
+                console.log(chalk.red('✖ Planning failed'));
+            }
+            debug.error('Planner failed:', error);
+            console.error('Error:', error);
+            throw error;
+        }
+        console.log('');
+        console.log(chalk.yellow('📋 Analysis Plan'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(chalk.cyan('Complexity:'), planResult.project_complexity);
+        console.log(chalk.cyan('Estimated Files:'), planResult.estimated_files);
+        console.log(chalk.cyan('Estimated LOC:'), planResult.estimated_loc);
+        console.log(chalk.cyan('Total Tasks:'), planResult.total_tasks);
+        console.log('');
+        console.log(chalk.cyan('Tasks by Module:'));
+        Object.entries(planResult.summary.tasks_by_module).forEach(([module, count]) => {
+            console.log(`  ${chalk.gray('•')} ${module}: ${count}`);
+        });
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log('');
+        // Save manifest
+        const manifest = {
+            id: analysisId,
+            displayName: `Analysis Report ${new Date().toISOString().replace('T', ' ').substring(0, 19)}`,
+            createdAt: new Date().toISOString(),
+            scope: {
+                targetPath: workspaceRoot,
+                modules
+            },
+            status: 'planning',
+            version: '2.0.0'
+        };
+        await fs.writeFile(path.join(reportDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+        debug.debug('Manifest saved');
+        // Save plan
+        await fs.writeFile(path.join(reportDir, 'plan.json'), JSON.stringify(planResult, null, 2));
+        debug.debug('Plan saved to plan.json');
+        console.log(chalk.green('✓ Analysis plan saved to:'), reportDir);
+        console.log('');
+        const tasksToProcess = planResult.tasks;
+        console.log('');
+        debug.section('MULTI-PHASE ANALYSIS');
+        // ========================================
+        // PHASE 2: ANALYSIS (Analyst only)
+        // ========================================
+        console.log('');
+        console.log(chalk.blue('📊 Phase 2: Analysis'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(chalk.dim('Running Analyst agent to analyze code and store findings in memory'));
+        console.log('');
+        for (let i = 0; i < tasksToProcess.length; i++) {
+            const task = tasksToProcess[i];
+            debug.progress(i + 1, tasksToProcess.length, `Analyzing task: ${task.task_id}`);
+            if (useSpinner) {
+                spinner.start(`[${i + 1}/${tasksToProcess.length}] 🔍 Analyzing: ${task.title}`);
+            }
+            else {
+                console.log(chalk.blue(`[${i + 1}/${tasksToProcess.length}] 🔍 Analyzing: ${task.title}`));
+            }
+            try {
+                // Run Analyst
+                debug.agentStart('analyst', { task_id: task.task_id, title: task.title });
+                // Filter tools for Analyst (needs file ops, terminal, memory, web search)
+                const analystToolNames = [
+                    'file_list', 'file_read', 'file_search_content', 'terminal_execute',
+                    'memory_store', 'memory_recall', 'memory_list', 'memory_search',
+                    'web_search', 'web_fetch',
+                    'task_get_current', 'task_execute_next',
+                    'subtask_create_plan', 'subtask_get_current', 'subtask_complete', 'subtask_skip',
+                    'context_reset', 'context_stats',
+                    'code_analyze_dead', 'code_check_references'
+                ];
+                const analystTools = allTools.filter((t) => analystToolNames.includes(t.name));
+                const analystAgent = compileAgent(createAnalystAgent(promptsDir));
+                const analystWithTools = { ...analystAgent, tools: analystTools };
+                const analystWorkflow = {
+                    name: 'limo-analyst',
+                    graph: createSequenceNode([createStepNode(analystWithTools)]),
+                    defaultModel: { adapter: llmAdapter }
+                };
+                debug.debug('Running analyst workflow...');
+                const analystResult = await runWorkflow(analystWorkflow, {
+                    task,
+                    workspaceRoot,
+                    promptsDir
+                });
+                debug.agentEnd('analyst', { memoriesCreated: analystResult.memoriesCreated });
+                if (useSpinner) {
+                    spinner.succeed(chalk.green(`✓ [${i + 1}/${tasksToProcess.length}] ${task.title}`));
+                }
+                else {
+                    console.log(chalk.green(`✓ [${i + 1}/${tasksToProcess.length}] ${task.title}`));
+                }
+            }
+            catch (error) {
+                if (useSpinner) {
+                    spinner.fail(chalk.red(`✖ [${i + 1}/${tasksToProcess.length}] ${task.title}`));
+                }
+                else {
+                    console.log(chalk.red(`✖ [${i + 1}/${tasksToProcess.length}] ${task.title}`));
+                }
+                console.error(chalk.gray(`  Error: ${error instanceof Error ? error.message : String(error)}`));
+                debug.error(`Analysis task ${task.task_id} failed:`, error);
+                // Continue with next task
+            }
+        }
+        // ========================================
+        // PHASE 3: WRITING (Writer only)
+        // ========================================
+        console.log('');
+        console.log(chalk.blue('✍️  Phase 3: Writing'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(chalk.dim('Running Writer agent to create report sections from memory'));
+        console.log('');
+        for (let i = 0; i < tasksToProcess.length; i++) {
+            const task = tasksToProcess[i];
+            debug.progress(i + 1, tasksToProcess.length, `Writing task: ${task.task_id}`);
+            if (useSpinner) {
+                spinner.start(`[${i + 1}/${tasksToProcess.length}] ✍️  Writing: ${task.title}`);
+            }
+            else {
+                console.log(chalk.blue(`[${i + 1}/${tasksToProcess.length}] ✍️  Writing: ${task.title}`));
+            }
+            try {
+                // Run Writer
+                debug.agentStart('writer', { task_id: task.task_id, title: task.title });
+                const writerAgent = compileAgent(createWriterAgent(promptsDir));
+                // Filter tools for Writer (only needs memory recall and report writing)
+                const writerToolNames = ['memory_recall', 'memory_list', 'memory_search', 'report_write', 'report_add_diagram', 'web_search', 'web_fetch'];
+                const writerTools = allTools.filter((t) => writerToolNames.includes(t.name));
+                const writerWithTools = { ...writerAgent, tools: writerTools };
+                const writerWorkflow = {
+                    name: 'limo-writer',
+                    graph: createSequenceNode([createStepNode(writerWithTools)]),
+                    defaultModel: { adapter: llmAdapter }
+                };
+                debug.debug('Running writer workflow...');
+                const writerResult = await runWorkflow(writerWorkflow, {
+                    task,
+                    promptsDir,
+                    reportLanguage: options.lang || 'English'
+                });
+                debug.agentEnd('writer', { wordCount: writerResult.wordCount });
+                if (useSpinner) {
+                    spinner.succeed(chalk.green(`✓ [${i + 1}/${tasksToProcess.length}] ${task.title}`));
+                }
+                else {
+                    console.log(chalk.green(`✓ [${i + 1}/${tasksToProcess.length}] ${task.title}`));
+                }
+            }
+            catch (error) {
+                if (useSpinner) {
+                    spinner.fail(chalk.red(`✖ [${i + 1}/${tasksToProcess.length}] ${task.title}`));
+                }
+                else {
+                    console.log(chalk.red(`✖ [${i + 1}/${tasksToProcess.length}] ${task.title}`));
+                }
+                console.error(chalk.gray(`  Error: ${error instanceof Error ? error.message : String(error)}`));
+                debug.error(`Writing task ${task.task_id} failed:`, error);
+                // Continue with next task
+            }
+        }
+        // ========================================
+        // PHASE 4: EDITING (Editor - NEW!)
+        // ========================================
+        console.log('');
+        console.log(chalk.blue('🎨 Phase 4: Editing & Finalization'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(chalk.dim('Running Editor agent to generate executive summary and finalize report'));
+        console.log('');
+        let executiveSummary = '';
+        if (useSpinner) {
+            spinner.start('Generating executive summary and polishing report...');
+        }
+        else {
+            console.log(chalk.blue('Generating executive summary and polishing report...'));
+        }
+        try {
+            debug.agentStart('editor', { sectionCount: toolContext.reportSections.size });
+            const editorAgent = compileAgent(createEditorAgent(promptsDir));
+            // Editor needs memory recall and report writing
+            const editorToolNames = ['memory_recall', 'memory_list', 'memory_search', 'report_write', 'web_search', 'web_fetch'];
+            const editorTools = allTools.filter((t) => editorToolNames.includes(t.name));
+            const editorWithTools = { ...editorAgent, tools: editorTools };
+            const editorWorkflow = {
+                name: 'limo-editor',
+                graph: createSequenceNode([createStepNode(editorWithTools)]),
+                defaultModel: { adapter: llmAdapter }
+            };
+            debug.debug('Running editor workflow...');
+            // Prepare context for Editor
+            const editorContext = {
+                projectName: path.basename(workspaceRoot),
+                taskCount: tasksToProcess.length,
+                sectionCount: toolContext.reportSections.size,
+                diagramCount: toolContext.diagrams.size,
+                promptsDir,
+                reportLanguage: options.lang || 'English'
+            };
+            const editorResult = await runWorkflow(editorWorkflow, editorContext);
+            debug.agentEnd('editor', { summaryGenerated: !!editorResult.summaryGenerated });
+            // Extract executive summary from report sections
+            // Editor should have created a section with id "executive_summary"
+            const execSummarySection = toolContext.reportSections.get('executive_summary');
+            if (execSummarySection) {
+                executiveSummary = execSummarySection;
+                // Remove from sections map so it doesn't appear twice
+                toolContext.reportSections.delete('executive_summary');
+            }
+            if (useSpinner) {
+                spinner.succeed(chalk.green('✓ Executive summary generated'));
+            }
+            else {
+                console.log(chalk.green('✓ Executive summary generated'));
+            }
+        }
+        catch (error) {
+            console.error(chalk.yellow('⚠ Editor phase failed, continuing without executive summary'));
+            console.error(chalk.gray(`  Error: ${error instanceof Error ? error.message : String(error)}`));
+            debug.error('Editor failed:', error);
+            // Continue without executive summary
+        }
+        console.log('');
+        console.log(chalk.blue('📝 Generating Final Report'));
+        console.log(chalk.gray('─'.repeat(50)));
+        // Combine all report sections into report.md using MarkdownGenerator
+        if (useSpinner) {
+            spinner.start('Combining report sections...');
+        }
+        else {
+            console.log(chalk.blue('Combining report sections...'));
+        }
+        // Import MarkdownGenerator
+        const { MarkdownGenerator, extractTitle, countAllFindings } = await import('../report/markdownGenerator.js');
+        const generator = new MarkdownGenerator();
+        // Build report sections with associated diagrams
+        const sections = [];
+        for (const [sectionId, content] of toolContext.reportSections) {
+            // Find diagrams for this section
+            const sectionDiagrams = [];
+            for (const [diagramId, diagram] of toolContext.diagrams) {
+                if (diagram.metadata?.sectionId === sectionId) {
+                    sectionDiagrams.push(diagram);
+                }
+            }
+            sections.push({
+                id: sectionId,
+                title: extractTitle(content),
+                content,
+                diagrams: sectionDiagrams.length > 0 ? sectionDiagrams : undefined
+            });
+        }
+        // Collect orphaned diagrams (not associated with any section)
+        const orphanedDiagrams = [];
+        for (const [diagramId, diagram] of toolContext.diagrams) {
+            const hasSection = diagram.metadata?.sectionId;
+            if (!hasSection) {
+                orphanedDiagrams.push(diagram);
+            }
+        }
+        // If there are orphaned diagrams, add them as a separate section
+        if (orphanedDiagrams.length > 0) {
+            const { embedDiagramInMarkdown } = await import('../report/diagrams.js');
+            const diagramMarkdown = orphanedDiagrams.map(d => embedDiagramInMarkdown(d)).join('\n\n');
+            sections.push({
+                id: 'diagrams',
+                title: 'Diagrams',
+                content: `## Diagrams\n\n${diagramMarkdown}`,
+                diagrams: undefined // Already embedded in content
+            });
+        }
+        // Build report metadata
+        const reportMetadata = {
+            id: analysisId,
+            title: `Analysis Report - ${path.basename(workspaceRoot)}`,
+            generatedAt: new Date(),
+            projectPath: workspaceRoot,
+            aiModel: model,
+            modules: modules, // Already string[]
+            statistics: {
+                totalSections: sections.length,
+                totalDiagrams: toolContext.diagrams.size,
+                totalFindings: countAllFindings(sections)
+            }
+        };
+        // Build complete report object
+        const report = {
+            metadata: reportMetadata,
+            executiveSummary, // From Editor agent
+            sections
+        };
+        // Generate markdown using MarkdownGenerator
+        const reportContent = generator.generate(report);
+        await fs.writeFile(path.join(reportDir, 'report.md'), reportContent);
+        if (useSpinner) {
+            spinner.succeed(chalk.green('✓ Final report generated'));
+        }
+        else {
+            console.log(chalk.green('✓ Final report generated'));
+        }
+        console.log('');
+        console.log(chalk.green('✓ Analysis Complete!'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(chalk.cyan('Report:'), path.join(reportDir, 'report.md'));
+        console.log(chalk.cyan('Plan:'), path.join(reportDir, 'plan.json'));
+        console.log(chalk.gray('─'.repeat(50)));
+        // Update manifest with completion status
+        const completedManifest = {
+            ...manifest,
+            updatedAt: new Date().toISOString(),
+            completedAt: new Date().toISOString(),
+            status: 'completed',
+            hasReport: true,
+            hasSession: false // CLI doesn't use session.json
+        };
+        await fs.writeFile(path.join(reportDir, 'manifest.json'), JSON.stringify(completedManifest, null, 2));
+        debug.debug('Manifest updated to completed status');
+        // Cleanup LLM adapter
+        debug.debug('Cleaning up LLM adapter...');
+        await llmAdapter.cleanup();
+        debug.success('Cleanup complete');
+    }
+    catch (error) {
+        if (useSpinner && spinner) {
+            spinner.fail(chalk.red('Analysis failed'));
+        }
+        else {
+            console.log(chalk.red('✖ Analysis failed'));
+        }
+        throw error;
+    }
+}
+function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(7)}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { analyze } from './commands/analyze.js';
+import chalk from 'chalk';
+const program = new Command();
+program
+    .name('limo')
+    .description('Limo CLI - AI-powered codebase analysis tool')
+    .version('0.1.0');
+program
+    .command('analyze')
+    .description('Analyze a codebase and generate a comprehensive report')
+    .argument('[path]', 'Path to the codebase to analyze', '.')
+    .option('-o, --output <path>', 'Output directory for the report', '.limo')
+    .option('--model <model>', 'AI model to use', 'claude-opus-4.6')
+    .option('--lang <language>', 'Report language (English, 简体中文, 日本語, Español, Français, Deutsch)', '简体中文')
+    .option('--modules <modules>', 'Comma-separated list of modules to analyze', 'architecture,dependencies,code-quality,security,database,testing,migration')
+    .option('--verbose', 'Show AI thinking process in real-time', false)
+    .option('-d, --debug', 'Enable debug mode with verbose logging', false)
+    .option('--debug-api', 'Enable API request/response logging', false)
+    .action(async (path, options) => {
+    try {
+        // Set global debug mode
+        if (options.debug || options.debugApi) {
+            process.env.LIMO_DEBUG = 'true';
+        }
+        if (options.debugApi) {
+            process.env.LIMO_DEBUG_API = 'true';
+        }
+        await analyze(path, options);
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        if (options.debug) {
+            console.error(chalk.gray('\nStack trace:'));
+            console.error(error);
+        }
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/report/diagrams.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Diagram rendering utilities for CLI reports
+ */
+/**
+ * Diagram definition
+ */
+export interface DiagramDefinition {
+    id: string;
+    title: string;
+    description?: string;
+    format: 'svg' | 'dot' | 'mermaid';
+    source: string;
+    relatedFiles?: string[];
+    metadata?: {
+        nodeCount?: number;
+        edgeCount?: number;
+        generatedAt?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * Embeds a diagram in Markdown format
+ *
+ * For SVG diagrams, embeds as base64 data URI image for universal compatibility.
+ * For DOT/Mermaid format, embeds as code blocks for external rendering.
+ */
+export declare function embedDiagramInMarkdown(diagram: DiagramDefinition): string;