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

package/dist/agents/planner-validator.js

@@ -0,0 +1,125 @@
+/**
+ * Planner Validator - Validates that planner created a comprehensive analysis plan
+ */
+export class PlannerValidator {
+    async validate(ctx, loopState) {
+        const inputs = ctx.inputs;
+        // 1. Check if planning_create was called
+        const allToolCalls = [
+            ...loopState.toolCallsThisRound,
+            // Also check previous rounds from messages
+            ...loopState.messages
+                .filter((msg) => msg.role === 'assistant' && msg.toolCalls)
+                .flatMap((msg) => msg.toolCalls || [])
+        ];
+        const planningCall = allToolCalls.find(tc => tc.name === 'planning_create');
+        if (!planningCall) {
+            return {
+                valid: false,
+                feedback: `⚠️ CRITICAL: You must call the planning_create tool to create the analysis plan.
+
+**Required Steps**:
+1. Call file_list with pattern "**/*" to scan project files
+2. Store project insights using memory_store
+3. Call planning_create with comprehensive task list
+
+Please follow the workflow and call planning_create to complete this task.`
+            };
+        }
+        const planArgs = planningCall.arguments;
+        // 2. Check plan has tasks
+        if (!planArgs.tasks || planArgs.tasks.length === 0) {
+            return {
+                valid: false,
+                feedback: `⚠️ QUALITY ISSUE: The planning_create tool was called but with no tasks.
+
+Please create a comprehensive analysis plan with multiple tasks covering all required modules.`
+            };
+        }
+        // 3. Check minimum task count based on project complexity
+        const minTasksByComplexity = {
+            small: 5,
+            medium: 10,
+            large: 15
+        };
+        const complexity = planArgs.project_complexity || 'medium';
+        const requiredMin = minTasksByComplexity[complexity] || 10;
+        if (planArgs.tasks.length < requiredMin) {
+            return {
+                valid: false,
+                feedback: `⚠️ QUALITY ISSUE: Your plan has only ${planArgs.tasks.length} tasks, but ${complexity} projects require at least ${requiredMin} tasks.
+
+**Please improve your plan**:
+- Scan the project structure with file_list
+- Identify all major components/packages
+- Create specific tasks for each area (e.g., "Analyze Spring MVC controllers", "Review database schema")
+- Each module should have 2-3 detailed tasks
+
+Call planning_create again with a more comprehensive task list.`
+            };
+        }
+        // 4. Check for estimated_files (must have scanned project)
+        if (!planArgs.estimated_files || planArgs.estimated_files === 0) {
+            return {
+                valid: false,
+                feedback: `⚠️ CRITICAL: You must call file_list to scan the project and get the actual file count.
+
+**Required**:
+1. Call file_list with pattern "**/*"
+2. Use the ACTUAL file count in planning_create
+3. Don't guess the file count!
+
+Please scan the project first, then call planning_create with accurate data.`
+            };
+        }
+        // 5. Check for trivial tasks
+        const trivialPatterns = ['verify', 'check setup', 'initialize', 'validate', 'confirm'];
+        const trivialTasks = planArgs.tasks.filter((task) => trivialPatterns.some(pattern => task.title.toLowerCase().includes(pattern)));
+        if (trivialTasks.length > planArgs.tasks.length * 0.3) {
+            return {
+                valid: false,
+                feedback: `⚠️ QUALITY ISSUE: ${trivialTasks.length}/${planArgs.tasks.length} tasks appear to be trivial setup/verification tasks.
+
+**Please create meaningful analysis tasks**:
+- Focus on actual code analysis, not setup
+- Each task should analyze specific files/packages
+- Tasks should produce substantial documentation (600-1200 words)
+
+Examples of good tasks:
+- "Analyze Spring MVC controller architecture in owner/ package"
+- "Review JPA entity relationships and database schema"
+- "Document REST API endpoints and request/response patterns"
+
+Please revise your plan with more substantive analysis tasks.`
+            };
+        }
+        // 6. Check task descriptions are specific
+        const vagueDescriptions = planArgs.tasks.filter((task) => {
+            const desc = (task.description || '').toLowerCase();
+            return desc.length < 50 ||
+                (!desc.includes('file') && !desc.includes('package') && !desc.includes('class'));
+        });
+        if (vagueDescriptions.length > planArgs.tasks.length * 0.4) {
+            return {
+                valid: false,
+                feedback: `⚠️ QUALITY ISSUE: ${vagueDescriptions.length}/${planArgs.tasks.length} tasks have vague descriptions.
+
+**Task descriptions should be specific**:
+- Mention which files/packages to analyze
+- Describe what patterns to look for
+- Explain what the task should document
+
+Example:
+❌ Bad: "Analyze architecture"
+✅ Good: "Analyze Spring MVC architecture in src/main/java/owner/ package, focusing on controller-service-repository pattern"
+
+Please improve task descriptions to be more specific and actionable.`
+            };
+        }
+        // All validations passed!
+        return {
+            valid: true,
+            message: `✅ Analysis plan successfully validated with ${planArgs.tasks.length} comprehensive tasks for ${complexity} project.`
+        };
+    }
+}

package/dist/agents/planner.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Planner Agent - Creates comprehensive analysis plans
+ * Using declarative TSX syntax
+ */
+import { z } from 'zod';
+import { type AgentNode } from '@limo-labs/deity';
+declare const PlannerInputSchema: z.ZodObject<{
+    workspaceRoot: z.ZodString;
+    modules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    limoConfig: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type PlannerInput = z.infer<typeof PlannerInputSchema>;
+declare const PlannerOutputSchema: z.ZodObject<{
+    project_complexity: z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        large: "large";
+    }>;
+    estimated_loc: z.ZodNumber;
+    estimated_files: z.ZodNumber;
+    tasks: z.ZodArray<z.ZodObject<{
+        task_id: z.ZodString;
+        module: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        required_outputs: z.ZodObject<{
+            report_sections: z.ZodNumber;
+            code_examples: z.ZodNumber;
+            diagrams: z.ZodNumber;
+            min_word_count: z.ZodNumber;
+        }, z.core.$strip>;
+        memory_keys_to_generate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dependencies: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>>;
+    total_tasks: z.ZodNumber;
+    estimated_duration_minutes: z.ZodOptional<z.ZodNumber>;
+    created_at: z.ZodString;
+    summary: z.ZodObject<{
+        tasks_by_module: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        total_sections_expected: z.ZodNumber;
+        total_diagrams_expected: z.ZodNumber;
+        total_words_expected: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type PlannerOutput = z.infer<typeof PlannerOutputSchema>;
+/**
+ * Create Planner Agent using declarative TSX syntax
+ */
+export declare function createPlannerAgent(promptsDir: string): AgentNode<PlannerInput, PlannerOutput>;
+export {};

package/dist/agents/planner.js

@@ -0,0 +1,186 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@limo-labs/deity/jsx-runtime";
+/**
+ * Planner Agent - Creates comprehensive analysis plans
+ * Using declarative TSX syntax
+ */
+import { z } from 'zod';
+import { Agent, Prompt, System, User, Result } from '@limo-labs/deity';
+import { extractLastToolResult } from '@limo-labs/deity';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { PlannerValidator } from './planner-validator.js';
+// Input schema
+const PlannerInputSchema = z.object({
+    workspaceRoot: z.string(),
+    modules: z.array(z.string()).optional(),
+    limoConfig: z.any().optional() // LIMO.md configuration
+});
+// Output schema (matches AnalysisPlan)
+const PlannerOutputSchema = z.object({
+    project_complexity: z.enum(['small', 'medium', 'large']),
+    estimated_loc: z.number(),
+    estimated_files: z.number(),
+    tasks: z.array(z.object({
+        task_id: z.string(),
+        module: z.string(),
+        title: z.string(),
+        description: z.string(),
+        required_outputs: z.object({
+            report_sections: z.number(),
+            code_examples: z.number(),
+            diagrams: z.number(),
+            min_word_count: z.number()
+        }),
+        memory_keys_to_generate: z.array(z.string()).optional(),
+        dependencies: z.array(z.string()),
+        status: z.enum(['pending', 'in_progress', 'completed', 'failed'])
+    })),
+    total_tasks: z.number(),
+    estimated_duration_minutes: z.number().optional(),
+    created_at: z.string(),
+    summary: z.object({
+        tasks_by_module: z.record(z.string(), z.number()),
+        total_sections_expected: z.number(),
+        total_diagrams_expected: z.number(),
+        total_words_expected: z.number()
+    })
+});
+/**
+ * Build system prompt by loading from prompts directory
+ */
+async function buildSystemPrompt(promptsDir) {
+    const promptPath = path.join(promptsDir, 'planner.md');
+    // Verify prompt file exists before reading
+    try {
+        await fs.access(promptPath);
+    }
+    catch (error) {
+        throw new Error(`Critical: Planner 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 planning task details
+ */
+function buildUserMessage(ctx) {
+    const { workspaceRoot, modules, limoConfig } = ctx.inputs;
+    // Build comprehensive task message
+    const modulesText = modules && modules.length > 0
+        ? modules.join(', ')
+        : 'architecture, dependencies, code-quality, security, database, testing, migration';
+    let message = `**Planning Task**: Create comprehensive analysis plan
+
+**Project Path**: ${workspaceRoot}
+
+**Modules to Cover**: ${modulesText}
+`;
+    // NEW: Add LIMO.md-aware instructions
+    if (limoConfig) {
+        message += `\n**User-Provided LIMO.md Configuration**:\n`;
+        if (limoConfig.scopeDescription) {
+            message += `\n**Scope Description**: ${limoConfig.scopeDescription}\n`;
+        }
+        if (limoConfig.focusAreas && limoConfig.focusAreas.length > 0) {
+            message += `\n**Focus Areas**: ${limoConfig.focusAreas.join(', ')}\n`;
+        }
+        if (limoConfig.excludeModules && limoConfig.excludeModules.length > 0) {
+            message += `\n**Excluded Modules**: ${limoConfig.excludeModules.join(', ')}\n`;
+        }
+        if (limoConfig.privateContext) {
+            message += `\n**Private Context**:\n${limoConfig.privateContext}\n`;
+        }
+        if (limoConfig.constraints && limoConfig.constraints.length > 0) {
+            message += `\n**Constraints**:\n`;
+            limoConfig.constraints.forEach((c) => {
+                message += `- ${c}\n`;
+            });
+        }
+        message += `\n**Important**: Focus on the user's specified areas and apply their constraints to the analysis plan.\n`;
+    }
+    message += `
+**Required Steps**:
+
+1. **Scan Project** (MANDATORY):
+   - Call file_list with pattern "**/*" to get ALL project files
+   - This gives you the ACTUAL file count (not a guess!)
+   - Identify main directories and project structure
+
+2. **Identify Tech Stack**:
+   - Read key files: pom.xml, build.gradle, package.json, requirements.txt, etc.
+   - Determine frameworks, versions, build tools
+   - Store findings using memory_store
+
+3. **Assess Complexity**:
+   - Small (<50 files): 10-15 tasks
+   - Medium (50-200 files): 15-25 tasks
+   - Large (>200 files): 25-40 tasks`;
+    // Adaptive task count instruction based on LIMO config
+    if (limoConfig?.scopeDescription) {
+        message += `\n   - **Note**: User has limited scope, so fewer tasks may be appropriate\n`;
+    }
+    message += `
+4. **Create Detailed Tasks**:
+   - Cover all modules: ${modulesText}
+   - Each task must have: task_id, module, title, description, required_outputs, memory_keys_to_generate
+   - Be SPECIFIC in task descriptions (mention what files to analyze, what patterns to look for)
+
+5. **Call planning_create** (MANDATORY):
+   - Use ACTUAL estimated_files from your file_list scan
+   - Include ALL generated tasks
+   - Generate task titles and descriptions in ENGLISH
+
+⚠️ **CRITICAL REMINDER**: You MUST call the \`planning_create\` tool to complete this task successfully. Do not end your response without calling this tool! This is the ONLY way to complete the planning phase.
+
+**Quality Standards**:
+- Medium project (50-200 files) should have 15-25 tasks minimum
+- Tasks should be specific (e.g., "Analyze Spring MVC controllers in owner/ package")
+- Each task should produce 600-1200 words of analysis`;
+    return message;
+}
+/**
+ * Extract and normalize plan data from LLM result
+ */
+function extractPlanData(_ctx, llmResult) {
+    // Extract plan data using utility (handles toolCalls, messages, and response)
+    const planData = extractLastToolResult(llmResult, 'planning_create', {
+        unwrap: true,
+        required: true
+    });
+    // Validate plan data structure
+    if (!planData || !planData.tasks || !Array.isArray(planData.tasks)) {
+        throw new Error(`Invalid plan data structure: ${JSON.stringify(planData).substring(0, 200)}`);
+    }
+    // Normalize the plan data
+    const normalizedTasks = planData.tasks.map((task) => ({
+        ...task,
+        dependencies: task.dependencies || [],
+        status: task.status || 'pending'
+    }));
+    return {
+        project_complexity: planData.project_complexity || 'medium',
+        estimated_loc: planData.estimated_loc || 0,
+        estimated_files: planData.estimated_files || 0,
+        tasks: normalizedTasks,
+        total_tasks: normalizedTasks.length,
+        created_at: new Date().toISOString(),
+        summary: planData.summary || {
+            tasks_by_module: normalizedTasks.reduce((acc, task) => {
+                acc[task.module] = (acc[task.module] || 0) + 1;
+                return acc;
+            }, {}),
+            total_sections_expected: normalizedTasks.reduce((sum, t) => sum + (t.required_outputs?.report_sections || 1), 0),
+            total_diagrams_expected: normalizedTasks.reduce((sum, t) => sum + (t.required_outputs?.diagrams || 0), 0),
+            total_words_expected: normalizedTasks.reduce((sum, t) => sum + (t.required_outputs?.min_word_count || 500), 0)
+        }
+    };
+}
+/**
+ * Create Planner Agent using declarative TSX syntax
+ */
+export function createPlannerAgent(promptsDir) {
+    return (_jsxs(Agent, { id: "planner", input: PlannerInputSchema, output: PlannerOutputSchema, loopConfig: {
+            maxToolRounds: 15, // Increase from default 10 to allow more exploration
+            timeout: 180000 // 3 minutes timeout
+        }, loopValidator: new PlannerValidator(), children: [_jsxs(Prompt, { children: [_jsx(System, { children: async () => buildSystemPrompt(promptsDir) }), _jsx(User, { children: (ctx) => buildUserMessage(ctx) })] }), _jsx(Result, { children: (ctx, llmResult) => extractPlanData(ctx, llmResult) })] }));
+}

package/dist/agents/writer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Writer Agent - Generates report sections based on analysis
+ * Using declarative TSX syntax
+ */
+import { z } from 'zod';
+import { type AgentNode } from '@limo-labs/deity';
+declare const WriterInputSchema: z.ZodObject<{
+    task: z.ZodAny;
+    promptsDir: z.ZodString;
+    reportLanguage: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type WriterInput = z.infer<typeof WriterInputSchema>;
+declare const WriterOutputSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    sectionId: z.ZodString;
+    success: z.ZodBoolean;
+    wordCount: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type WriterOutput = z.infer<typeof WriterOutputSchema>;
+/**
+ * Create Writer Agent using declarative TSX syntax
+ */
+export declare function createWriterAgent(promptsDir: string): AgentNode<WriterInput, WriterOutput>;
+export {};

package/dist/agents/writer.js

@@ -0,0 +1,164 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@limo-labs/deity/jsx-runtime";
+/**
+ * Writer Agent - Generates report sections based on analysis
+ * Using declarative TSX syntax
+ */
+import { z } from 'zod';
+import { Agent, Prompt, System, User, Result, Validate, Retry } from '@limo-labs/deity';
+import { extractLastToolResult } from '@limo-labs/deity';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Input schema
+const WriterInputSchema = z.object({
+    task: z.any(), // Task object from plan
+    promptsDir: z.string(),
+    reportLanguage: z.string().optional()
+});
+// Output schema
+const WriterOutputSchema = z.object({
+    taskId: z.string(),
+    sectionId: z.string(),
+    success: z.boolean(),
+    wordCount: z.number().optional(),
+    error: z.string().optional()
+});
+/**
+ * Generate section ID from task title
+ */
+function generateSectionId(task) {
+    return task.title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Build system prompt by loading from prompts directory
+ */
+async function buildSystemPrompt(promptsDir, reportLanguage) {
+    const promptPath = path.join(promptsDir, 'writer.md');
+    // Verify prompt file exists before reading
+    try {
+        await fs.access(promptPath);
+    }
+    catch (error) {
+        throw new Error(`Critical: Writer 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 report content in ${reportLanguage}.**
+
+This applies to:
+- Section titles and headings
+- Body paragraphs and descriptions
+- Diagram titles, labels, and annotations
+- Finding descriptions
+- Recommendations
+
+IMPORTANT Guidelines:
+1. Write naturally in ${reportLanguage}, not as a direct translation
+2. Use appropriate technical terminology for ${reportLanguage}
+3. Preserve code snippets in their original language - do NOT translate code
+4. Do NOT translate variable names, function names, or code syntax
+5. Memory keys must remain in English (system requirement)
+6. Cross-references and technical identifiers stay in English
+
+`;
+        systemPrompt = systemPrompt + languageInstruction;
+    }
+    return systemPrompt;
+}
+/**
+ * Build user message with writing task details
+ */
+function buildUserMessage(ctx) {
+    const { task } = ctx.inputs;
+    const sectionId = generateSectionId(task);
+    const memoryKeys = task.memory_keys_to_generate || [];
+    return `**Report Writing Task**: ${task.title}
+
+**Section ID**: ${sectionId}
+
+**Description**: ${task.description}
+
+**Memory Keys to Recall**:
+${memoryKeys.map((k) => `- ${k}`).join('\n')}
+
+**Requirements**:
+- Minimum word count: ${task.required_outputs?.min_word_count || 800} words
+- Code examples: ${task.required_outputs?.code_examples || 2} (from actual project files!)
+- Diagrams: ${task.required_outputs?.diagrams || 0}
+- Report sections: ${task.required_outputs?.report_sections || 1}
+
+**Instructions**:
+1. Recall analysis findings using memory_recall (batch multiple queries for efficiency)
+2. Write comprehensive, educational content with:
+   - Actual code examples from the project (with file paths)
+   - Specific technical details (versions, class names, file paths)
+   - Analysis explaining WHY patterns were used, not just WHAT exists
+   - Technical depth suitable for new team members learning the codebase
+3. MUST call report_write with complete content (THIS IS MANDATORY!)
+
+Write detailed, specific content based on ACTUAL analysis findings - not generic placeholder text.`;
+}
+/**
+ * Extract writer output from LLM result
+ */
+function extractWriterOutput(ctx, llmResult) {
+    const task = ctx.inputs.task;
+    const sectionId = generateSectionId(task);
+    // Extract report_write result using utility
+    const reportResult = extractLastToolResult(llmResult, 'report_write', {
+        unwrap: true,
+        required: false
+    });
+    if (!reportResult) {
+        return {
+            taskId: task.task_id,
+            sectionId,
+            success: false,
+            error: 'Writer did not call report_write - no section was written'
+        };
+    }
+    return {
+        taskId: task.task_id,
+        sectionId,
+        success: true,
+        wordCount: reportResult.word_count || 0
+    };
+}
+/**
+ * Create Writer Agent using declarative TSX syntax
+ */
+export function createWriterAgent(promptsDir) {
+    return (_jsxs(Agent, { id: "writer", input: WriterInputSchema, output: WriterOutputSchema, 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) => extractWriterOutput(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 task must include error message'
+                            });
+                        }
+                        return { rules };
+                    }
+                    // Check word count (very relaxed - accept any content)
+                    const minWords = task.required_outputs?.min_word_count || 800;
+                    if (typedOutput.wordCount && typedOutput.wordCount < minWords * 0.2) {
+                        // Only fail if extremely short (less than 20% of requirement)
+                        console.warn(`[WRITER] Warning: Section has ${typedOutput.wordCount} words (target: ${minWords}), but accepting it`);
+                    }
+                    // Always return valid to avoid blocking on word count
+                    return { rules };
+                } }), _jsx(Retry, { maxAttempts: 2, feedbackOnError: true })] }));
+}

package/dist/commands/analyze.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Analyze command - Main entry point for codebase analysis
+ */
+interface AnalyzeOptions {
+    output?: string;
+    model?: string;
+    modules?: string;
+    lang?: string;
+    verbose?: boolean;
+    debug?: boolean;
+    debugApi?: boolean;
+}
+export declare function analyze(targetPath: string, options: AnalyzeOptions): Promise<void>;
+export {};