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

package/dist/tools/additional.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Additional tool implementations for Limo CLI
+ * UI operations and code analysis tools
+ */
+import { z } from 'zod';
+import type { Tool } from '@limo-labs/deity';
+import type { ToolContext } from './index.js';
+declare const AddFindingsInputSchema: z.ZodObject<{
+    findings: z.ZodArray<z.ZodAny>;
+    recommendations: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    code_snippets: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    executive_summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createAddFindingsTool(_context: ToolContext): Tool<z.infer<typeof AddFindingsInputSchema>, any>;
+declare const FinishCurrentStepInputSchema: z.ZodObject<{
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createFinishCurrentStepTool(_context: ToolContext): Tool<z.infer<typeof FinishCurrentStepInputSchema>, any>;
+declare const SidebarUpdateStepInputSchema: z.ZodObject<{
+    step_id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    phase: z.ZodEnum<{
+        discovery: "discovery";
+        analysis: "analysis";
+        assessment: "assessment";
+        reporting: "reporting";
+    }>;
+    status: z.ZodEnum<{
+        in_progress: "in_progress";
+        completed: "completed";
+        skipped: "skipped";
+        blocked: "blocked";
+    }>;
+    details: z.ZodOptional<z.ZodAny>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createSidebarUpdateStepTool(_context: ToolContext): Tool<z.infer<typeof SidebarUpdateStepInputSchema>, any>;
+declare const WebviewUpdateContentInputSchema: z.ZodObject<{
+    step_id: z.ZodString;
+    content: z.ZodAny;
+}, z.core.$strip>;
+export declare function createWebviewUpdateContentTool(_context: ToolContext): Tool<z.infer<typeof WebviewUpdateContentInputSchema>, any>;
+declare const UserNotifyInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>>;
+    actions: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+}, z.core.$strip>;
+export declare function createUserNotifyTool(_context: ToolContext): Tool<z.infer<typeof UserNotifyInputSchema>, any>;
+declare const UserAskInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    options: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    can_pick_many: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare function createUserAskTool(_context: ToolContext): Tool<z.infer<typeof UserAskInputSchema>, any>;
+declare const ReportAddAssetInputSchema: z.ZodObject<{
+    asset_id: z.ZodString;
+    type: z.ZodEnum<{
+        chart: "chart";
+        table: "table";
+    }>;
+    title: z.ZodString;
+    data: z.ZodAny;
+}, z.core.$strip>;
+export declare function createReportAddAssetTool(context: ToolContext): Tool<z.infer<typeof ReportAddAssetInputSchema>, any>;
+declare const LimoConfigReadInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare function createLimoConfigReadTool(context: ToolContext): Tool<z.infer<typeof LimoConfigReadInputSchema>, any>;
+declare const MemoryPromoteToCoreInputSchema: z.ZodObject<{
+    key: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createMemoryPromoteToCoreTool(context: ToolContext): Tool<z.infer<typeof MemoryPromoteToCoreInputSchema>, any>;
+declare const MemoryDemoteFromCoreInputSchema: z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$strip>;
+export declare function createMemoryDemoteFromCoreTool(context: ToolContext): Tool<z.infer<typeof MemoryDemoteFromCoreInputSchema>, any>;
+declare const MemoryHealthCheckInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare function createMemoryHealthCheckTool(context: ToolContext): Tool<z.infer<typeof MemoryHealthCheckInputSchema>, any>;
+declare const CodeAnalyzeDeadInputSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        file: "file";
+        workspace: "workspace";
+        folder: "folder";
+    }>;
+    target: z.ZodOptional<z.ZodString>;
+    filePattern: z.ZodOptional<z.ZodString>;
+    excludePatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    analysisDepth: z.ZodEnum<{
+        quick: "quick";
+        thorough: "thorough";
+    }>;
+}, z.core.$strip>;
+export declare function createCodeAnalyzeDeadTool(_context: ToolContext): Tool<z.infer<typeof CodeAnalyzeDeadInputSchema>, any>;
+declare const CodeCheckReferencesInputSchema: z.ZodObject<{
+    file: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+    symbolName: z.ZodString;
+}, z.core.$strip>;
+export declare function createCodeCheckReferencesTool(_context: ToolContext): Tool<z.infer<typeof CodeCheckReferencesInputSchema>, any>;
+declare const CodeAnalyzeCallGraphInputSchema: z.ZodObject<{
+    entryPoint: z.ZodString;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodEnum<{
+        dot: "dot";
+        json: "json";
+    }>;
+}, z.core.$strip>;
+export declare function createCodeAnalyzeCallGraphTool(_context: ToolContext): Tool<z.infer<typeof CodeAnalyzeCallGraphInputSchema>, any>;
+export declare function createAdditionalTools(context: ToolContext): Tool[];
+export {};

package/dist/tools/additional.js

@@ -0,0 +1,349 @@
+/**
+ * Additional tool implementations for Limo CLI
+ * UI operations and code analysis tools
+ */
+import * as fs from 'fs/promises';
+import { z } from 'zod';
+// ===== UI OPERATIONS (CLI Stubs) =====
+const AddFindingsInputSchema = z.object({
+    findings: z.array(z.any()).describe('Array of findings'),
+    recommendations: z.array(z.any()).optional().describe('Array of recommendations'),
+    code_snippets: z.array(z.any()).optional().describe('Array of code snippets'),
+    executive_summary: z.string().optional().describe('Executive summary')
+});
+export function createAddFindingsTool(_context) {
+    return {
+        name: 'add_findings',
+        description: 'Add findings to current analysis step (CLI stub)',
+        inputSchema: AddFindingsInputSchema,
+        execute: async (params) => {
+            console.log(`[FINDINGS] Added ${params.findings.length} findings`);
+            return {
+                success: true,
+                data: { message: 'Findings recorded (CLI mode)' }
+            };
+        }
+    };
+}
+const FinishCurrentStepInputSchema = z.object({
+    summary: z.string().optional().describe('Final summary')
+});
+export function createFinishCurrentStepTool(_context) {
+    return {
+        name: 'finish_current_step',
+        description: 'Finish current analysis step (CLI stub)',
+        inputSchema: FinishCurrentStepInputSchema,
+        execute: async (params) => {
+            if (params.summary) {
+                console.log(`[SUMMARY] ${params.summary}`);
+            }
+            return {
+                success: true,
+                data: { message: 'Step finished (CLI mode)' }
+            };
+        }
+    };
+}
+const SidebarUpdateStepInputSchema = z.object({
+    step_id: z.string().describe('Step ID'),
+    title: z.string().describe('Step title'),
+    description: z.string().describe('Step description'),
+    phase: z.enum(['discovery', 'analysis', 'assessment', 'reporting']).describe('Analysis phase'),
+    status: z.enum(['in_progress', 'completed', 'blocked', 'skipped']).describe('Step status'),
+    details: z.any().optional().describe('Additional details'),
+    error: z.string().optional().describe('Error message')
+});
+export function createSidebarUpdateStepTool(_context) {
+    return {
+        name: 'sidebar_update_step',
+        description: 'Update sidebar step (CLI stub)',
+        inputSchema: SidebarUpdateStepInputSchema,
+        execute: async (params) => {
+            console.log(`[SIDEBAR] ${params.step_id}: ${params.status}`);
+            return {
+                success: true,
+                data: { message: 'Sidebar updated (CLI mode)' }
+            };
+        }
+    };
+}
+const WebviewUpdateContentInputSchema = z.object({
+    step_id: z.string().describe('Step ID'),
+    content: z.any().describe('Content object')
+});
+export function createWebviewUpdateContentTool(_context) {
+    return {
+        name: 'webview_update_content',
+        description: 'Update webview content (CLI stub)',
+        inputSchema: WebviewUpdateContentInputSchema,
+        execute: async (params) => {
+            console.log(`[WEBVIEW] Updated content for ${params.step_id}`);
+            return {
+                success: true,
+                data: { message: 'Webview updated (CLI mode)' }
+            };
+        }
+    };
+}
+const UserNotifyInputSchema = z.object({
+    message: z.string().describe('Notification message'),
+    type: z.enum(['info', 'warning', 'error']).optional().describe('Notification type'),
+    actions: z.array(z.any()).optional().describe('Action buttons')
+});
+export function createUserNotifyTool(_context) {
+    return {
+        name: 'user_notify',
+        description: 'Show notification to user',
+        inputSchema: UserNotifyInputSchema,
+        execute: async (params) => {
+            const type = params.type || 'info';
+            console.log(`[${type.toUpperCase()}] ${params.message}`);
+            return {
+                success: true,
+                data: { message: 'Notification sent (CLI mode)' }
+            };
+        }
+    };
+}
+const UserAskInputSchema = z.object({
+    prompt: z.string().describe('Question prompt'),
+    options: z.array(z.any()).optional().describe('Options for quick pick'),
+    placeholder: z.string().optional().describe('Placeholder text'),
+    can_pick_many: z.boolean().optional().describe('Allow multiple selections')
+});
+export function createUserAskTool(_context) {
+    return {
+        name: 'user_ask',
+        description: 'Ask user a question (CLI stub - returns default)',
+        inputSchema: UserAskInputSchema,
+        execute: async (params) => {
+            console.log(`[QUESTION] ${params.prompt}`);
+            return {
+                success: true,
+                data: {
+                    response: params.options?.[0] || 'yes',
+                    message: 'Auto-answered (CLI mode)'
+                }
+            };
+        }
+    };
+}
+// ===== REPORT OPERATIONS (Additional) =====
+const ReportAddAssetInputSchema = z.object({
+    asset_id: z.string().describe('Asset ID'),
+    type: z.enum(['chart', 'table']).describe('Asset type'),
+    title: z.string().describe('Asset title'),
+    data: z.any().describe('Asset data')
+});
+export function createReportAddAssetTool(context) {
+    return {
+        name: 'report_add_asset',
+        description: 'Add an asset (chart, table) to the report',
+        inputSchema: ReportAddAssetInputSchema,
+        execute: async (params) => {
+            // Store asset data
+            context.diagrams.set(params.asset_id, {
+                type: params.type,
+                title: params.title,
+                data: params.data
+            });
+            return {
+                success: true,
+                data: { asset_id: params.asset_id }
+            };
+        }
+    };
+}
+// ===== CONFIGURATION =====
+const LimoConfigReadInputSchema = z.object({});
+export function createLimoConfigReadTool(context) {
+    return {
+        name: 'config_read',
+        description: 'Read LIMO.md configuration file',
+        inputSchema: LimoConfigReadInputSchema,
+        execute: async () => {
+            try {
+                const configPath = `${context.workspaceRoot}/LIMO.md`;
+                const content = await fs.readFile(configPath, 'utf-8');
+                return {
+                    success: true,
+                    data: {
+                        exists: true,
+                        content
+                    }
+                };
+            }
+            catch (error) {
+                return {
+                    success: true,
+                    data: {
+                        exists: false,
+                        message: 'No LIMO.md configuration file found'
+                    }
+                };
+            }
+        }
+    };
+}
+// ===== MEMORY OPERATIONS (Additional) =====
+const MemoryPromoteToCoreInputSchema = z.object({
+    key: z.string().describe('Memory key to promote'),
+    reason: z.string().optional().describe('Reason for promotion')
+});
+export function createMemoryPromoteToCoreTool(context) {
+    return {
+        name: 'memory_promote_to_core',
+        description: 'Promote memory to core memory (higher priority)',
+        inputSchema: MemoryPromoteToCoreInputSchema,
+        execute: async (params) => {
+            const memory = context.memory.get(params.key);
+            if (!memory) {
+                return {
+                    success: false,
+                    error: `Memory key not found: ${params.key}`
+                };
+            }
+            // Increase importance to mark as core
+            memory.importance = Math.max(memory.importance, 8);
+            memory.core = true;
+            context.memory.set(params.key, memory);
+            return {
+                success: true,
+                data: {
+                    key: params.key,
+                    reason: params.reason
+                }
+            };
+        }
+    };
+}
+const MemoryDemoteFromCoreInputSchema = z.object({
+    key: z.string().describe('Memory key to demote')
+});
+export function createMemoryDemoteFromCoreTool(context) {
+    return {
+        name: 'memory_demote_from_core',
+        description: 'Demote memory from core memory',
+        inputSchema: MemoryDemoteFromCoreInputSchema,
+        execute: async (params) => {
+            const memory = context.memory.get(params.key);
+            if (!memory) {
+                return {
+                    success: false,
+                    error: `Memory key not found: ${params.key}`
+                };
+            }
+            memory.core = false;
+            context.memory.set(params.key, memory);
+            return {
+                success: true,
+                data: { key: params.key }
+            };
+        }
+    };
+}
+const MemoryHealthCheckInputSchema = z.object({});
+export function createMemoryHealthCheckTool(context) {
+    return {
+        name: 'memory_health_check',
+        description: 'Check memory system health',
+        inputSchema: MemoryHealthCheckInputSchema,
+        execute: async () => {
+            const memories = Array.from(context.memory.values());
+            const totalSize = memories.reduce((sum, m) => sum + m.content.length, 0);
+            const coreMemories = memories.filter(m => m.core || m.importance >= 8);
+            return {
+                success: true,
+                data: {
+                    total_memories: memories.length,
+                    core_memories: coreMemories.length,
+                    total_size_bytes: totalSize,
+                    average_importance: memories.reduce((sum, m) => sum + m.importance, 0) / memories.length || 0,
+                    health_status: 'good'
+                }
+            };
+        }
+    };
+}
+// ===== CODE ANALYSIS OPERATIONS (Stubs) =====
+const CodeAnalyzeDeadInputSchema = z.object({
+    scope: z.enum(['workspace', 'folder', 'file']).describe('Analysis scope'),
+    target: z.string().optional().describe('Target folder or file'),
+    filePattern: z.string().optional().describe('File pattern to analyze'),
+    excludePatterns: z.array(z.string()).optional().describe('Patterns to exclude'),
+    analysisDepth: z.enum(['quick', 'thorough']).describe('Analysis depth')
+});
+export function createCodeAnalyzeDeadTool(_context) {
+    return {
+        name: 'code_analyze_dead',
+        description: 'Analyze dead code (requires VSCode extension with ts-morph)',
+        inputSchema: CodeAnalyzeDeadInputSchema,
+        execute: async (params) => {
+            return {
+                success: false,
+                error: 'Dead code analysis requires VSCode extension. This is a CLI stub.',
+                data: {
+                    message: 'Please use VSCode extension for code analysis features'
+                }
+            };
+        }
+    };
+}
+const CodeCheckReferencesInputSchema = z.object({
+    file: z.string().describe('File containing symbol'),
+    line: z.number().describe('Line number'),
+    column: z.number().describe('Column number'),
+    symbolName: z.string().describe('Symbol name')
+});
+export function createCodeCheckReferencesTool(_context) {
+    return {
+        name: 'code_check_references',
+        description: 'Find references to a symbol (requires VSCode extension)',
+        inputSchema: CodeCheckReferencesInputSchema,
+        execute: async (params) => {
+            return {
+                success: false,
+                error: 'Reference checking requires VSCode extension. This is a CLI stub.'
+            };
+        }
+    };
+}
+const CodeAnalyzeCallGraphInputSchema = z.object({
+    entryPoint: z.string().describe('Entry point file'),
+    maxDepth: z.number().optional().describe('Maximum depth'),
+    format: z.enum(['dot', 'json']).describe('Output format')
+});
+export function createCodeAnalyzeCallGraphTool(_context) {
+    return {
+        name: 'code_analyze_call_graph',
+        description: 'Generate call graph (requires VSCode extension)',
+        inputSchema: CodeAnalyzeCallGraphInputSchema,
+        execute: async (params) => {
+            return {
+                success: false,
+                error: 'Call graph analysis requires VSCode extension. This is a CLI stub.'
+            };
+        }
+    };
+}
+// Export all additional tools
+export function createAdditionalTools(context) {
+    return [
+        // UI operations
+        createAddFindingsTool(context),
+        createFinishCurrentStepTool(context),
+        createSidebarUpdateStepTool(context),
+        createWebviewUpdateContentTool(context),
+        createUserNotifyTool(context),
+        createUserAskTool(context),
+        // Report operations
+        createReportAddAssetTool(context),
+        // Configuration
+        createLimoConfigReadTool(context),
+        // Memory operations - REMOVED: Now handled by Deity's built-in memory tools
+        // Code analysis (stubs)
+        createCodeAnalyzeDeadTool(context),
+        createCodeCheckReferencesTool(context),
+        createCodeAnalyzeCallGraphTool(context)
+    ];
+}

package/dist/tools/extended.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Extended tool implementations for Limo CLI
+ * Implements all missing tools from VSCode extension
+ */
+import { z } from 'zod';
+import type { Tool } from '@limo-labs/deity';
+import type { ToolContext } from './index.js';
+declare const FileSearchContentInputSchema: z.ZodObject<{
+    root_path: z.ZodString;
+    pattern: z.ZodString;
+    file_pattern: z.ZodOptional<z.ZodString>;
+    exclude_pattern: z.ZodOptional<z.ZodString>;
+    max_results: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function createFileSearchContentTool(context: ToolContext): Tool<z.infer<typeof FileSearchContentInputSchema>, any>;
+declare const TerminalExecuteInputSchema: z.ZodObject<{
+    command: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createTerminalExecuteTool(context: ToolContext): Tool<z.infer<typeof TerminalExecuteInputSchema>, any>;
+declare const MemoryListInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare function createMemoryListTool(context: ToolContext): Tool<z.infer<typeof MemoryListInputSchema>, any>;
+declare const MemorySearchInputSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    min_importance: z.ZodOptional<z.ZodNumber>;
+    max_results: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function createMemorySearchTool(context: ToolContext): Tool<z.infer<typeof MemorySearchInputSchema>, any>;
+declare const MemoryUpdateInputSchema: z.ZodObject<{
+    key: z.ZodString;
+    content: z.ZodString;
+    importance: z.ZodOptional<z.ZodNumber>;
+    merge_mode: z.ZodOptional<z.ZodEnum<{
+        replace: "replace";
+        append: "append";
+    }>>;
+}, z.core.$strip>;
+export declare function createMemoryUpdateTool(context: ToolContext): Tool<z.infer<typeof MemoryUpdateInputSchema>, any>;
+declare const WebSearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    max_results: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function createWebSearchTool(_context: ToolContext): Tool<z.infer<typeof WebSearchInputSchema>, any>;
+declare const WebFetchInputSchema: z.ZodObject<{
+    url: z.ZodString;
+    parse_html: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare function createWebFetchTool(_context: ToolContext): Tool<z.infer<typeof WebFetchInputSchema>, any>;
+declare const ContextResetInputSchema: z.ZodObject<{
+    reason: z.ZodString;
+    memories_stored: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare function createContextResetTool(_context: ToolContext): Tool<z.infer<typeof ContextResetInputSchema>, any>;
+declare const ContextStatsInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare function createContextStatsTool(_context: ToolContext): Tool<z.infer<typeof ContextStatsInputSchema>, any>;
+declare const SubtaskCreatePlanInputSchema: z.ZodObject<{
+    parent_task_id: z.ZodString;
+    subtasks: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function createSubtaskCreatePlanTool(context: ToolContext): Tool<z.infer<typeof SubtaskCreatePlanInputSchema>, any>;
+declare const SubtaskGetCurrentInputSchema: z.ZodObject<{
+    parent_task_id: z.ZodString;
+}, z.core.$strip>;
+export declare function createSubtaskGetCurrentTool(context: ToolContext): Tool<z.infer<typeof SubtaskGetCurrentInputSchema>, any>;
+declare const SubtaskCompleteInputSchema: z.ZodObject<{
+    parent_task_id: z.ZodString;
+    result: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createSubtaskCompleteTool(context: ToolContext): Tool<z.infer<typeof SubtaskCompleteInputSchema>, any>;
+declare const SubtaskSkipInputSchema: z.ZodObject<{
+    parent_task_id: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare function createSubtaskSkipTool(context: ToolContext): Tool<z.infer<typeof SubtaskSkipInputSchema>, any>;
+declare const TaskGetCurrentInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare function createTaskGetCurrentTool(context: ToolContext): Tool<z.infer<typeof TaskGetCurrentInputSchema>, any>;
+declare const TaskExecuteNextInputSchema: z.ZodObject<{
+    current_task_id: z.ZodString;
+    outputs_generated: z.ZodObject<{}, z.core.$strip>;
+}, z.core.$strip>;
+export declare function createTaskExecuteNextTool(context: ToolContext): Tool<z.infer<typeof TaskExecuteNextInputSchema>, any>;
+declare const StartAnalysisStepInputSchema: z.ZodObject<{
+    module: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    phase: z.ZodOptional<z.ZodEnum<{
+        discovery: "discovery";
+        analysis: "analysis";
+        assessment: "assessment";
+        reporting: "reporting";
+    }>>;
+}, z.core.$strip>;
+export declare function createStartAnalysisStepTool(_context: ToolContext): Tool<z.infer<typeof StartAnalysisStepInputSchema>, any>;
+export declare function createExtendedTools(context: ToolContext): Tool[];
+export {};