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

package/dist/types/graphSemantics.js

@@ -0,0 +1,104 @@
+/**
+ * Graph Semantic Structure (Intermediate Representation)
+ *
+ * This IR defines the STRUCTURE of a graph, not its visual representation.
+ * LLM outputs this IR, and the code compiles it to DOT deterministically.
+ *
+ * CRITICAL CONSTRAINTS:
+ * - LLM MUST NOT output DOT/Graphviz syntax
+ * - LLM MUST NOT specify layout, coordinates, styles, or visual properties
+ * - Graph quality depends on structural modeling, not LLM's text expression
+ */
+/**
+ * DOT reserved keywords that cannot be used as node IDs
+ */
+const DOT_KEYWORDS = new Set(['node', 'edge', 'graph', 'digraph', 'subgraph', 'strict']);
+/**
+ * Validate graph semantic structure
+ */
+export function validateGraphSemantics(graph) {
+    const errors = [];
+    const warnings = [];
+    // Check for empty graph
+    if (graph.nodes.length === 0) {
+        errors.push('Graph must contain at least one node');
+    }
+    // Check for duplicate node IDs
+    const nodeIds = new Set();
+    for (const node of graph.nodes) {
+        if (nodeIds.has(node.id)) {
+            errors.push(`Duplicate node ID: ${node.id}`);
+        }
+        nodeIds.add(node.id);
+        // Validate node ID legality
+        // Check for DOT reserved keywords
+        if (DOT_KEYWORDS.has(node.id.toLowerCase())) {
+            warnings.push(`Node ID '${node.id}' is a DOT reserved keyword. ` +
+                `It will be sanitized to 'n_${node.id}' during compilation.`);
+        }
+        // Check for digit-starting IDs
+        if (/^[0-9]/.test(node.id)) {
+            warnings.push(`Node ID '${node.id}' starts with a digit. ` +
+                `It will be sanitized to 'n_${node.id}' during compilation.`);
+        }
+        // Check for special characters
+        if (/[^a-zA-Z0-9_]/.test(node.id)) {
+            warnings.push(`Node ID '${node.id}' contains special characters. ` +
+                `They will be replaced with underscores during compilation.`);
+        }
+    }
+    // Check for duplicate group IDs
+    if (graph.groups) {
+        const groupIds = new Set();
+        for (const group of graph.groups) {
+            if (groupIds.has(group.id)) {
+                errors.push(`Duplicate group ID: ${group.id}`);
+            }
+            groupIds.add(group.id);
+            // Validate group ID legality
+            if (DOT_KEYWORDS.has(group.id.toLowerCase())) {
+                warnings.push(`Group ID '${group.id}' is a DOT reserved keyword. ` +
+                    `It will be sanitized during compilation.`);
+            }
+        }
+    }
+    // Validate edges reference existing nodes
+    for (const edge of graph.edges) {
+        if (!nodeIds.has(edge.from)) {
+            errors.push(`Edge references non-existent source node: ${edge.from}`);
+        }
+        if (!nodeIds.has(edge.to)) {
+            errors.push(`Edge references non-existent target node: ${edge.to}`);
+        }
+        if (edge.from === edge.to) {
+            warnings.push(`Self-loop detected: ${edge.from} -> ${edge.to}`);
+        }
+    }
+    // Validate node groups reference existing groups
+    if (graph.groups) {
+        const groupIds = new Set(graph.groups.map(g => g.id));
+        for (const node of graph.nodes) {
+            if (node.group && !groupIds.has(node.group)) {
+                errors.push(`Node ${node.id} references non-existent group: ${node.group}`);
+            }
+        }
+        // Check for circular group references
+        for (const group of graph.groups) {
+            if (group.parent && !groupIds.has(group.parent)) {
+                errors.push(`Group ${group.id} references non-existent parent: ${group.parent}`);
+            }
+        }
+    }
+    // Warn if graph is too complex
+    if (graph.nodes.length > 50) {
+        warnings.push(`Graph has ${graph.nodes.length} nodes, consider splitting into multiple diagrams`);
+    }
+    if (graph.edges.length > 100) {
+        warnings.push(`Graph has ${graph.edges.length} edges, consider simplifying`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors: errors.length > 0 ? errors : undefined,
+        warnings: warnings.length > 0 ? warnings : undefined
+    };
+}

package/dist/utils/debug.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Debug utilities for Limo CLI
+ * Provides structured logging with different levels
+ */
+export declare class DebugLogger {
+    private startTime;
+    constructor();
+    private get enabled();
+    private get apiDebugEnabled();
+    private getTimestamp;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    success(...args: any[]): void;
+    api(direction: 'request' | 'response', data: any): void;
+    toolCall(toolName: string, params: any): void;
+    toolResult(toolName: string, result: any): void;
+    agentStart(agentName: string, inputs: any): void;
+    agentEnd(agentName: string, outputs: any): void;
+    section(title: string): void;
+    object(label: string, obj: any): void;
+    memory(action: 'store' | 'recall', key: string, data?: any): void;
+    progress(current: number, total: number, message: string): void;
+}
+export declare const debug: DebugLogger;
+export declare function isDebugEnabled(): boolean;
+export declare function isApiDebugEnabled(): boolean;

package/dist/utils/debug.js

@@ -0,0 +1,125 @@
+/**
+ * Debug utilities for Limo CLI
+ * Provides structured logging with different levels
+ */
+import chalk from 'chalk';
+export class DebugLogger {
+    constructor() {
+        this.startTime = Date.now();
+    }
+    get enabled() {
+        return process.env.LIMO_DEBUG === 'true';
+    }
+    get apiDebugEnabled() {
+        return process.env.LIMO_DEBUG_API === 'true';
+    }
+    getTimestamp() {
+        const elapsed = Date.now() - this.startTime;
+        const seconds = (elapsed / 1000).toFixed(3);
+        return chalk.gray(`[+${seconds}s]`);
+    }
+    debug(...args) {
+        if (this.enabled) {
+            console.log(this.getTimestamp(), chalk.cyan('[DEBUG]'), ...args);
+        }
+    }
+    info(...args) {
+        console.log(this.getTimestamp(), chalk.blue('[INFO]'), ...args);
+    }
+    warn(...args) {
+        console.log(this.getTimestamp(), chalk.yellow('[WARN]'), ...args);
+    }
+    error(...args) {
+        console.log(this.getTimestamp(), chalk.red('[ERROR]'), ...args);
+    }
+    success(...args) {
+        console.log(this.getTimestamp(), chalk.green('[SUCCESS]'), ...args);
+    }
+    api(direction, data) {
+        if (this.apiDebugEnabled) {
+            const prefix = direction === 'request' ? '→' : '←';
+            console.log(this.getTimestamp(), chalk.magenta(`[API ${prefix}]`));
+            if (typeof data === 'string') {
+                // Truncate long strings
+                const truncated = data.length > 500 ? data.substring(0, 500) + '...' : data;
+                console.log(chalk.gray(truncated));
+            }
+            else {
+                console.log(JSON.stringify(data, null, 2));
+            }
+        }
+    }
+    toolCall(toolName, params) {
+        if (this.enabled) {
+            console.log(this.getTimestamp(), chalk.yellow('[TOOL]'), toolName);
+            console.log(chalk.gray('  Parameters:'), JSON.stringify(params, null, 2));
+        }
+    }
+    toolResult(toolName, result) {
+        if (this.enabled) {
+            const status = result.success ? chalk.green('✓') : chalk.red('✗');
+            console.log(this.getTimestamp(), chalk.yellow('[TOOL]'), toolName, status);
+            if (result.error) {
+                console.log(chalk.red('  Error:'), result.error);
+            }
+            else if (result.data) {
+                const dataStr = typeof result.data === 'string'
+                    ? result.data.substring(0, 200)
+                    : JSON.stringify(result.data, null, 2).substring(0, 200);
+                console.log(chalk.gray('  Result:'), dataStr + (dataStr.length >= 200 ? '...' : ''));
+            }
+        }
+    }
+    agentStart(agentName, inputs) {
+        if (this.enabled) {
+            console.log('\n' + chalk.bgCyan.black(` AGENT START: ${agentName.toUpperCase()} `));
+            console.log(chalk.gray('Inputs:'), JSON.stringify(inputs, null, 2));
+        }
+    }
+    agentEnd(agentName, outputs) {
+        if (this.enabled) {
+            console.log(chalk.bgGreen.black(` AGENT END: ${agentName.toUpperCase()} `));
+            console.log(chalk.gray('Outputs:'), JSON.stringify(outputs, null, 2));
+            console.log('');
+        }
+    }
+    section(title) {
+        if (this.enabled) {
+            console.log('\n' + chalk.cyan('═'.repeat(60)));
+            console.log(chalk.cyan.bold(`  ${title}`));
+            console.log(chalk.cyan('═'.repeat(60)) + '\n');
+        }
+    }
+    object(label, obj) {
+        if (this.enabled) {
+            console.log(this.getTimestamp(), chalk.cyan('[OBJECT]'), label);
+            console.log(JSON.stringify(obj, null, 2));
+        }
+    }
+    memory(action, key, data) {
+        if (this.enabled) {
+            const icon = action === 'store' ? '💾' : '🔍';
+            console.log(this.getTimestamp(), chalk.magenta(`[MEMORY ${icon}]`), key);
+            if (data && action === 'store') {
+                console.log(chalk.gray('  Content length:'), data.content?.length || 0);
+                console.log(chalk.gray('  Importance:'), data.importance);
+                console.log(chalk.gray('  Category:'), data.category);
+            }
+        }
+    }
+    progress(current, total, message) {
+        if (this.enabled) {
+            const percentage = ((current / total) * 100).toFixed(0);
+            console.log(this.getTimestamp(), chalk.blue('[PROGRESS]'), `[${current}/${total}]`, `${percentage}%`, message);
+        }
+    }
+}
+// Global singleton instance
+export const debug = new DebugLogger();
+// Helper function to check if debug is enabled
+export function isDebugEnabled() {
+    return process.env.LIMO_DEBUG === 'true';
+}
+export function isApiDebugEnabled() {
+    return process.env.LIMO_DEBUG_API === 'true';
+}

package/dist/utils/limoConfigParser.d.ts

@@ -0,0 +1,21 @@
+/**
+ * LIMO.md Configuration Parser
+ *
+ * Parses user-provided LIMO.md files to extract analysis requirements,
+ * focus areas, constraints, and private context.
+ */
+/**
+ * LIMO configuration interface
+ */
+export interface LimoConfiguration {
+    rawContent: string;
+    focusAreas?: string[];
+    excludeModules?: string[];
+    scopeDescription?: string;
+    privateContext?: string;
+    constraints?: string[];
+}
+/**
+ * Parse LIMO.md file and extract configuration
+ */
+export declare function parseLimoConfig(workspaceRoot: string): Promise<LimoConfiguration | undefined>;

package/dist/utils/limoConfigParser.js

@@ -0,0 +1,274 @@
+/**
+ * LIMO.md Configuration Parser
+ *
+ * Parses user-provided LIMO.md files to extract analysis requirements,
+ * focus areas, constraints, and private context.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { debug } from './debug.js';
+/**
+ * Valid analysis module names
+ */
+const VALID_MODULES = [
+    'architecture',
+    'dependencies',
+    'code-quality',
+    'security',
+    'database',
+    'testing',
+    'migration',
+    'migration-verification'
+];
+/**
+ * Parse LIMO.md file and extract configuration
+ */
+export async function parseLimoConfig(workspaceRoot) {
+    const limoPath = path.join(workspaceRoot, 'LIMO.md');
+    try {
+        await fs.access(limoPath);
+    }
+    catch {
+        debug.info('No LIMO.md file found - using default analysis scope');
+        return undefined;
+    }
+    try {
+        const content = await fs.readFile(limoPath, 'utf-8');
+        debug.info('Found LIMO.md configuration file');
+        // Parse configuration (flexible, keyword-based parsing)
+        return {
+            rawContent: content,
+            focusAreas: extractFocusAreas(content),
+            excludeModules: extractExcludeModules(content),
+            scopeDescription: extractScopeDescription(content),
+            privateContext: extractPrivateContext(content),
+            constraints: extractConstraints(content)
+        };
+    }
+    catch (error) {
+        debug.warn('Failed to parse LIMO.md - using default analysis scope', error);
+        return undefined;
+    }
+}
+/**
+ * Extract focus areas from LIMO.md content
+ * Looks for sections like "Focus Areas" or keywords like "only analyze", "focus on"
+ */
+function extractFocusAreas(content) {
+    const areas = [];
+    // Look for explicit focus areas section
+    const focusSectionMatch = content.match(/##?\s*Focus\s*Areas?[:\s]*\n([\s\S]*?)(?=\n##|$)/i);
+    if (focusSectionMatch) {
+        const focusSection = focusSectionMatch[1];
+        // Extract list items
+        const listItems = focusSection.match(/^[\s-*]+(.+)$/gm);
+        if (listItems) {
+            listItems.forEach(item => {
+                const cleaned = item.replace(/^[\s-*]+/, '').trim().toLowerCase();
+                if (VALID_MODULES.includes(cleaned)) {
+                    areas.push(cleaned);
+                }
+            });
+        }
+    }
+    // Look for "Include:" or "What to analyze:" sections
+    const includeMatch = content.match(/(?:Include|What to analyze)[:\s]*\n([\s\S]*?)(?=\n##|(?:Exclude|What to skip)|$)/i);
+    if (includeMatch) {
+        const includeSection = includeMatch[1];
+        const listItems = includeSection.match(/^[\s-*]+(.+)$/gm);
+        if (listItems) {
+            listItems.forEach(item => {
+                const cleaned = item.replace(/^[\s-*]+/, '').trim().toLowerCase();
+                if (VALID_MODULES.includes(cleaned)) {
+                    areas.push(cleaned);
+                }
+            });
+        }
+    }
+    // Look for keywords in natural language
+    const naturalLanguagePatterns = [
+        /(?:only|just)\s+(?:analyze|focus\s+on|check)\s+(?:the\s+)?(\w+(?:\s+and\s+\w+)*)/gi,
+        /focus\s+(?:on|areas?)[:\s]+(.+?)(?:\.|$)/gi,
+        /concentrate\s+on[:\s]+(.+?)(?:\.|$)/gi
+    ];
+    naturalLanguagePatterns.forEach(pattern => {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            const mentioned = match[1].toLowerCase().split(/\s+(?:and|,)\s+/);
+            mentioned.forEach(word => {
+                const cleaned = word.trim().replace(/[.,;!?]/, '');
+                if (VALID_MODULES.includes(cleaned)) {
+                    areas.push(cleaned);
+                }
+            });
+        }
+    });
+    // Validate and deduplicate
+    const validAreas = [...new Set(areas)].filter(area => VALID_MODULES.includes(area));
+    const invalidAreas = [...new Set(areas)].filter(area => !VALID_MODULES.includes(area));
+    if (invalidAreas.length > 0) {
+        debug.warn(`Invalid module names in LIMO.md: ${invalidAreas.join(', ')}`);
+        debug.warn(`Valid modules: ${VALID_MODULES.join(', ')}`);
+    }
+    return validAreas.length > 0 ? validAreas : undefined;
+}
+/**
+ * Extract excluded modules from LIMO.md content
+ * Looks for keywords like "skip", "ignore", "don't analyze", "exclude"
+ */
+function extractExcludeModules(content) {
+    const excludes = [];
+    // Look for explicit exclude section
+    const excludeSectionMatch = content.match(/##?\s*(?:Exclude|What to skip)[:\s]*\n([\s\S]*?)(?=\n##|$)/i);
+    if (excludeSectionMatch) {
+        const excludeSection = excludeSectionMatch[1];
+        // Extract list items
+        const listItems = excludeSection.match(/^[\s-*]+(.+)$/gm);
+        if (listItems) {
+            listItems.forEach(item => {
+                const cleaned = item.replace(/^[\s-*]+/, '').trim().toLowerCase();
+                if (VALID_MODULES.includes(cleaned)) {
+                    excludes.push(cleaned);
+                }
+            });
+        }
+    }
+    // Look for "Exclude:" in focus areas section
+    const excludeMatch = content.match(/Exclude[:\s]*\n([\s\S]*?)(?=\n##|\n\*\*|$)/i);
+    if (excludeMatch) {
+        const excludeSection = excludeMatch[1];
+        const listItems = excludeSection.match(/^[\s-*]+(.+)$/gm);
+        if (listItems) {
+            listItems.forEach(item => {
+                const cleaned = item.replace(/^[\s-*]+/, '').trim().toLowerCase();
+                if (VALID_MODULES.includes(cleaned)) {
+                    excludes.push(cleaned);
+                }
+            });
+        }
+    }
+    // Look for keywords in natural language
+    const naturalLanguagePatterns = [
+        /(?:skip|ignore|don't\s+analyze|exclude)\s+(?:the\s+)?(\w+(?:\s+and\s+\w+)*)/gi,
+        /no\s+(\w+)\s+(?:analysis|module)/gi
+    ];
+    naturalLanguagePatterns.forEach(pattern => {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            const mentioned = match[1].toLowerCase().split(/\s+(?:and|,)\s+/);
+            mentioned.forEach(word => {
+                const cleaned = word.trim().replace(/[.,;!?]/, '');
+                if (VALID_MODULES.includes(cleaned)) {
+                    excludes.push(cleaned);
+                }
+            });
+        }
+    });
+    // Validate and deduplicate
+    const validExcludes = [...new Set(excludes)].filter(area => VALID_MODULES.includes(area));
+    return validExcludes.length > 0 ? validExcludes : undefined;
+}
+/**
+ * Extract scope description from LIMO.md content
+ * Looks for sections describing what user wants analyzed
+ */
+function extractScopeDescription(content) {
+    // Look for "Analysis Scope" section
+    const scopeSectionMatch = content.match(/##?\s*Analysis\s*Scope[:\s]*\n([\s\S]*?)(?=\n##|$)/i);
+    if (scopeSectionMatch) {
+        const scopeSection = scopeSectionMatch[1].trim();
+        // Remove empty lines and HTML comments
+        const cleaned = scopeSection
+            .replace(/<!--[\s\S]*?-->/g, '')
+            .replace(/^\s*$/gm, '')
+            .trim();
+        if (cleaned && cleaned.length > 10) {
+            return cleaned;
+        }
+    }
+    // Look for "What to analyze:" section
+    const whatToAnalyzeMatch = content.match(/\*\*What to analyze:\*\*\s*\n([\s\S]*?)(?=\n\*\*|$)/i);
+    if (whatToAnalyzeMatch) {
+        const whatSection = whatToAnalyzeMatch[1].trim();
+        const cleaned = whatSection
+            .replace(/<!--[\s\S]*?-->/g, '')
+            .replace(/^\s*$/gm, '')
+            .trim();
+        if (cleaned && cleaned.length > 10) {
+            return cleaned;
+        }
+    }
+    // Look for natural language descriptions
+    const descriptionPatterns = [
+        /(?:analyze|focus\s+on|examine)\s+(?:only|just)?\s*(?:the\s+)?(.+?)(?:\.|$)/i,
+        /scope[:\s]+(.+?)(?:\.|$)/i
+    ];
+    for (const pattern of descriptionPatterns) {
+        const match = content.match(pattern);
+        if (match && match[1].length > 10) {
+            return match[1].trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract private/company context from LIMO.md content
+ * Looks for sections with company-specific info, constraints, etc.
+ */
+function extractPrivateContext(content) {
+    // Look for context sections
+    const contextPatterns = [
+        /##?\s*(?:Private|Company|Domain|Project)\s*Context[:\s]*\n([\s\S]*?)(?=\n##|$)/i,
+        /##?\s*(?:Production|Environment|Company)\s*(?:Environment|Context|Info)[:\s]*\n([\s\S]*?)(?=\n##|$)/i,
+        /##?\s*(?:Security|Business)\s*Requirements?[:\s]*\n([\s\S]*?)(?=\n##|$)/i
+    ];
+    for (const pattern of contextPatterns) {
+        const match = content.match(pattern);
+        if (match) {
+            const context = match[1].trim();
+            // Remove HTML comments
+            const cleaned = context
+                .replace(/<!--[\s\S]*?-->/g, '')
+                .replace(/^\s*$/gm, '')
+                .trim();
+            if (cleaned && cleaned.length > 10) {
+                return cleaned;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract constraints from LIMO.md content
+ * Looks for specific constraints like "no external dependencies", "must use X"
+ */
+function extractConstraints(content) {
+    const constraints = [];
+    // Look for constraints section
+    const constraintsSectionMatch = content.match(/##?\s*Constraints?[:\s]*\n([\s\S]*?)(?=\n##|$)/i);
+    if (constraintsSectionMatch) {
+        const constraintsSection = constraintsSectionMatch[1];
+        // Extract list items or numbered items
+        const listItems = constraintsSection.match(/^[\s-*\d.]+(.+)$/gm);
+        if (listItems) {
+            listItems.forEach(item => {
+                const cleaned = item.replace(/^[\s-*\d.]+/, '').trim();
+                if (cleaned && cleaned.length > 5) {
+                    constraints.push(cleaned);
+                }
+            });
+        }
+    }
+    // Look for "must" or "cannot" statements
+    const mustPattern = /(?:must|cannot|should not|can't|don't)\s+(.+?)(?:\.|$)/gi;
+    let match;
+    while ((match = mustPattern.exec(content)) !== null) {
+        const constraint = match[0].trim();
+        if (constraint.length > 10 && constraint.length < 200) {
+            constraints.push(constraint);
+        }
+    }
+    // Deduplicate
+    const uniqueConstraints = [...new Set(constraints)];
+    return uniqueConstraints.length > 0 ? uniqueConstraints : undefined;
+}

package/dist/utils/reviewMonitor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Review Folder Monitor
+ * Watches for new files in the review/ directory and checks for comments
+ */
+export declare class ReviewMonitor {
+    private reviewPath;
+    private watcher;
+    private processedFiles;
+    constructor(workspaceRoot: string);
+    start(): Promise<void>;
+    stop(): void;
+    private processExistingFiles;
+    private processFile;
+    private extractComments;
+    getStats(): {
+        totalFiles: number;
+        processedFiles: number;
+    };
+}
+export default ReviewMonitor;