@compilr-dev/cli 0.4.0 → 0.5.0

package/dist/index.js

@@ -9,26 +9,31 @@ process.env.FORCE_COLOR = '3';
  * A terminal-based REPL for interacting with AI agents.
  */
 import { createAgent } from './agent.js';
-import { REPL } from './repl.js';
+import { ReplV2 } from './repl-v2.js';
+import * as fs from 'fs';
 import * as diff from './ui/diff.js';
 import * as terminal from './ui/terminal.js';
 import { getStyles } from './themes/index.js';
-import { getDefaultProvider, getDefaultModel as getDefaultModelSetting } from './settings/index.js';
+import { getDefaultProvider, getDefaultModel as getDefaultModelSetting, getProjectStartupMode, getLastProjectId } from './settings/index.js';
 import { showAskUserOverlay } from './ui/ask-user-overlay.js';
 import { showAskUserSimpleOverlay } from './ui/ask-user-simple-overlay.js';
 import { showPermissionOverlay } from './ui/permission-overlay.js';
 import { showIterationLimitOverlay } from './ui/iteration-limit-overlay.js';
+import { showGuardrailOverlay } from './ui/guardrail-overlay.js';
 import { showKeysOverlay } from './ui/keys-overlay.js';
+import { projectRepository, workItemRepository } from './db/repositories/index.js';
+import { setActiveProject } from './tools/project-db.js';
+import { getFullGuidedPrompt, shouldInjectGuidedContext, } from './workflow/index.js';
 import { hasApiKey, settingsProviderToCredentialKey } from './utils/credentials.js';
-import { printLogo } from './ui/conversation.js';
 import { loadProjectMemory, formatBytes, getSizeCategory } from './utils/project-memory.js';
+import { getGlobalAnchorManager, getAnchorManager } from './anchors/index.js';
 import { registerAskUserHandler, registerAskUserSimpleHandler, setOverlayActive, } from './shared-handlers.js';
 import chalk from 'chalk';
 const sharedState = { mode: 'normal', pendingSuggestion: null };
 // =============================================================================
 // Version
 // =============================================================================
-const VERSION = '0.0.1';
+const VERSION = '0.4.0';
 function parseArgs() {
     const args = process.argv.slice(2);
     const options = {};
@@ -83,8 +88,6 @@ Examples:
 // =============================================================================
 async function main() {
     const options = parseArgs();
-    // Show logo immediately on startup
-    printLogo(VERSION);
     // Resolve provider: CLI arg > settings > auto-detect
     const settingsProvider = getDefaultProvider();
     const provider = options.provider
@@ -136,13 +139,146 @@ async function main() {
         }
         projectContext = projectMemory.content;
     }
+    // ==========================================================================
+    // Load guided mode context from database (if project uses guided mode)
+    // ==========================================================================
+    let guidedModeContext;
+    // Determine which project to load based on projectStartup setting
+    const projectStartupMode = getProjectStartupMode();
+    let dbProject = null;
+    if (projectStartupMode === 'last') {
+        // Try to load the last opened project
+        const lastProjectId = getLastProjectId();
+        if (lastProjectId !== null) {
+            dbProject = projectRepository.getById(lastProjectId);
+            // If last project no longer exists (deleted), don't auto-load any project
+        }
+        // If no lastProjectId remembered, don't auto-load any project
+    }
+    // else projectStartupMode === 'off': don't auto-load any project
+    if (dbProject) {
+        // Set as active project for tools to use
+        setActiveProject({ id: dbProject.id, name: dbProject.name, displayName: dbProject.displayName, path: dbProject.path });
+        // If in guided mode, generate context
+        if (shouldInjectGuidedContext(dbProject)) {
+            // Get work item counts
+            const statusCounts = workItemRepository.getStatusCounts(dbProject.id);
+            // Get current work item if set
+            let currentItem = null;
+            if (dbProject.currentItemId) {
+                currentItem = workItemRepository.getByItemId(dbProject.id, dbProject.currentItemId);
+            }
+            else {
+                // Look for any in-progress item
+                const inProgressItems = workItemRepository.query({
+                    project_id: dbProject.id,
+                    status: 'in_progress',
+                    limit: 1,
+                });
+                if (inProgressItems.items.length > 0) {
+                    currentItem = inProgressItems.items[0];
+                }
+            }
+            // Generate guided mode context
+            const contextOptions = {
+                project: dbProject,
+                currentItem,
+                backlogCount: statusCounts.backlog,
+                inProgressCount: statusCounts.in_progress,
+                completedCount: statusCounts.completed,
+            };
+            guidedModeContext = getFullGuidedPrompt(contextOptions);
+        }
+    }
+    // ==========================================================================
+    // Load persisted anchors (critical info that survives compaction)
+    // ==========================================================================
+    // Load global anchors (always)
+    const globalAnchors = getGlobalAnchorManager().getAll({ scope: 'persistent' });
+    // Load project-specific anchors (if in a tracked project)
+    const projectAnchors = dbProject
+        ? getAnchorManager(String(dbProject.id)).getAll({ scope: 'persistent' })
+        : [];
+    // Combine into persistedAnchors array for agent
+    const persistedAnchors = [
+        ...globalAnchors.map((a) => ({
+            id: a.id,
+            content: a.content,
+            priority: a.priority,
+            scope: a.scope,
+            tags: a.tags,
+        })),
+        ...projectAnchors.map((a) => ({
+            id: a.id,
+            content: a.content,
+            priority: a.priority,
+            scope: a.scope,
+            tags: a.tags,
+            projectId: String(dbProject?.id),
+        })),
+    ];
+    // ==========================================================================
+    // Create handlers and agent BEFORE menu (so menu can access agent info)
+    // ==========================================================================
     // Create permission handler that respects mode state
     const onPermissionRequest = async (request) => {
         // Auto-accept mode: allow everything without prompting
         if (sharedState.mode === 'auto-accept') {
             return true;
         }
-        // Normal mode: show permission prompt
+        // V2 mode: use TerminalUI overlay system
+        if (sharedState.showPermissionOverlayV2) {
+            // Flush any accumulated text BEFORE showing the permission overlay
+            // This ensures agent's "I'll help you..." text appears before the permission prompt
+            sharedState.flushTextBuffer?.();
+            // For edit operations, pre-render diff lines for the overlay
+            let diffLines;
+            if (request.toolName === 'edit') {
+                // DEBUG: Write to file to see field names (temporary)
+                fs.appendFileSync('/tmp/compilr-debug.log', `[${new Date().toISOString()}] edit request.input: ${JSON.stringify(request.input)}\n`);
+                const filePath = ((typeof request.input.filePath === 'string' ? request.input.filePath : null) ||
+                    (typeof request.input.file_path === 'string' ? request.input.file_path : null) ||
+                    (typeof request.input.path === 'string' ? request.input.path : null) || '');
+                const oldText = ((typeof request.input.oldString === 'string' ? request.input.oldString : null) ||
+                    (typeof request.input.old_string === 'string' ? request.input.old_string : null) ||
+                    (typeof request.input.old_text === 'string' ? request.input.old_text : null) || '');
+                const newText = ((typeof request.input.newString === 'string' ? request.input.newString : null) ||
+                    (typeof request.input.new_string === 'string' ? request.input.new_string : null) ||
+                    (typeof request.input.new_text === 'string' ? request.input.new_text : null) || '');
+                const replaceAll = Boolean(request.input.replaceAll);
+                // DEBUG: Log extracted values
+                fs.appendFileSync('/tmp/compilr-debug.log', `  filePath: "${filePath}", oldText len: ${String(oldText.length)}, newText len: ${String(newText.length)}, replaceAll: ${String(replaceAll)}\n`);
+                if (filePath && oldText && newText) {
+                    const editDiff = diff.generateEditDiff(filePath, oldText, newText, replaceAll);
+                    fs.appendFileSync('/tmp/compilr-debug.log', `  editDiff: ${editDiff ? `${String(editDiff.lines.length)} lines` : 'null'}\n`);
+                    if (editDiff) {
+                        const s = getStyles();
+                        diffLines = [
+                            s.warning('● ') + chalk.bold(`Edit(${filePath.split('/').pop() ?? 'unknown'})`),
+                            diff.formatDiffHeader(filePath, editDiff.additions, editDiff.removals),
+                            ...editDiff.lines,
+                        ];
+                    }
+                }
+            }
+            const result = await sharedState.showPermissionOverlayV2({
+                toolName: request.toolName,
+                args: request.input,
+                description: request.description,
+                diffLines,
+            });
+            // Handle result
+            if (result === 'allow-always') {
+                sharedState.grantSession?.(request.toolName);
+                sharedState.setMode?.('auto-accept');
+            }
+            // null result means cancelled, treat as deny
+            return result !== null && result !== 'deny';
+        }
+        // Legacy mode: show permission prompt with manual footer coordination
+        // Flush any accumulated text BEFORE showing the permission overlay
+        // This ensures agent's "I'll help you..." text appears before the permission prompt
+        sharedState.flushTextBuffer?.();
         // Pause footer to prevent interference with the overlay
         sharedState.pauseFooter?.();
         // Set overlay active flag so REPL buffers any text output
@@ -204,8 +340,20 @@ async function main() {
     };
     // Register ask_user handler that coordinates with footer
     registerAskUserHandler(async (input) => {
-        // Pause footer to prevent interference with the overlay
+        // Wait for event loop to process any pending tool_end events
+        await new Promise((resolve) => setImmediate(resolve));
+        // Flush any accumulated text BEFORE showing the overlay
+        sharedState.flushTextBuffer?.();
+        // V2 mode: use TerminalUI overlay system
+        if (sharedState.showAskUserOverlayV2) {
+            return sharedState.showAskUserOverlayV2({
+                questions: input.questions,
+                context: input.context,
+            });
+        }
+        // Legacy mode: pause footer and use InlineOverlay
         sharedState.pauseFooter?.();
+        setOverlayActive(true);
         try {
             // Show the overlay and get answers
             const result = await showAskUserOverlay({
@@ -215,14 +363,28 @@ async function main() {
             return result;
         }
         finally {
-            // Resume footer after overlay closes
+            // Clear overlay active flag and resume footer
+            setOverlayActive(false);
             sharedState.resumeFooter?.();
         }
     });
     // Register ask_user_simple handler for smaller models (flat schema)
     registerAskUserSimpleHandler(async (input) => {
-        // Pause footer to prevent interference with the overlay
+        // Wait for event loop to process any pending tool_end events
+        await new Promise((resolve) => setImmediate(resolve));
+        // Flush any accumulated text BEFORE showing the overlay
+        sharedState.flushTextBuffer?.();
+        // V2 mode: use TerminalUI overlay system
+        if (sharedState.showAskUserSimpleOverlayV2) {
+            return sharedState.showAskUserSimpleOverlayV2({
+                question: input.question,
+                options: input.options,
+                allowCustom: input.allowCustom,
+            });
+        }
+        // Legacy mode: pause footer and use InlineOverlay
         sharedState.pauseFooter?.();
+        setOverlayActive(true);
         try {
             // Show the simple overlay and get answer
             const result = await showAskUserSimpleOverlay({
@@ -233,13 +395,30 @@ async function main() {
             return result;
         }
         finally {
-            // Resume footer after overlay closes
+            // Clear overlay active flag and resume footer
+            setOverlayActive(false);
             sharedState.resumeFooter?.();
         }
     });
     // Create iteration limit handler that shows overlay
     const onIterationLimitReached = async (context) => {
-        // Pause footer to prevent interference with the overlay
+        // Wait for event loop to process any pending tool_end events
+        await new Promise((resolve) => setImmediate(resolve));
+        // Flush any accumulated text BEFORE showing the overlay
+        sharedState.flushTextBuffer?.();
+        // V2 mode: use TerminalUI overlay system
+        if (sharedState.showIterationLimitOverlayV2) {
+            const result = await sharedState.showIterationLimitOverlayV2({
+                iteration: context.iteration,
+                maxIterations: context.maxIterations,
+                toolCallCount: context.toolCallCount,
+            });
+            if (result.continue) {
+                return result.additionalIterations;
+            }
+            return false;
+        }
+        // Legacy mode: pause footer and use InlineOverlay
         sharedState.pauseFooter?.();
         setOverlayActive(true);
         try {
@@ -259,6 +438,38 @@ async function main() {
             sharedState.resumeFooter?.();
         }
     };
+    // Create guardrail confirmation handler (for risky operations that need approval)
+    const onGuardrailTriggered = async (result, context) => {
+        // Wait for event loop to process any pending events
+        await new Promise((resolve) => setImmediate(resolve));
+        // Flush any accumulated text BEFORE showing the overlay
+        sharedState.flushTextBuffer?.();
+        const overlayOptions = {
+            name: result.guardrail?.name ?? 'Unknown Guardrail',
+            message: result.guardrail?.message ?? 'This operation requires confirmation.',
+            action: result.guardrail?.action ?? 'confirm',
+            toolName: context.toolName,
+            matchedInput: result.match ?? context.inputString,
+            category: result.guardrail?.tags?.[0],
+        };
+        // V2 mode: use TerminalUI overlay system
+        if (sharedState.showGuardrailOverlayV2) {
+            const overlayResult = await sharedState.showGuardrailOverlayV2(overlayOptions);
+            return overlayResult.approved;
+        }
+        // Legacy mode: pause footer and use InlineOverlay
+        sharedState.pauseFooter?.();
+        setOverlayActive(true);
+        try {
+            const overlayResult = await showGuardrailOverlay(overlayOptions);
+            return overlayResult.approved;
+        }
+        finally {
+            // Clear overlay active flag and resume footer
+            setOverlayActive(false);
+            sharedState.resumeFooter?.();
+        }
+    };
     // Create agent with permission handler and suggestion callback
     const agent = createAgent({
         provider,
@@ -271,46 +482,94 @@ async function main() {
             sharedState.pendingSuggestion = event.action;
         },
         projectContext,
+        guidedModeContext,
+        // Anchors - library handles re-injection on every LLM call
+        enableAnchors: true,
+        persistedAnchors: persistedAnchors.length > 0 ? persistedAnchors : undefined,
+        // Guardrails - 15 built-in safety patterns for risky operations
+        // Warnings are emitted as 'guardrail_warning' events and handled by REPL
+        enableGuardrails: true,
+        onGuardrailTriggered,
+        // Subagent tracking callbacks (forwarded to footer via sharedState)
+        // Now using toolUseId for direct correlation (no more FIFO matching)
+        onSubagentStart: (toolUseId, agentType, description) => {
+            sharedState.onSubagentStart?.(toolUseId, agentType, description);
+        },
+        onSubagentEnd: (toolUseId, success, tokenCount, error) => {
+            sharedState.onSubagentEnd?.(toolUseId, success, tokenCount, error);
+        },
+        onSubagentToolUse: (toolUseId, toolName, summary) => {
+            sharedState.onSubagentToolUse?.(toolUseId, toolName, summary);
+        },
+        // Receive function to clear subagent tracking between runs
+        onSubagentTrackingReady: (clearTracking) => {
+            sharedState.clearSubagentTracking = clearTracking;
+        },
     });
     // Bind grantSession for the permission handler to use
     sharedState.grantSession = (toolName) => {
         agent.grantSessionPermission(toolName);
     };
-    // Note: setMode will be bound after REPL is created (see below)
-    // Create and run REPL with mode state setter and footer callbacks
-    const repl = new REPL({
+    // ==========================================================================
+    // Create and run REPL
+    // ==========================================================================
+    const replV2 = new ReplV2({
         agent,
         model,
         provider,
         version: VERSION,
-        showFiltering: options.showFiltering,
-        onModeChange: (mode) => {
-            sharedState.mode = mode;
+        projectName: dbProject?.displayName ?? process.cwd().split('/').pop(),
+        // Set up V2 permission overlay callback when UI is ready
+        onUIReady: (showOverlay) => {
+            sharedState.showPermissionOverlayV2 = showOverlay;
+        },
+        // Set up text buffer flush callback for V2 mode
+        onTextBufferReady: (flushTextBuffer) => {
+            sharedState.flushTextBuffer = flushTextBuffer;
+        },
+        // Set up ask_user_simple V2 overlay callback
+        onAskUserSimpleReady: (showOverlay) => {
+            sharedState.showAskUserSimpleOverlayV2 = showOverlay;
+        },
+        // Set up guardrail V2 overlay callback
+        onGuardrailReady: (showOverlay) => {
+            sharedState.showGuardrailOverlayV2 = showOverlay;
         },
-        onFooterReady: (pause, resume, setSuggestion) => {
-            sharedState.pauseFooter = pause;
-            sharedState.resumeFooter = resume;
+        // Set up ask_user V2 overlay callback
+        onAskUserReady: (showOverlay) => {
+            sharedState.showAskUserOverlayV2 = showOverlay;
+        },
+        // Set up iteration_limit V2 overlay callback
+        onIterationLimitReady: (showOverlay) => {
+            sharedState.showIterationLimitOverlayV2 = showOverlay;
+        },
+        // Set up subagent tracking callbacks for LiveRegion rendering
+        onSubagentReady: (callbacks) => {
+            sharedState.onSubagentStart = callbacks.onStart;
+            sharedState.onSubagentToolUse = callbacks.onToolUse;
+            sharedState.onSubagentEnd = callbacks.onEnd;
+        },
+        // Pass function to clear agent.ts subagent tracking between runs
+        clearSubagentTracking: sharedState.clearSubagentTracking,
+        // Set up suggestion callback when UI is ready
+        onSuggestionReady: (setSuggestion) => {
             sharedState.setSuggestion = setSuggestion;
         },
+        // Apply pending suggestions when agent finishes
         onAgentFinish: () => {
-            // Apply any pending suggestion now that agent has finished
             if (sharedState.pendingSuggestion) {
                 sharedState.setSuggestion?.(sharedState.pendingSuggestion);
                 sharedState.pendingSuggestion = null;
             }
         },
     });
-    // Bind setMode for the permission handler to use
-    sharedState.setMode = (mode) => {
-        repl.setMode(mode);
-    };
     // Handle Ctrl+C gracefully
     process.on('SIGINT', () => {
-        repl.stop();
+        replV2.stop();
         process.exit(0);
     });
-    await repl.run();
-    process.exit(0);
+    replV2.start();
+    // REPL V2 runs in event loop - the ReplV2 manages its own lifecycle
 }
 // =============================================================================
 // Provider Detection

package/dist/input-handlers/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Input Handlers - Process special input prefixes
+ *
+ * Handles input that doesn't go to the agent, like:
+ * - "#" prefix for memory notes (persistent anchors)
+ */
+export { isMemoryInput, handleMemoryInput, type MemoryHandlerContext } from './memory-handler.js';

package/dist/input-handlers/index.js

@@ -0,0 +1,7 @@
+/**
+ * Input Handlers - Process special input prefixes
+ *
+ * Handles input that doesn't go to the agent, like:
+ * - "#" prefix for memory notes (persistent anchors)
+ */
+export { isMemoryInput, handleMemoryInput } from './memory-handler.js';

package/dist/input-handlers/memory-handler.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Memory Handler - Process "# note" input prefix
+ *
+ * Creates persistent anchors from user input prefixed with "#".
+ * Auto-detects priority based on keywords in the note.
+ */
+import type { Agent } from '@compilr-dev/agents';
+import type { Footer } from '../ui/footer.js';
+export interface MemoryHandlerContext {
+    agent: Agent;
+    footer: Footer;
+}
+/**
+ * Check if input is a memory note (starts with #)
+ */
+export declare function isMemoryInput(input: string): boolean;
+/**
+ * Handle memory note input ("# note text")
+ *
+ * Creates a persistent anchor from the note, stored either globally or
+ * in the current project if one is active.
+ *
+ * @param input - The full input string (including # prefix)
+ * @param ctx - Handler context with agent and footer
+ */
+export declare function handleMemoryInput(input: string, ctx: MemoryHandlerContext): void;

package/dist/input-handlers/memory-handler.js

@@ -0,0 +1,68 @@
+/**
+ * Memory Handler - Process "# note" input prefix
+ *
+ * Creates persistent anchors from user input prefixed with "#".
+ * Auto-detects priority based on keywords in the note.
+ */
+import { addAnchor } from '../anchors/index.js';
+import { getActiveProject } from '../tools/project-db.js';
+import * as conversation from '../ui/conversation.js';
+import * as terminal from '../ui/terminal.js';
+// =============================================================================
+// Handler
+// =============================================================================
+/**
+ * Check if input is a memory note (starts with #)
+ */
+export function isMemoryInput(input) {
+    return input.startsWith('#') && input.length > 1 && input.slice(1).trim().length > 0;
+}
+/**
+ * Handle memory note input ("# note text")
+ *
+ * Creates a persistent anchor from the note, stored either globally or
+ * in the current project if one is active.
+ *
+ * @param input - The full input string (including # prefix)
+ * @param ctx - Handler context with agent and footer
+ */
+export function handleMemoryInput(input, ctx) {
+    const note = input.slice(1).trim();
+    // Get active project to determine scope
+    const activeProject = getActiveProject();
+    const projectId = activeProject?.id;
+    // Determine priority based on keywords
+    let priority = 'info';
+    const lowerNote = note.toLowerCase();
+    if (lowerNote.includes('never') || lowerNote.includes('always') || lowerNote.includes('must')) {
+        priority = 'safety';
+    }
+    if (lowerNote.includes('critical') || lowerNote.includes('important')) {
+        priority = 'critical';
+    }
+    // Create the anchor (persisted to file)
+    const anchor = addAnchor({
+        content: note,
+        priority,
+        scope: 'persistent',
+        projectId: projectId?.toString(),
+        tags: ['user-note'],
+    });
+    // Show confirmation
+    ctx.footer.clearForOutput();
+    const scope = activeProject ? `project "${activeProject.displayName || activeProject.name}"` : 'global';
+    const priorityLabel = priority === 'info' ? '' : ` (${priority})`;
+    conversation.printSuccess(`Saved${priorityLabel}: "${note.length > 50 ? note.slice(0, 47) + '...' : note}" → ${scope}`);
+    terminal.writeLine('');
+    ctx.footer.forceRender();
+    // Also add to agent's anchor manager if enabled (for current session)
+    if (ctx.agent.getAnchorManager()) {
+        ctx.agent.addAnchor({
+            id: anchor.id,
+            content: note,
+            priority,
+            scope: 'persistent',
+            tags: ['user-note'],
+        });
+    }
+}

package/dist/repl-helpers.d.ts

@@ -0,0 +1,63 @@
+/**
+ * REPL Helper Functions
+ *
+ * Standalone utility functions extracted from repl.ts to reduce file size
+ * and improve maintainability. These functions support the REPL but don't
+ * depend on REPL instance state.
+ */
+import type { BacklogItem } from './tools/backlog.js';
+/**
+ * Keyword patterns for tool selection based on user input.
+ * Maps tool names to keywords that suggest the tool should be used.
+ */
+export declare const TOOL_KEYWORDS: Record<string, string[]>;
+/**
+ * Select relevant tool names based on user input intent.
+ * Returns all tools if input is short or a question.
+ */
+export declare function selectToolNamesByIntent(input: string, allToolNames: string[]): string[];
+/**
+ * Priority order for sorting backlog items (most important first).
+ */
+export declare const PRIORITY_ORDER: string[];
+/**
+ * Result of detecting a compilr project structure.
+ */
+export interface CompilrProjectInfo {
+    found: boolean;
+    backlogPath: string | null;
+    projectPath: string | null;
+    docsPath: string | null;
+}
+/**
+ * Detect if we're in a compilr project (has .compilr folder or -docs sibling).
+ * Returns project path from config.json if available.
+ */
+export declare function detectCompilrProject(): CompilrProjectInfo;
+/**
+ * Check if backlog has any items using the shared parser.
+ */
+export declare function hasBacklogItems(backlogPath: string | null): boolean;
+/**
+ * Get skill prompt by name from builtinSkills or codingSkills.
+ */
+export declare function getSkillPrompt(name: string): string | null;
+/**
+ * Select the best backlog item to build.
+ * If requestedId is provided, finds that specific item.
+ * Otherwise, auto-picks the highest priority 📋 item.
+ */
+export declare function selectBuildItem(items: BacklogItem[], requestedId?: string): BacklogItem | null;
+/**
+ * Find dependency IDs mentioned in item title/description.
+ * Looks for patterns like "depends on REQ-001", "blocked by BUG-002", etc.
+ */
+export declare function findDependencies(item: BacklogItem): string[];
+/**
+ * Get list of dependencies that are not yet completed.
+ */
+export declare function getUnmetDependencies(item: BacklogItem, allItems: BacklogItem[]): BacklogItem[];
+/**
+ * Check if the project has a code foundation (src/, package.json, etc.)
+ */
+export declare function hasProjectFoundation(): boolean;