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

package/dist/tools/extended.js

@@ -0,0 +1,586 @@
+/**
+ * Extended tool implementations for Limo CLI
+ * Implements all missing tools from VSCode extension
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { glob } from 'glob';
+import { z } from 'zod';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+// ===== FILE OPERATIONS =====
+const FileSearchContentInputSchema = z.object({
+    root_path: z.string().describe('Root directory to search from'),
+    pattern: z.string().describe('Regex pattern to search for'),
+    file_pattern: z.string().optional().describe('Glob pattern for files to search'),
+    exclude_pattern: z.string().optional().describe('Glob pattern for files to exclude'),
+    max_results: z.number().optional().describe('Maximum number of results to return')
+});
+export function createFileSearchContentTool(context) {
+    return {
+        name: 'file_search_content',
+        description: 'Search for content in files using regex pattern',
+        inputSchema: FileSearchContentInputSchema,
+        execute: async (params) => {
+            const rootPath = path.resolve(context.workspaceRoot, params.root_path || '.');
+            const maxResults = params.max_results || 50;
+            try {
+                const filePattern = params.file_pattern || '**/*';
+                const files = await glob(filePattern, {
+                    cwd: rootPath,
+                    ignore: [
+                        '**/node_modules/**',
+                        '**/.git/**',
+                        '**/.limo/**',
+                        ...(params.exclude_pattern ? [params.exclude_pattern] : [])
+                    ],
+                    nodir: true
+                });
+                const regex = new RegExp(params.pattern, 'gi');
+                const results = [];
+                for (const file of files) {
+                    if (results.length >= maxResults)
+                        break;
+                    const filePath = path.join(rootPath, file);
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        const lines = content.split('\n');
+                        for (let i = 0; i < lines.length; i++) {
+                            if (results.length >= maxResults)
+                                break;
+                            const match = regex.exec(lines[i]);
+                            if (match) {
+                                results.push({
+                                    file: file,
+                                    line: i + 1,
+                                    content: lines[i].trim(),
+                                    match: match[0]
+                                });
+                            }
+                        }
+                    }
+                    catch (err) {
+                        // Skip files that can't be read
+                    }
+                }
+                return {
+                    success: true,
+                    data: {
+                        results,
+                        total: results.length,
+                        truncated: results.length >= maxResults
+                    }
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: `Search failed: ${error instanceof Error ? error.message : String(error)}`
+                };
+            }
+        }
+    };
+}
+// ===== TERMINAL OPERATIONS =====
+const TerminalExecuteInputSchema = z.object({
+    command: z.string().describe('Command to execute'),
+    timeout: z.number().optional().describe('Timeout in milliseconds'),
+    cwd: z.string().optional().describe('Working directory')
+});
+export function createTerminalExecuteTool(context) {
+    return {
+        name: 'terminal_execute',
+        description: 'Execute a shell command',
+        inputSchema: TerminalExecuteInputSchema,
+        execute: async (params) => {
+            const timeout = params.timeout || 30000;
+            const cwd = params.cwd || context.workspaceRoot;
+            try {
+                const { stdout, stderr } = await execAsync(params.command, {
+                    cwd,
+                    timeout,
+                    maxBuffer: 1024 * 1024 * 10 // 10MB buffer
+                });
+                return {
+                    success: true,
+                    data: {
+                        stdout: stdout.trim(),
+                        stderr: stderr.trim(),
+                        exitCode: 0
+                    }
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: `Command failed: ${error.message}`,
+                    data: {
+                        stdout: error.stdout || '',
+                        stderr: error.stderr || '',
+                        exitCode: error.code || 1
+                    }
+                };
+            }
+        }
+    };
+}
+// ===== MEMORY OPERATIONS (Extended) =====
+const MemoryListInputSchema = z.object({});
+export function createMemoryListTool(context) {
+    return {
+        name: 'memory_list',
+        description: 'List all memory keys',
+        inputSchema: MemoryListInputSchema,
+        execute: async () => {
+            const keys = Array.from(context.memory.keys());
+            return {
+                success: true,
+                data: {
+                    keys,
+                    total: keys.length
+                }
+            };
+        }
+    };
+}
+const MemorySearchInputSchema = z.object({
+    query: z.string().optional().describe('Search query'),
+    tags: z.array(z.string()).optional().describe('Filter by tags'),
+    categories: z.array(z.string()).optional().describe('Filter by categories'),
+    min_importance: z.number().optional().describe('Minimum importance level'),
+    max_results: z.number().optional().describe('Maximum results to return')
+});
+export function createMemorySearchTool(context) {
+    return {
+        name: 'memory_search',
+        description: 'Search memory by query, tags, or categories',
+        inputSchema: MemorySearchInputSchema,
+        execute: async (params) => {
+            const maxResults = params.max_results || 10;
+            const memories = Array.from(context.memory.entries())
+                .filter(([key, value]) => {
+                if (params.query && !key.includes(params.query) && !value.content.includes(params.query)) {
+                    return false;
+                }
+                if (params.tags && params.tags.length > 0) {
+                    const memoryTags = value.tags || [];
+                    if (!params.tags.every(tag => memoryTags.includes(tag))) {
+                        return false;
+                    }
+                }
+                if (params.categories && params.categories.length > 0) {
+                    if (!params.categories.includes(value.category)) {
+                        return false;
+                    }
+                }
+                if (params.min_importance && value.importance < params.min_importance) {
+                    return false;
+                }
+                return true;
+            })
+                .slice(0, maxResults)
+                .map(([key, value]) => ({ key, ...value }));
+            return {
+                success: true,
+                data: {
+                    memories,
+                    total: memories.length
+                }
+            };
+        }
+    };
+}
+const MemoryUpdateInputSchema = z.object({
+    key: z.string().describe('Memory key to update'),
+    content: z.string().describe('New content'),
+    importance: z.number().optional().describe('Updated importance level'),
+    merge_mode: z.enum(['replace', 'append']).optional().describe('How to merge content')
+});
+export function createMemoryUpdateTool(context) {
+    return {
+        name: 'memory_update',
+        description: 'Update existing memory content',
+        inputSchema: MemoryUpdateInputSchema,
+        execute: async (params) => {
+            const existing = context.memory.get(params.key);
+            if (!existing) {
+                return {
+                    success: false,
+                    error: `Memory key not found: ${params.key}`
+                };
+            }
+            const mergeMode = params.merge_mode || 'replace';
+            const newContent = mergeMode === 'append'
+                ? `${existing.content}\n\n${params.content}`
+                : params.content;
+            context.memory.set(params.key, {
+                ...existing,
+                content: newContent,
+                importance: params.importance !== undefined ? params.importance : existing.importance,
+                timestamp: new Date().toISOString()
+            });
+            return {
+                success: true,
+                data: { key: params.key }
+            };
+        }
+    };
+}
+// ===== WEB OPERATIONS =====
+const WebSearchInputSchema = z.object({
+    query: z.string().describe('Search query'),
+    max_results: z.number().optional().describe('Maximum number of results')
+});
+export function createWebSearchTool(_context) {
+    return {
+        name: 'web_search',
+        description: 'Search the web for information',
+        inputSchema: WebSearchInputSchema,
+        execute: async (params) => {
+            // Note: This is a stub implementation
+            // In production, you would integrate with a search API
+            return {
+                success: true,
+                data: {
+                    results: [],
+                    message: 'Web search not implemented in CLI version. Use VSCode extension for web search.'
+                }
+            };
+        }
+    };
+}
+const WebFetchInputSchema = z.object({
+    url: z.string().describe('URL to fetch'),
+    parse_html: z.boolean().optional().describe('Parse HTML to extract text')
+});
+export function createWebFetchTool(_context) {
+    return {
+        name: 'web_fetch',
+        description: 'Fetch and parse content from a URL',
+        inputSchema: WebFetchInputSchema,
+        execute: async (params) => {
+            // Note: This is a stub implementation
+            return {
+                success: false,
+                error: 'Web fetch not implemented in CLI version. Use VSCode extension for web fetch.'
+            };
+        }
+    };
+}
+// ===== CONTEXT OPERATIONS =====
+const ContextResetInputSchema = z.object({
+    reason: z.string().describe('Reason for context reset'),
+    memories_stored: z.array(z.string()).optional().describe('Memory keys stored')
+});
+export function createContextResetTool(_context) {
+    return {
+        name: 'context_reset',
+        description: 'Request a context reset to clear conversation history',
+        inputSchema: ContextResetInputSchema,
+        execute: async (params) => {
+            // In CLI, this is informational only - actual reset happens at framework level
+            return {
+                success: true,
+                data: {
+                    message: 'Context reset requested',
+                    reason: params.reason,
+                    memories_preserved: params.memories_stored?.length || 0
+                }
+            };
+        }
+    };
+}
+const ContextStatsInputSchema = z.object({});
+export function createContextStatsTool(_context) {
+    return {
+        name: 'context_stats',
+        description: 'Get statistics about current conversation context',
+        inputSchema: ContextStatsInputSchema,
+        execute: async () => {
+            // CLI stub - actual stats would come from deity framework
+            return {
+                success: true,
+                data: {
+                    message: 'Context stats not available in CLI version',
+                    approximate_tokens: 0
+                }
+            };
+        }
+    };
+}
+// ===== SUBTASK OPERATIONS =====
+const SubtaskCreatePlanInputSchema = z.object({
+    parent_task_id: z.string().describe('Parent task ID'),
+    subtasks: z.array(z.object({
+        title: z.string().describe('Subtask title'),
+        description: z.string().optional().describe('Subtask description')
+    })).describe('Array of subtasks')
+});
+export function createSubtaskCreatePlanTool(context) {
+    return {
+        name: 'subtask_create_plan',
+        description: 'Create a plan by breaking down a task into subtasks',
+        inputSchema: SubtaskCreatePlanInputSchema,
+        execute: async (params) => {
+            // Store subtasks in context (simplified implementation)
+            const subtasksKey = `subtasks_${params.parent_task_id}`;
+            const subtasksWithStatus = params.subtasks.map((st, idx) => ({
+                ...st,
+                id: `${params.parent_task_id}_sub_${idx + 1}`,
+                status: 'pending'
+            }));
+            context.memory.set(subtasksKey, {
+                content: JSON.stringify(subtasksWithStatus),
+                importance: 5,
+                category: 'planning',
+                timestamp: new Date().toISOString()
+            });
+            return {
+                success: true,
+                data: {
+                    parent_task_id: params.parent_task_id,
+                    subtasks: subtasksWithStatus,
+                    total: subtasksWithStatus.length
+                }
+            };
+        }
+    };
+}
+const SubtaskGetCurrentInputSchema = z.object({
+    parent_task_id: z.string().describe('Parent task ID')
+});
+export function createSubtaskGetCurrentTool(context) {
+    return {
+        name: 'subtask_get_current',
+        description: 'Get the current subtask to work on',
+        inputSchema: SubtaskGetCurrentInputSchema,
+        execute: async (params) => {
+            const subtasksKey = `subtasks_${params.parent_task_id}`;
+            const stored = context.memory.get(subtasksKey);
+            if (!stored) {
+                return {
+                    success: false,
+                    error: `No subtasks found for task: ${params.parent_task_id}`
+                };
+            }
+            const subtasks = JSON.parse(stored.content);
+            const current = subtasks.find((st) => st.status === 'pending');
+            return {
+                success: true,
+                data: {
+                    current,
+                    remaining: subtasks.filter((st) => st.status === 'pending').length
+                }
+            };
+        }
+    };
+}
+const SubtaskCompleteInputSchema = z.object({
+    parent_task_id: z.string().describe('Parent task ID'),
+    result: z.string().optional().describe('Summary of accomplishment')
+});
+export function createSubtaskCompleteTool(context) {
+    return {
+        name: 'subtask_complete',
+        description: 'Mark current subtask as completed',
+        inputSchema: SubtaskCompleteInputSchema,
+        execute: async (params) => {
+            const subtasksKey = `subtasks_${params.parent_task_id}`;
+            const stored = context.memory.get(subtasksKey);
+            if (!stored) {
+                return {
+                    success: false,
+                    error: `No subtasks found for task: ${params.parent_task_id}`
+                };
+            }
+            const subtasks = JSON.parse(stored.content);
+            const currentIdx = subtasks.findIndex((st) => st.status === 'pending');
+            if (currentIdx === -1) {
+                return {
+                    success: false,
+                    error: 'No pending subtasks to complete'
+                };
+            }
+            subtasks[currentIdx].status = 'completed';
+            subtasks[currentIdx].result = params.result;
+            context.memory.set(subtasksKey, {
+                ...stored,
+                content: JSON.stringify(subtasks),
+                timestamp: new Date().toISOString()
+            });
+            const nextSubtask = subtasks.find((st) => st.status === 'pending');
+            return {
+                success: true,
+                data: {
+                    completed: subtasks[currentIdx],
+                    next: nextSubtask,
+                    remaining: subtasks.filter((st) => st.status === 'pending').length
+                }
+            };
+        }
+    };
+}
+const SubtaskSkipInputSchema = z.object({
+    parent_task_id: z.string().describe('Parent task ID'),
+    reason: z.string().describe('Reason for skipping')
+});
+export function createSubtaskSkipTool(context) {
+    return {
+        name: 'subtask_skip',
+        description: 'Skip current subtask',
+        inputSchema: SubtaskSkipInputSchema,
+        execute: async (params) => {
+            const subtasksKey = `subtasks_${params.parent_task_id}`;
+            const stored = context.memory.get(subtasksKey);
+            if (!stored) {
+                return {
+                    success: false,
+                    error: `No subtasks found for task: ${params.parent_task_id}`
+                };
+            }
+            const subtasks = JSON.parse(stored.content);
+            const currentIdx = subtasks.findIndex((st) => st.status === 'pending');
+            if (currentIdx === -1) {
+                return {
+                    success: false,
+                    error: 'No pending subtasks to skip'
+                };
+            }
+            subtasks[currentIdx].status = 'skipped';
+            subtasks[currentIdx].skip_reason = params.reason;
+            context.memory.set(subtasksKey, {
+                ...stored,
+                content: JSON.stringify(subtasks),
+                timestamp: new Date().toISOString()
+            });
+            return {
+                success: true,
+                data: {
+                    skipped: subtasks[currentIdx],
+                    reason: params.reason
+                }
+            };
+        }
+    };
+}
+// ===== TASK OPERATIONS =====
+const TaskGetCurrentInputSchema = z.object({});
+export function createTaskGetCurrentTool(context) {
+    return {
+        name: 'task_get_current',
+        description: 'Get the current task that should be executed',
+        inputSchema: TaskGetCurrentInputSchema,
+        execute: async () => {
+            if (!context.plan) {
+                return {
+                    success: false,
+                    error: 'No plan created yet'
+                };
+            }
+            // Prefer in_progress tasks (already started), then pending tasks
+            let currentTask = context.plan.tasks.find((t) => t.status === 'in_progress');
+            if (!currentTask) {
+                currentTask = context.plan.tasks.find((t) => t.status === 'pending');
+                if (currentTask) {
+                    currentTask.status = 'in_progress';
+                }
+            }
+            return {
+                success: true,
+                data: {
+                    current: currentTask,
+                    total_tasks: context.plan.tasks.length,
+                    completed_tasks: context.plan.tasks.filter((t) => t.status === 'completed').length
+                }
+            };
+        }
+    };
+}
+const TaskExecuteNextInputSchema = z.object({
+    current_task_id: z.string().describe('ID of completed task'),
+    outputs_generated: z.object({}).describe('Outputs generated')
+});
+export function createTaskExecuteNextTool(context) {
+    return {
+        name: 'task_execute_next',
+        description: 'Mark current task as complete and get next task',
+        inputSchema: TaskExecuteNextInputSchema,
+        execute: async (params) => {
+            if (!context.plan) {
+                return {
+                    success: false,
+                    error: 'No plan exists'
+                };
+            }
+            let taskIdx = context.plan.tasks.findIndex((t) => t.task_id === params.current_task_id);
+            // Fallback: if exact task_id not found, complete in_progress or first pending task
+            if (taskIdx === -1) {
+                taskIdx = context.plan.tasks.findIndex((t) => t.status === 'in_progress');
+            }
+            if (taskIdx === -1) {
+                taskIdx = context.plan.tasks.findIndex((t) => t.status === 'pending');
+            }
+            if (taskIdx === -1) {
+                return {
+                    success: false,
+                    error: `Task not found: ${params.current_task_id}. All ${context.plan.tasks.length} tasks are already completed or failed.`
+                };
+            }
+            context.plan.tasks[taskIdx].status = 'completed';
+            context.plan.tasks[taskIdx].outputs = params.outputs_generated;
+            const nextTask = context.plan.tasks.find((t) => t.status === 'pending');
+            return {
+                success: true,
+                data: {
+                    completed_task_id: params.current_task_id,
+                    next_task: nextTask,
+                    progress: {
+                        completed: context.plan.tasks.filter((t) => t.status === 'completed').length,
+                        total: context.plan.tasks.length
+                    }
+                }
+            };
+        }
+    };
+}
+// ===== UI OPERATIONS (Stubs for CLI) =====
+const StartAnalysisStepInputSchema = z.object({
+    module: z.string().describe('Analysis module'),
+    title: z.string().describe('Step title'),
+    description: z.string().describe('Step description'),
+    phase: z.enum(['discovery', 'analysis', 'assessment', 'reporting']).optional()
+});
+export function createStartAnalysisStepTool(_context) {
+    return {
+        name: 'start_analysis_step',
+        description: 'Start a new analysis step (UI operation - stub in CLI)',
+        inputSchema: StartAnalysisStepInputSchema,
+        execute: async (params) => {
+            console.log(`[STEP] ${params.module}: ${params.title}`);
+            return {
+                success: true,
+                data: { message: 'Step started (CLI mode - no UI)' }
+            };
+        }
+    };
+}
+// Export all extended tools creator function
+export function createExtendedTools(context) {
+    return [
+        createFileSearchContentTool(context),
+        createTerminalExecuteTool(context),
+        // Memory tools - REMOVED: Now handled by Deity's built-in memory_store and memory_recall
+        createWebSearchTool(context),
+        createWebFetchTool(context),
+        createContextResetTool(context),
+        createContextStatsTool(context),
+        createSubtaskCreatePlanTool(context),
+        createSubtaskGetCurrentTool(context),
+        createSubtaskCompleteTool(context),
+        createSubtaskSkipTool(context),
+        createTaskGetCurrentTool(context),
+        createTaskExecuteNextTool(context),
+        createStartAnalysisStepTool(context)
+    ];
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Tool implementations for Limo CLI
+ */
+import { z } from 'zod';
+import type { Tool, ExecutionContext } from '@limo-labs/deity';
+export interface ToolContext {
+    workspaceRoot: string;
+    outputDir: string;
+    memory: Map<string, any>;
+    plan?: any;
+    reportSections: Map<string, string>;
+    diagrams: Map<string, any>;
+}
+declare const FileListInputSchema: z.ZodObject<{
+    root_path: z.ZodString;
+    pattern: z.ZodString;
+    exclude_pattern: z.ZodOptional<z.ZodString>;
+    max_results: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function createFileListTool(context: ToolContext): Tool<z.infer<typeof FileListInputSchema>, any>;
+declare const FileReadInputSchema: z.ZodObject<{
+    file_path: z.ZodString;
+}, z.core.$strip>;
+export declare function createFileReadTool(context: ToolContext): Tool<z.infer<typeof FileReadInputSchema>, any>;
+declare const PlanningCreateInputSchema: 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.ZodOptional<z.ZodArray<z.ZodString>>;
+        status: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function createPlanningCreateTool(context: ToolContext): Tool<z.infer<typeof PlanningCreateInputSchema>, any>;
+declare const ReportWriteInputSchema: z.ZodObject<{
+    section_id: z.ZodString;
+    title: z.ZodString;
+    content: z.ZodString;
+    level: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function createReportWriteTool(context: ToolContext): Tool<z.infer<typeof ReportWriteInputSchema>, any>;
+declare const ReportAddDiagramInputSchema: z.ZodObject<{
+    diagram_id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    section_id: z.ZodOptional<z.ZodString>;
+    nodes: z.ZodArray<z.ZodAny>;
+    edges: z.ZodArray<z.ZodAny>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    format: z.ZodOptional<z.ZodEnum<{
+        svg: "svg";
+    }>>;
+    source: z.ZodOptional<z.ZodString>;
+    related_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export declare function createReportAddDiagramTool(context: ToolContext): Tool<z.infer<typeof ReportAddDiagramInputSchema>, any>;
+declare const ReportFinalizeInputSchema: z.ZodObject<{
+    executive_summary: z.ZodString;
+    recommendations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare function createReportFinalizeTool(context: ToolContext): Tool<z.infer<typeof ReportFinalizeInputSchema>, any>;
+/**
+ * Create all tools including Deity's memory tools
+ *
+ * @param context Tool context
+ * @param ctx ExecutionContext with memory enabled
+ * @returns Array of all tools
+ */
+export declare function createAllTools(context: ToolContext, ctx: ExecutionContext): Tool[];
+export {};