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

package/dist/tools/index.js

@@ -0,0 +1,362 @@
+/**
+ * Tool implementations for Limo CLI
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { glob } from 'glob';
+import { z } from 'zod';
+import { createMemoryTools } from '@limo-labs/deity';
+import { debug } from '../utils/debug.js';
+import { createExtendedTools } from './extended.js';
+import { createAdditionalTools } from './additional.js';
+/**
+ * Count words in text, handling both CJK characters and whitespace-separated words.
+ * Each CJK character counts as one word; remaining text is split by whitespace.
+ */
+function countWords(text) {
+    const cjkChars = text.match(/[\u4e00-\u9fff\u3400-\u4dbf\uf900-\ufaff]/g);
+    const cjkCount = cjkChars ? cjkChars.length : 0;
+    const nonCjkText = text.replace(/[\u4e00-\u9fff\u3400-\u4dbf\uf900-\ufaff]/g, ' ');
+    const nonCjkWords = nonCjkText.split(/\s+/).filter(w => w.length > 0);
+    return cjkCount + nonCjkWords.length;
+}
+const FileListInputSchema = z.object({
+    root_path: z.string().describe('Root path to start listing from'),
+    pattern: z.string().describe('Glob pattern to match files'),
+    exclude_pattern: z.string().optional().describe('Glob pattern to exclude files'),
+    max_results: z.number().optional().describe('Maximum number of results to return')
+});
+export function createFileListTool(context) {
+    return {
+        name: 'file_list', // LIMO prefix to avoid conflicts with env tools
+        description: 'List files and directories in the project',
+        inputSchema: FileListInputSchema,
+        execute: async (params) => {
+            debug.toolCall('file_list', params);
+            const rootPath = path.resolve(context.workspaceRoot, params.root_path || '.');
+            const pattern = params.pattern || '**/*';
+            const maxResults = params.max_results || 500;
+            const files = await glob(pattern, {
+                cwd: rootPath,
+                ignore: [
+                    '**/node_modules/**',
+                    '**/.git/**',
+                    '**/.limo/**',
+                    ...(params.exclude_pattern ? [params.exclude_pattern] : [])
+                ],
+                nodir: true,
+                maxDepth: 10
+            });
+            const truncated = files.length > maxResults;
+            const resultFiles = files.slice(0, maxResults);
+            const result = {
+                success: true,
+                data: {
+                    files: resultFiles,
+                    total: resultFiles.length,
+                    truncated,
+                    message: truncated ? `Showing ${maxResults} of ${files.length} files (truncated)` : `Found ${files.length} files`
+                }
+            };
+            debug.toolResult('file_list', result);
+            return result;
+        }
+    };
+}
+const FileReadInputSchema = z.object({
+    file_path: z.string().describe('Path to the file to read')
+});
+export function createFileReadTool(context) {
+    return {
+        name: 'file_read', // LIMO prefix to avoid conflicts with env tools
+        description: 'Read the contents of a file',
+        inputSchema: FileReadInputSchema,
+        execute: async (params) => {
+            const filePath = path.resolve(context.workspaceRoot, params.file_path);
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const lines = content.split('\n');
+                const numberedLines = lines.map((line, idx) => `${idx + 1}\t${line}`).join('\n');
+                return { success: true, data: numberedLines };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: `Error reading file: ${error instanceof Error ? error.message : String(error)}`
+                };
+            }
+        }
+    };
+}
+const TaskSchema = z.object({
+    task_id: z.string().describe('Unique task identifier (e.g., arch-01, dep-02)'),
+    module: z.string().describe('Module type (architecture, dependencies, security, code-quality, database, testing, migration)'),
+    title: z.string().describe('Concise task title'),
+    description: z.string().describe('Detailed description of what to analyze (2-3 sentences)'),
+    required_outputs: z.object({
+        report_sections: z.number().describe('Number of report sections (1-3)'),
+        code_examples: z.number().describe('Number of code examples (0-5)'),
+        diagrams: z.number().describe('Number of diagrams (0-2)'),
+        min_word_count: z.number().describe('Minimum word count (600-1200)')
+    }).describe('Required output specifications'),
+    memory_keys_to_generate: z.array(z.string()).optional().describe('Memory keys to generate (2-5 keys)'),
+    dependencies: z.array(z.string()).optional().describe('Task IDs this task depends on'),
+    status: z.string().optional().describe('Task status (always pending)')
+});
+const PlanningCreateInputSchema = z.object({
+    project_complexity: z.enum(['small', 'medium', 'large']).describe('Project complexity level'),
+    estimated_loc: z.number().describe('Estimated lines of code'),
+    estimated_files: z.number().describe('Estimated number of files'),
+    tasks: z.array(TaskSchema).describe('Array of analysis tasks')
+});
+export function createPlanningCreateTool(context) {
+    return {
+        name: 'planning_create', // LIMO prefix to avoid conflicts with env tools
+        description: 'Create a detailed analysis plan with sub-tasks',
+        inputSchema: PlanningCreateInputSchema,
+        execute: async (params) => {
+            debug.toolCall('planning_create', {
+                complexity: params.project_complexity,
+                files: params.estimated_files,
+                tasks: params.tasks.length
+            });
+            // Normalize tasks: add missing dependencies and status fields
+            const normalizedTasks = params.tasks.map(task => ({
+                ...task,
+                dependencies: task.dependencies || [],
+                status: task.status || 'pending'
+            }));
+            const plan = {
+                project_complexity: params.project_complexity,
+                estimated_loc: params.estimated_loc,
+                estimated_files: params.estimated_files,
+                tasks: normalizedTasks, // Use normalized tasks
+                total_tasks: normalizedTasks.length,
+                created_at: new Date().toISOString(),
+                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)
+                }
+            };
+            context.plan = plan;
+            const result = { success: true, data: plan };
+            debug.toolResult('planning_create', result);
+            return result;
+        }
+    };
+}
+const ReportWriteInputSchema = z.object({
+    section_id: z.string().describe('Unique section identifier'),
+    title: z.string().describe('Section title'),
+    content: z.string().describe('Section content in Markdown'),
+    level: z.number().optional().describe('Heading level (1-6)')
+});
+export function createReportWriteTool(context) {
+    return {
+        name: 'report_write', // LIMO prefix to avoid conflicts with env tools
+        description: 'Write a section to the analysis report',
+        inputSchema: ReportWriteInputSchema,
+        execute: async (params) => {
+            const level = params.level || 2;
+            const markdown = `${'#'.repeat(level)} ${params.title}\n\n${params.content}\n\n---\n\n`;
+            context.reportSections.set(params.section_id, markdown);
+            return {
+                success: true,
+                data: {
+                    section_id: params.section_id,
+                    word_count: countWords(params.content)
+                }
+            };
+        }
+    };
+}
+const ReportAddDiagramInputSchema = z.object({
+    diagram_id: z.string().describe('Unique diagram identifier'),
+    title: z.string().describe('Diagram title'),
+    description: z.string().optional().describe('Diagram description'),
+    section_id: z.string().optional().describe('ID of the report section this diagram belongs to (for embedding diagram in the section)'),
+    // PREFERRED: Semantic mode - nodes/edges provided, compile to SVG
+    nodes: z.array(z.any()).describe('Array of nodes/components (REQUIRED for semantic diagrams)'),
+    edges: z.array(z.any()).describe('Array of edges/relationships (REQUIRED for semantic diagrams)'),
+    groups: z.array(z.any()).optional().describe('Optional groups/clusters'),
+    // DEPRECATED: Direct source mode (only for SVG passthrough)
+    format: z.enum(['svg']).optional().describe('DEPRECATED: Only use "svg" if providing pre-rendered SVG'),
+    source: z.string().optional().describe('DEPRECATED: Only use for pre-rendered SVG source'),
+    related_files: z.array(z.string()).optional().describe('Related file paths'),
+    metadata: z.any().optional().describe('Optional metadata')
+});
+export function createReportAddDiagramTool(context) {
+    return {
+        name: 'report_add_diagram', // LIMO prefix to avoid conflicts with env tools
+        description: 'Add a diagram to the report using semantic structure (nodes + edges). ALWAYS use semantic mode with nodes/edges arrays - DO NOT use mermaid or DOT source code. The system will automatically compile to professional SVG diagrams.',
+        inputSchema: ReportAddDiagramInputSchema,
+        execute: async (params) => {
+            // Import diagram utilities dynamically
+            const { compileGraphToSvgSafe } = await import('../report/graphCompiler.js');
+            const { validateGraphSemantics } = await import('../types/graphSemantics.js');
+            // Legacy source mode (mermaid/dot) - DEPRECATED, return error
+            if (params.format && params.format !== 'svg') {
+                return {
+                    success: false,
+                    error: 'Mermaid and DOT formats are deprecated. Please use semantic structure with nodes/edges arrays instead. See tool description for examples.'
+                };
+            }
+            // SVG passthrough mode (only for pre-rendered SVG)
+            if (params.format === 'svg' && params.source) {
+                context.diagrams.set(params.diagram_id, {
+                    id: params.diagram_id,
+                    title: params.title,
+                    description: params.description,
+                    format: 'svg',
+                    source: params.source,
+                    relatedFiles: params.related_files,
+                    metadata: {
+                        sectionId: params.section_id, // Store section association
+                        generatedAt: new Date().toISOString()
+                    }
+                });
+                return {
+                    success: true,
+                    data: {
+                        diagram_id: params.diagram_id,
+                        title: params.title,
+                        format: 'svg',
+                        source_length: params.source.length
+                    }
+                };
+            }
+            // Semantic mode: nodes/edges provided, compile to SVG (PREFERRED)
+            if (!params.nodes || !params.edges) {
+                return {
+                    success: false,
+                    error: 'Must provide nodes and edges arrays for semantic diagram generation. Do not use format/source (deprecated).'
+                };
+            }
+            // Construct graph semantics
+            const graphSemantics = {
+                id: params.diagram_id,
+                title: params.title,
+                description: params.description,
+                nodes: params.nodes.map((n) => ({
+                    id: n.id,
+                    label: n.label,
+                    type: n.type,
+                    group: n.group,
+                    description: n.description,
+                    metadata: n.metadata
+                })),
+                edges: params.edges.map((e) => ({
+                    from: e.from,
+                    to: e.to,
+                    type: e.type,
+                    label: e.label,
+                    bidirectional: e.bidirectional,
+                    metadata: e.metadata
+                })),
+                groups: params.groups?.map((g) => ({
+                    id: g.id,
+                    label: g.label,
+                    parent: g.parent,
+                    type: g.type,
+                    description: g.description
+                })),
+                metadata: params.metadata
+            };
+            // Validate graph semantics
+            const validation = validateGraphSemantics(graphSemantics);
+            if (!validation.valid) {
+                return {
+                    success: false,
+                    error: `Graph validation failed: ${validation.errors?.join(', ')}`
+                };
+            }
+            // Compile directly to SVG (DOT intermediate step is internal)
+            const svgResult = await compileGraphToSvgSafe(graphSemantics);
+            if (!svgResult.success) {
+                return {
+                    success: false,
+                    error: svgResult.error || 'Failed to compile graph to SVG'
+                };
+            }
+            // Store diagram with SVG source
+            context.diagrams.set(params.diagram_id, {
+                id: params.diagram_id,
+                title: params.title,
+                description: params.description,
+                format: 'svg',
+                source: svgResult.svg,
+                relatedFiles: params.related_files,
+                metadata: {
+                    sectionId: params.section_id, // Store section association
+                    nodeCount: params.nodes.length,
+                    edgeCount: params.edges.length,
+                    generatedAt: new Date().toISOString()
+                }
+            });
+            return {
+                success: true,
+                data: {
+                    diagram_id: params.diagram_id,
+                    title: params.title,
+                    nodes: params.nodes.length,
+                    edges: params.edges.length,
+                    validation: validation.warnings ? `passed with ${validation.warnings.length} warnings` : 'passed',
+                    warnings: validation.warnings
+                }
+            };
+        }
+    };
+}
+const ReportFinalizeInputSchema = z.object({
+    executive_summary: z.string().describe('Executive summary'),
+    recommendations: z.array(z.string()).optional().describe('List of recommendations')
+});
+export function createReportFinalizeTool(context) {
+    return {
+        name: 'report_finalize', // LIMO prefix to avoid conflicts with env tools
+        description: 'Finalize the analysis report',
+        inputSchema: ReportFinalizeInputSchema,
+        execute: async (params) => {
+            return {
+                success: true,
+                data: {
+                    message: 'Report finalized',
+                    executive_summary: params.executive_summary,
+                    recommendations: params.recommendations
+                }
+            };
+        }
+    };
+}
+/**
+ * Create all tools including Deity's memory tools
+ *
+ * @param context Tool context
+ * @param ctx ExecutionContext with memory enabled
+ * @returns Array of all tools
+ */
+export function createAllTools(context, ctx) {
+    // Get Deity's built-in memory tools
+    const memoryTools = ctx.memory ? createMemoryTools(ctx) : [];
+    return [
+        // File operation tools
+        createFileListTool(context),
+        createFileReadTool(context),
+        // Deity memory tools (replaces custom memory_store/memory_recall)
+        ...memoryTools,
+        // Planning and reporting tools
+        createPlanningCreateTool(context),
+        createReportWriteTool(context),
+        createReportAddDiagramTool(context),
+        createReportFinalizeTool(context),
+        // Extended tools from VSCode extension
+        ...createExtendedTools(context),
+        // Additional tools (UI, code analysis, etc.)
+        ...createAdditionalTools(context)
+    ];
+}

package/dist/types/agents.types.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Limo CLI Agent Input/Output Types
+ *
+ * @deity.schema
+ */
+/**
+ * LIMO.md configuration
+ * @zod
+ */
+export interface LimoConfig {
+    focusAreas?: string[];
+    excludeModules?: string[];
+    scopeDescription?: string;
+}
+/**
+ * Planner agent input
+ * @zod
+ */
+export interface PlannerInput {
+    workspaceRoot: string;
+    modules?: string[];
+    limoConfig?: LimoConfig;
+}
+/**
+ * Task required outputs
+ * @zod
+ */
+export interface TaskRequiredOutputs {
+    report_sections: number;
+    code_examples: number;
+    diagrams: number;
+    min_word_count: number;
+}
+/**
+ * Task status
+ */
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+/**
+ * Project complexity
+ */
+export type ProjectComplexity = 'small' | 'medium' | 'large';
+/**
+ * Task in the analysis plan
+ * @zod
+ */
+export interface PlanTask {
+    task_id: string;
+    module: string;
+    title: string;
+    description: string;
+    required_outputs: TaskRequiredOutputs;
+    memory_keys_to_generate?: string[];
+    dependencies: string[];
+    status: TaskStatus;
+}
+/**
+ * Plan summary
+ * @zod
+ */
+export interface PlanSummary {
+    tasks_by_module: Record<string, number>;
+    total_sections_expected: number;
+    total_diagrams_expected: number;
+    total_words_expected: number;
+}
+/**
+ * Planner agent output
+ * @zod
+ */
+export interface PlannerOutput {
+    project_complexity: ProjectComplexity;
+    estimated_loc: number;
+    estimated_files: number;
+    tasks: PlanTask[];
+    total_tasks: number;
+    estimated_duration_minutes?: number;
+    created_at: string;
+    summary: PlanSummary;
+}
+/**
+ * Analyst agent input
+ * @zod
+ */
+export interface AnalystInput {
+    task: PlanTask;
+    workspaceRoot: string;
+    promptsDir: string;
+}
+/**
+ * Analyst agent output
+ * @zod
+ */
+export interface AnalystOutput {
+    taskId: string;
+    success: boolean;
+    memoriesCreated: number;
+    error?: string;
+}
+/**
+ * Writer agent input
+ * @zod
+ */
+export interface WriterInput {
+    task: PlanTask;
+    promptsDir: string;
+    reportLanguage?: string;
+}
+/**
+ * Writer agent output
+ * @zod
+ */
+export interface WriterOutput {
+    taskId: string;
+    sectionId: string;
+    success: boolean;
+    wordCount?: number;
+    error?: string;
+}
+/**
+ * Editor agent input
+ * @zod
+ */
+export interface EditorInput {
+    projectName: string;
+    taskCount: number;
+    sectionCount: number;
+    diagramCount: number;
+    promptsDir: string;
+    reportLanguage?: string;
+}
+/**
+ * Editor agent output
+ * @zod
+ */
+export interface EditorOutput {
+    success: boolean;
+    summaryGenerated: boolean;
+    error?: string;
+}

package/dist/types/agents.types.js

@@ -0,0 +1,6 @@
+/**
+ * Limo CLI Agent Input/Output Types
+ *
+ * @deity.schema
+ */
+export {};

package/dist/types/graphSemantics.d.ts

@@ -0,0 +1,99 @@
+/**
+ * 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
+ */
+/**
+ * Node type - represents a component, module, or entity
+ */
+export type GraphNodeType = 'component' | 'layer' | 'system' | 'data' | 'process' | 'actor';
+/**
+ * Edge type - represents relationship semantics
+ */
+export type GraphEdgeType = 'depends_on' | 'calls' | 'uses' | 'contains' | 'inherits' | 'implements' | 'data_flow' | 'control_flow';
+/**
+ * Node in the graph
+ */
+export interface GraphNode {
+    readonly id: string;
+    readonly label: string;
+    readonly type: GraphNodeType;
+    readonly group?: string;
+    readonly description?: string;
+    readonly metadata?: {
+        readonly filePath?: string;
+        readonly complexity?: 'low' | 'medium' | 'high';
+        [key: string]: unknown;
+    };
+}
+/**
+ * Edge in the graph
+ */
+export interface GraphEdge {
+    readonly from: string;
+    readonly to: string;
+    readonly type: GraphEdgeType;
+    readonly label?: string;
+    readonly bidirectional?: boolean;
+    readonly metadata?: {
+        readonly weight?: number;
+        readonly conditional?: boolean;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Group/cluster for hierarchical organization
+ */
+export interface GraphGroup {
+    readonly id: string;
+    readonly label: string;
+    readonly parent?: string;
+    readonly type?: string;
+    readonly description?: string;
+}
+/**
+ * Architecture constraint or rule
+ */
+export interface GraphConstraint {
+    readonly type: 'allowed' | 'forbidden';
+    readonly from: string;
+    readonly to: string;
+    readonly reason?: string;
+}
+/**
+ * Complete graph semantic structure
+ * This is what LLM outputs
+ */
+export interface GraphSemantics {
+    readonly id: string;
+    readonly title: string;
+    readonly description?: string;
+    readonly nodes: readonly GraphNode[];
+    readonly edges: readonly GraphEdge[];
+    readonly groups?: readonly GraphGroup[];
+    readonly constraints?: readonly GraphConstraint[];
+    readonly metadata?: {
+        readonly direction?: 'TB' | 'LR' | 'BT' | 'RL';
+        readonly focusNodes?: readonly string[];
+        readonly hiddenNodes?: readonly string[];
+        [key: string]: unknown;
+    };
+}
+/**
+ * Validation result for graph semantics
+ */
+export interface GraphValidationResult {
+    readonly valid: boolean;
+    readonly errors?: readonly string[];
+    readonly warnings?: readonly string[];
+}
+/**
+ * Validate graph semantic structure
+ */
+export declare function validateGraphSemantics(graph: GraphSemantics): GraphValidationResult;