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

package/README.md

@@ -0,0 +1,238 @@
+# Limo CLI
+
+Command-line interface for Limo - AI-powered codebase analysis and migration planning tool.
+
+## Features
+
+- 🤖 **Multi-Agent Analysis** - Planner, Analyst, Writer, and Editor agents collaborate
+- 📊 **Professional Reports** - Executive summaries, diagrams, and detailed analysis
+- 🎯 **LIMO.md Support** - Customize analysis scope with LIMO.md configuration
+- 📈 **Semantic Diagrams** - Type-safe architecture diagrams with nodes and edges
+- 🌍 **Multi-language** - Supports English, 简体中文, 日本語, and more
+
+## Installation
+
+```bash
+npm install
+npm run build
+```
+
+## Usage
+
+### Basic Analysis
+
+```bash
+node dist/index.js analyze /path/to/project
+```
+
+### With Options
+
+```bash
+# Specify language
+node dist/index.js analyze /path/to/project --lang 简体中文
+
+# Verbose mode (show AI thinking)
+node dist/index.js analyze /path/to/project --verbose
+
+# Custom modules
+node dist/index.js analyze /path/to/project --modules architecture,security,dependencies
+
+# Custom output directory
+node dist/index.js analyze /path/to/project --output .limo-reports
+```
+
+## LIMO.md Configuration
+
+Create a `LIMO.md` file in your project root to customize the analysis:
+
+```markdown
+# LIMO Configuration
+
+## Focus Areas
+- security
+- architecture
+- dependencies
+
+## Exclude
+- testing
+- migration
+
+## Analysis Scope
+Focus on the authentication and authorization modules.
+
+## Company Context
+This is a financial institution with strict security requirements.
+
+## Constraints
+- Must use Java 17
+- Cannot use external dependencies
+- Must maintain backward compatibility
+```
+
+The CLI will automatically detect and parse LIMO.md, adjusting the analysis accordingly.
+
+## Architecture
+
+### 4-Phase Analysis Workflow
+
+1. **Planning** - Planner creates comprehensive analysis plan
+2. **Analysis** - Analyst performs deep code exploration
+3. **Writing** - Writer generates detailed report sections
+4. **Editing** - Editor creates executive summary and finalizes report
+
+### Report Structure
+
+```markdown
+# Analysis Report - Project Name
+
+**Generated**: February 21, 2026, 12:00:00 AM
+**Project**: /path/to/project
+**AI Model**: claude-opus-4.6
+**Analysis Modules**: architecture, security, dependencies
+
+**Statistics**:
+- Report Sections: 15
+- Diagrams: 8
+- Key Findings: 42
+
+---
+
+## 📊 Executive Summary
+
+[Overall analysis summary...]
+
+---
+
+## Architecture Analysis
+
+[Detailed content...]
+
+![Architecture Diagram](data:image/svg+xml;base64,...)
+
+*Diagram: System architecture showing main components*
+
+---
+
+## Security Analysis
+
+[Detailed content...]
+
+![Security Flow](data:image/svg+xml;base64,...)
+
+*Diagram: Authentication and authorization flow*
+```
+
+## Report Output
+
+Reports are saved to `.limo/reports/{uuid}/`:
+- `report.md` - Final markdown report
+- `memory.json` - Analysis memories
+- `plan.json` - Analysis plan
+
+## Development
+
+### Build
+
+```bash
+npm run build
+```
+
+### Watch Mode
+
+```bash
+npm run watch
+```
+
+### Debug
+
+```bash
+# Enable debug logging
+LIMO_DEBUG=true node dist/index.js analyze /path/to/project
+
+# Enable API debug logging
+LIMO_DEBUG_API=true node dist/index.js analyze /path/to/project
+```
+
+## Requirements
+
+- Node.js 18+
+- GitHub Copilot subscription (for AI analysis)
+- `gh` CLI installed and authenticated
+
+## Project Structure
+
+```
+src/
+├── index.ts              # CLI entry point
+├── commands/
+│   └── analyze.ts        # Main analysis command
+├── agents/
+│   ├── planner.ts        # Planning agent
+│   ├── analyst.ts        # Analysis agent
+│   ├── writer.ts         # Writing agent
+│   └── editor.ts         # Editing agent
+├── tools/
+│   ├── index.ts          # Core tools
+│   ├── extended.ts       # Extended tools
+│   └── additional.ts     # Additional tools
+├── report/
+│   ├── markdownGenerator.ts    # Report generation
+│   ├── diagrams.ts             # Diagram embedding
+│   └── graphCompiler.ts        # Graph to SVG compilation
+├── utils/
+│   ├── debug.ts                # Debug utilities
+│   └── limoConfigParser.ts     # LIMO.md parser
+└── types/
+    └── graphSemantics.ts       # Graph type definitions
+
+prompts/
+├── planner.md            # Planner agent prompt
+├── analyst.md            # Analyst agent prompt
+├── writer.md             # Writer agent prompt
+└── editor.md             # Editor agent prompt
+```
+
+## Key Features
+
+### Semantic Diagrams
+
+Uses type-safe graph semantics for diagrams:
+
+```typescript
+{
+  "diagram_id": "architecture",
+  "title": "System Architecture",
+  "nodes": [
+    { "id": "web", "label": "Web Layer", "type": "layer" },
+    { "id": "api", "label": "API Layer", "type": "layer" },
+    { "id": "data", "label": "Data Layer", "type": "layer" }
+  ],
+  "edges": [
+    { "from": "web", "to": "api", "type": "calls" },
+    { "from": "api", "to": "data", "type": "calls" }
+  ]
+}
+```
+
+Available node types: `component`, `layer`, `system`, `data`, `process`, `actor`, `external`
+Available edge types: `dependency`, `calls`, `uses`, `contains`, `inherits`, `implements`, `data_flow`, `control_flow`, `stored_in`, `manages`
+
+### LIMO.md Parser
+
+Automatically parses LIMO.md with smart detection:
+- **Structured Markdown** - Sections with headings and lists
+- **Natural Language** - Keywords like "focus on", "skip", "must"
+- **Module Validation** - Validates against known modules
+- **Constraints Extraction** - Finds "must", "cannot", "should not" statements
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions welcome! Please open an issue or PR.
+
+---
+
+**Built with ❤️ using GitHub Copilot and Claude**

package/dist/agents/analyst.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Analyst Agent - Performs deep code analysis based on plan tasks
+ * Using declarative TSX syntax
+ */
+import { z } from 'zod';
+import { type AgentNode } from '@limo-labs/deity';
+declare const AnalystInputSchema: z.ZodObject<{
+    task: z.ZodAny;
+    workspaceRoot: z.ZodString;
+    promptsDir: z.ZodString;
+}, z.core.$strip>;
+type AnalystInput = z.infer<typeof AnalystInputSchema>;
+declare const AnalystOutputSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    success: z.ZodBoolean;
+    memoriesCreated: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type AnalystOutput = z.infer<typeof AnalystOutputSchema>;
+/**
+ * Create Analyst Agent using declarative TSX syntax
+ */
+export declare function createAnalystAgent(promptsDir: string): AgentNode<AnalystInput, AnalystOutput>;
+export {};

package/dist/agents/analyst.js

@@ -0,0 +1,128 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@limo-labs/deity/jsx-runtime";
+/**
+ * Analyst Agent - Performs deep code analysis based on plan tasks
+ * Using declarative TSX syntax
+ */
+import { z } from 'zod';
+import { Agent, Prompt, System, User, Result, Validate, Retry } from '@limo-labs/deity';
+import { countToolCalls } from '@limo-labs/deity';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Input schema
+const AnalystInputSchema = z.object({
+    task: z.any(), // Task object from plan
+    workspaceRoot: z.string(),
+    promptsDir: z.string()
+});
+// Output schema
+const AnalystOutputSchema = z.object({
+    taskId: z.string(),
+    success: z.boolean(),
+    memoriesCreated: z.number(),
+    error: z.string().optional()
+});
+/**
+ * Build system prompt by loading from prompts directory
+ */
+async function buildSystemPrompt(promptsDir) {
+    const promptPath = path.join(promptsDir, 'analyst.md');
+    // Verify prompt file exists before reading
+    try {
+        await fs.access(promptPath);
+    }
+    catch (error) {
+        throw new Error(`Critical: Analyst prompt file not found at ${promptPath}\n` +
+            `Please ensure prompts are copied from VSCode extension or run 'npm run sync-prompts'`);
+    }
+    return await fs.readFile(promptPath, 'utf-8');
+}
+/**
+ * Build user message with analysis task details
+ */
+function buildUserMessage(ctx) {
+    const { task, workspaceRoot } = ctx.inputs;
+    return `**Analysis Task**: ${task.title}
+
+**Module**: ${task.module}
+
+**Description**: ${task.description}
+
+**Project Path**: ${workspaceRoot}
+
+**Required Memory Keys** (suggestions - create these or similar):
+${(task.memory_keys_to_generate || []).map((k) => `- ${k}`).join('\n')}
+
+**Required Outputs**:
+- Minimum word count: ${task.required_outputs?.min_word_count || 600}
+- Code examples: ${task.required_outputs?.code_examples || 2}
+- Diagrams: ${task.required_outputs?.diagrams || 0}
+
+**Instructions**:
+1. Use file_list to discover relevant files in the project
+2. Use file_read to examine key files (pom.xml, source code, config files)
+3. Extract and analyze: architecture patterns, tech stack, code quality, dependencies
+4. Store ALL findings using memory_store with appropriate importance levels (7-10 for key discoveries)
+5. Create ${(task.memory_keys_to_generate || []).length} or more detailed memory entries
+
+Focus on discovering actual project specifics - file names, class names, versions, patterns from THIS project.
+
+**Task Completion**: Your analysis is complete when you have stored ${(task.memory_keys_to_generate || []).length} or more memory entries with detailed findings.`;
+}
+/**
+ * Extract analyst output from LLM result
+ */
+function extractAnalystOutput(ctx, llmResult) {
+    // Count successful memory_store tool calls using utility
+    const memoriesCreated = countToolCalls(llmResult, 'memory_store', (result) => {
+        return result?.success === true;
+    });
+    const taskId = ctx.inputs.task.task_id;
+    if (memoriesCreated === 0) {
+        return {
+            taskId,
+            success: false,
+            memoriesCreated: 0,
+            error: 'Analyst did not store any memories - no analysis was performed'
+        };
+    }
+    return {
+        taskId,
+        success: true,
+        memoriesCreated
+    };
+}
+/**
+ * Create Analyst Agent using declarative TSX syntax
+ */
+export function createAnalystAgent(promptsDir) {
+    return (_jsxs(Agent, { id: "analyst", input: AnalystInputSchema, output: AnalystOutputSchema, children: [_jsxs(Prompt, { children: [_jsx(System, { children: async () => buildSystemPrompt(promptsDir) }), _jsx(User, { children: (ctx) => buildUserMessage(ctx) })] }), _jsx(Result, { children: (ctx, llmResult) => extractAnalystOutput(ctx, llmResult) }), _jsx(Validate, { children: (output, ctx) => {
+                    const { task } = ctx.inputs;
+                    const typedOutput = output;
+                    const rules = [];
+                    if (!typedOutput.success) {
+                        if (!typedOutput.error) {
+                            rules.push({
+                                check: false,
+                                error: 'Failed analysis must include error message'
+                            });
+                        }
+                        return { rules };
+                    }
+                    // Check if memories were created
+                    if (typedOutput.memoriesCreated === 0) {
+                        rules.push({
+                            check: false,
+                            error: 'Analyst must store findings in memory'
+                        });
+                    }
+                    // Check if required memory keys were generated
+                    const requiredKeys = task.memory_keys_to_generate || [];
+                    if (requiredKeys.length > 0 && typedOutput.memoriesCreated < requiredKeys.length) {
+                        rules.push({
+                            check: false,
+                            error: `Expected at least ${requiredKeys.length} memory entries for keys: ${requiredKeys.join(', ')}`
+                        });
+                    }
+                    return { rules };
+                } }), _jsx(Retry, { maxAttempts: 2, feedbackOnError: true })] }));
+}

package/dist/agents/editor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Editor Agent - Generates executive summary and finalizes report
+ * Using declarative TSX syntax
+ */
+import { z } from 'zod';
+import { type AgentNode } from '@limo-labs/deity';
+declare const EditorInputSchema: z.ZodObject<{
+    projectName: z.ZodString;
+    taskCount: z.ZodNumber;
+    sectionCount: z.ZodNumber;
+    diagramCount: z.ZodNumber;
+    promptsDir: z.ZodString;
+    reportLanguage: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type EditorInput = z.infer<typeof EditorInputSchema>;
+declare const EditorOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    summaryGenerated: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type EditorOutput = z.infer<typeof EditorOutputSchema>;
+/**
+ * Create Editor Agent using declarative TSX syntax
+ */
+export declare function createEditorAgent(promptsDir: string): AgentNode<EditorInput, EditorOutput>;
+export {};

package/dist/agents/editor.js

@@ -0,0 +1,157 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@limo-labs/deity/jsx-runtime";
+/**
+ * Editor Agent - Generates executive summary and finalizes report
+ * Using declarative TSX syntax
+ */
+import { z } from 'zod';
+import { Agent, Prompt, System, User, Result, Validate, Retry } from '@limo-labs/deity';
+import { extractAllToolResults } from '@limo-labs/deity';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Input schema
+const EditorInputSchema = z.object({
+    projectName: z.string(),
+    taskCount: z.number(),
+    sectionCount: z.number(),
+    diagramCount: z.number(),
+    promptsDir: z.string(),
+    reportLanguage: z.string().optional()
+});
+// Output schema
+const EditorOutputSchema = z.object({
+    success: z.boolean(),
+    summaryGenerated: z.boolean(),
+    error: z.string().optional()
+});
+/**
+ * Build system prompt by loading from prompts directory
+ */
+async function buildSystemPrompt(promptsDir, reportLanguage) {
+    const promptPath = path.join(promptsDir, 'editor.md');
+    // Verify prompt file exists before reading
+    try {
+        await fs.access(promptPath);
+    }
+    catch (error) {
+        throw new Error(`Critical: Editor prompt file not found at ${promptPath}\n` +
+            `Please ensure prompts are copied from VSCode extension or run 'npm run sync-prompts'`);
+    }
+    let systemPrompt = await fs.readFile(promptPath, 'utf-8');
+    // Inject language instruction if reportLanguage is provided
+    if (reportLanguage && reportLanguage !== 'English') {
+        const languageInstruction = `
+
+## CRITICAL: Output Language Requirement
+
+**YOU MUST write ALL content in ${reportLanguage}.**
+
+This applies to:
+- Executive summary
+- Section titles and headings
+- All descriptions and findings
+- Recommendations
+
+IMPORTANT Guidelines:
+1. Write naturally in ${reportLanguage}, not as a direct translation
+2. Use appropriate technical terminology for ${reportLanguage}
+3. Preserve code snippets and technical identifiers in their original language
+4. Memory keys must remain in English (system requirement)
+
+`;
+        systemPrompt = systemPrompt + languageInstruction;
+    }
+    return systemPrompt;
+}
+/**
+ * Build user message with editing task details
+ */
+function buildUserMessage(ctx) {
+    const { projectName, taskCount, sectionCount, diagramCount } = ctx.inputs;
+    return `**Report Finalization Task**: Generate Executive Summary
+
+**Project**: ${projectName}
+**Analysis Scope**:
+- ${taskCount} analysis tasks completed
+- ${sectionCount} report sections generated
+- ${diagramCount} diagrams created
+
+**Your Responsibilities**:
+
+1. **Generate Executive Summary** (MANDATORY)
+   - Recall all key memories to understand the full analysis
+   - Create a comprehensive overview (200-400 words) covering:
+     * What the project is (brief description)
+     * Key findings from the analysis
+     * Architecture highlights and patterns
+     * Main recommendations for improvement
+   - Use section_id "executive_summary" when calling report_write
+
+2. **Review Report Quality**
+   - Ensure all sections are cohesive
+   - Check that findings are actionable
+   - Verify diagrams support the narrative
+
+**Instructions**:
+1. Use memory_list or memory_search to discover all analysis findings
+2. Recall key memories across different areas (architecture, code quality, testing, etc.)
+3. Synthesize findings into a coherent executive summary
+4. MUST call report_write with section_id "executive_summary" (THIS IS MANDATORY!)
+
+The executive summary should give readers a clear understanding of:
+- What was analyzed
+- What was discovered
+- What should be done next
+
+Write based on ACTUAL analysis findings - be specific and actionable.`;
+}
+/**
+ * Extract editor output from LLM result
+ */
+function extractEditorOutput(_ctx, llmResult) {
+    // Extract all report_write results using utility
+    const allReports = extractAllToolResults(llmResult, 'report_write', {
+        unwrap: true,
+        required: false
+    });
+    if (allReports.length === 0) {
+        return {
+            success: false,
+            summaryGenerated: false,
+            error: 'Editor did not call report_write - no executive summary was generated'
+        };
+    }
+    // Check if executive_summary section was created
+    const execSummaryCreated = allReports.some((report) => report?.section_id === 'executive_summary');
+    return {
+        success: true,
+        summaryGenerated: execSummaryCreated
+    };
+}
+/**
+ * Create Editor Agent using declarative TSX syntax
+ */
+export function createEditorAgent(promptsDir) {
+    return (_jsxs(Agent, { id: "editor", input: EditorInputSchema, output: EditorOutputSchema, children: [_jsxs(Prompt, { children: [_jsx(System, { children: async (ctx) => {
+                            const reportLanguage = ctx.inputs.reportLanguage;
+                            return buildSystemPrompt(promptsDir, reportLanguage);
+                        } }), _jsx(User, { children: (ctx) => buildUserMessage(ctx) })] }), _jsx(Result, { children: (ctx, llmResult) => extractEditorOutput(ctx, llmResult) }), _jsx(Validate, { children: (output) => {
+                    const typedOutput = output;
+                    const rules = [];
+                    if (!typedOutput.success) {
+                        if (!typedOutput.error) {
+                            rules.push({
+                                check: false,
+                                error: 'Failed task must include error message'
+                            });
+                        }
+                        return { rules };
+                    }
+                    if (!typedOutput.summaryGenerated) {
+                        rules.push({
+                            check: false,
+                            error: 'Editor must generate executive summary (section_id: "executive_summary")'
+                        });
+                    }
+                    return { rules };
+                } }), _jsx(Retry, { maxAttempts: 2, feedbackOnError: true })] }));
+}

package/dist/agents/planner-validator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Planner Validator - Validates that planner created a comprehensive analysis plan
+ */
+import type { Validator, ValidationResult, LLMLoopState, ExecutionContext } from '@limo-labs/deity';
+export declare class PlannerValidator implements Validator {
+    validate(ctx: ExecutionContext, loopState: LLMLoopState): Promise<ValidationResult>;
+}