@compilr-dev/cli 0.4.0 → 0.5.0

package/dist/workflow/step-criteria.js

@@ -0,0 +1,150 @@
+/**
+ * Step Criteria - Defines exit criteria for each guided workflow step
+ *
+ * Each step has:
+ * - Human-readable exit criteria (for system prompt)
+ * - Success indicators (what agent looks for)
+ * - Configuration (max attempts, auto-advance)
+ */
+/**
+ * Step order - defines valid step progression
+ */
+export const STEP_ORDER = ['plan', 'implement', 'test', 'commit', 'review'];
+/**
+ * Get the next step in the workflow
+ */
+export function getNextStep(current) {
+    if (current === null)
+        return 'plan';
+    const idx = STEP_ORDER.indexOf(current);
+    if (idx === -1 || idx >= STEP_ORDER.length - 1)
+        return 'complete';
+    return STEP_ORDER[idx + 1];
+}
+/**
+ * Get the previous step in the workflow
+ */
+export function getPreviousStep(current) {
+    const idx = STEP_ORDER.indexOf(current);
+    if (idx <= 0)
+        return null;
+    return STEP_ORDER[idx - 1];
+}
+/**
+ * Get step number (1-indexed for display)
+ */
+export function getStepNumber(step) {
+    return STEP_ORDER.indexOf(step) + 1;
+}
+/**
+ * Check if step transition is valid (can only advance to next step)
+ */
+export function isValidTransition(from, to) {
+    const nextStep = getNextStep(from);
+    return nextStep === to;
+}
+/**
+ * Guided step criteria definitions
+ */
+export const GUIDED_STEP_CRITERIA = [
+    {
+        step: 'plan',
+        exitCriteria: [
+            'Requirements understood and documented',
+            'Approach designed (files to create/modify identified)',
+            'Edge cases considered',
+        ],
+        successIndicators: [
+            'Agent has written a plan in conversation or document',
+            'Agent has identified target files',
+            'No blocking questions remain',
+        ],
+        autoAdvance: true,
+        nextActionHint: 'Start implementing the planned changes',
+    },
+    {
+        step: 'implement',
+        exitCriteria: [
+            'All planned code changes completed',
+            'No placeholder TODOs left',
+            'Code compiles/lints cleanly',
+        ],
+        successIndicators: [
+            'writeFile/edit tools have been called',
+            'Lint command passes (if available)',
+            'No obvious errors in code',
+        ],
+        autoAdvance: true,
+        nextActionHint: 'Run tests to verify the implementation',
+    },
+    {
+        step: 'test',
+        exitCriteria: [
+            'All tests pass',
+            'OR: User overrides after 2 failed attempts',
+        ],
+        successIndicators: [
+            'Test command exits with 0',
+            'All test assertions pass',
+        ],
+        maxAttempts: 2,
+        autoAdvance: true, // Only if tests pass
+        nextActionHint: 'Commit the changes with a proper message',
+    },
+    {
+        step: 'commit',
+        exitCriteria: [
+            'Changes committed with proper message',
+            'Commit hash captured',
+        ],
+        successIndicators: [
+            'git commit command succeeded',
+            'Commit hash in output',
+        ],
+        autoAdvance: true,
+        nextActionHint: 'Review and confirm ready for next item',
+    },
+    {
+        step: 'review',
+        exitCriteria: [
+            'User confirms ready for next item',
+            'OR: User wants to do something else',
+        ],
+        successIndicators: [
+            'User says "yes", "next", "continue"',
+            'User explicitly approves',
+        ],
+        autoAdvance: false, // Always wait for user
+        nextActionHint: 'Pick the next work item from backlog',
+    },
+];
+/**
+ * Get criteria for a specific step
+ */
+export function getStepCriteria(step) {
+    const criteria = GUIDED_STEP_CRITERIA.find((c) => c.step === step);
+    if (!criteria) {
+        throw new Error(`No criteria found for step: ${step}`);
+    }
+    return criteria;
+}
+/**
+ * Get human-readable step description for messages
+ */
+export function getStepDescription(step) {
+    const descriptions = {
+        plan: 'Planning - understanding requirements and designing approach',
+        implement: 'Implementing - writing code and making changes',
+        test: 'Testing - running tests and fixing failures',
+        commit: 'Committing - creating git commit with changes',
+        review: 'Reviewing - confirming completion and next steps',
+    };
+    return descriptions[step];
+}
+/**
+ * Format step for display (e.g., "IMPLEMENT (2 of 5)")
+ */
+export function formatStepDisplay(step) {
+    const num = getStepNumber(step);
+    return `${step.toUpperCase()} (${String(num)} of ${String(STEP_ORDER.length)})`;
+}

package/dist/workflow/step-tracker.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Step Tracker - In-memory tracking of step attempts
+ *
+ * Tracks attempts for retryable steps (like test) during a session.
+ * This is in-memory only - resets on CLI restart.
+ * Can be persisted to history table later if needed.
+ */
+import type { GuidedStep } from '../db/schema.js';
+/**
+ * Record of a single step attempt
+ */
+export interface StepAttempt {
+    /** When the attempt was made */
+    timestamp: Date;
+    /** Whether the attempt succeeded */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Additional context */
+    context?: string;
+}
+/**
+ * In-memory tracker for guided workflow step attempts
+ *
+ * Tracks attempts per item per step, enabling retry logic
+ * (e.g., "tests failed after 2 attempts, ask user").
+ */
+export declare class GuidedStepTracker {
+    /**
+     * Map: itemId -> step -> attempts[]
+     */
+    private readonly attempts;
+    /**
+     * Record an attempt for a step
+     */
+    recordAttempt(itemId: string, step: GuidedStep, success: boolean, error?: string, context?: string): void;
+    /**
+     * Get all attempts for a step
+     */
+    getAttempts(itemId: string, step: GuidedStep): StepAttempt[];
+    /**
+     * Get total attempt count for a step
+     */
+    getAttemptCount(itemId: string, step: GuidedStep): number;
+    /**
+     * Get failed attempt count for a step
+     */
+    getFailedAttemptCount(itemId: string, step: GuidedStep): number;
+    /**
+     * Get successful attempt count for a step
+     */
+    getSuccessfulAttemptCount(itemId: string, step: GuidedStep): number;
+    /**
+     * Check if we should escalate to user (max attempts exceeded)
+     */
+    shouldAskUser(itemId: string, step: GuidedStep, maxAttempts?: number): boolean;
+    /**
+     * Get remaining attempts before user escalation
+     */
+    getRemainingAttempts(itemId: string, step: GuidedStep): number | null;
+    /**
+     * Check if step has had any successful attempt
+     */
+    hasSucceeded(itemId: string, step: GuidedStep): boolean;
+    /**
+     * Get the last attempt for a step
+     */
+    getLastAttempt(itemId: string, step: GuidedStep): StepAttempt | null;
+    /**
+     * Reset attempts for a specific item (when starting fresh)
+     */
+    resetItem(itemId: string): void;
+    /**
+     * Reset attempts for a specific step (when user wants to retry)
+     */
+    resetStep(itemId: string, step: GuidedStep): void;
+    /**
+     * Clear all tracking data (e.g., on session end)
+     */
+    clear(): void;
+    /**
+     * Get a summary of attempts for an item (for display)
+     */
+    getItemSummary(itemId: string): Record<GuidedStep, {
+        total: number;
+        failed: number;
+    }> | null;
+}
+/**
+ * Singleton instance for the current session
+ */
+export declare const stepTracker: GuidedStepTracker;

package/dist/workflow/step-tracker.js

@@ -0,0 +1,141 @@
+/**
+ * Step Tracker - In-memory tracking of step attempts
+ *
+ * Tracks attempts for retryable steps (like test) during a session.
+ * This is in-memory only - resets on CLI restart.
+ * Can be persisted to history table later if needed.
+ */
+import { getStepCriteria } from './step-criteria.js';
+/**
+ * In-memory tracker for guided workflow step attempts
+ *
+ * Tracks attempts per item per step, enabling retry logic
+ * (e.g., "tests failed after 2 attempts, ask user").
+ */
+export class GuidedStepTracker {
+    /**
+     * Map: itemId -> step -> attempts[]
+     */
+    attempts = new Map();
+    /**
+     * Record an attempt for a step
+     */
+    recordAttempt(itemId, step, success, error, context) {
+        if (!this.attempts.has(itemId)) {
+            this.attempts.set(itemId, new Map());
+        }
+        const itemAttempts = this.attempts.get(itemId);
+        if (!itemAttempts)
+            return; // Should never happen, just added above
+        if (!itemAttempts.has(step)) {
+            itemAttempts.set(step, []);
+        }
+        const stepAttempts = itemAttempts.get(step);
+        if (!stepAttempts)
+            return; // Should never happen, just added above
+        stepAttempts.push({
+            timestamp: new Date(),
+            success,
+            error,
+            context,
+        });
+    }
+    /**
+     * Get all attempts for a step
+     */
+    getAttempts(itemId, step) {
+        return this.attempts.get(itemId)?.get(step) ?? [];
+    }
+    /**
+     * Get total attempt count for a step
+     */
+    getAttemptCount(itemId, step) {
+        return this.getAttempts(itemId, step).length;
+    }
+    /**
+     * Get failed attempt count for a step
+     */
+    getFailedAttemptCount(itemId, step) {
+        return this.getAttempts(itemId, step).filter((a) => !a.success).length;
+    }
+    /**
+     * Get successful attempt count for a step
+     */
+    getSuccessfulAttemptCount(itemId, step) {
+        return this.getAttempts(itemId, step).filter((a) => a.success).length;
+    }
+    /**
+     * Check if we should escalate to user (max attempts exceeded)
+     */
+    shouldAskUser(itemId, step, maxAttempts) {
+        const criteria = getStepCriteria(step);
+        const max = maxAttempts ?? criteria.maxAttempts;
+        if (max === undefined) {
+            // No retry limit defined for this step
+            return false;
+        }
+        return this.getFailedAttemptCount(itemId, step) >= max;
+    }
+    /**
+     * Get remaining attempts before user escalation
+     */
+    getRemainingAttempts(itemId, step) {
+        const criteria = getStepCriteria(step);
+        if (criteria.maxAttempts === undefined) {
+            return null; // No limit
+        }
+        return Math.max(0, criteria.maxAttempts - this.getFailedAttemptCount(itemId, step));
+    }
+    /**
+     * Check if step has had any successful attempt
+     */
+    hasSucceeded(itemId, step) {
+        return this.getSuccessfulAttemptCount(itemId, step) > 0;
+    }
+    /**
+     * Get the last attempt for a step
+     */
+    getLastAttempt(itemId, step) {
+        const attempts = this.getAttempts(itemId, step);
+        return attempts.length > 0 ? attempts[attempts.length - 1] : null;
+    }
+    /**
+     * Reset attempts for a specific item (when starting fresh)
+     */
+    resetItem(itemId) {
+        this.attempts.delete(itemId);
+    }
+    /**
+     * Reset attempts for a specific step (when user wants to retry)
+     */
+    resetStep(itemId, step) {
+        this.attempts.get(itemId)?.delete(step);
+    }
+    /**
+     * Clear all tracking data (e.g., on session end)
+     */
+    clear() {
+        this.attempts.clear();
+    }
+    /**
+     * Get a summary of attempts for an item (for display)
+     */
+    getItemSummary(itemId) {
+        const itemAttempts = this.attempts.get(itemId);
+        if (!itemAttempts) {
+            return null;
+        }
+        const summary = {};
+        for (const [step, attempts] of itemAttempts) {
+            summary[step] = {
+                total: attempts.length,
+                failed: attempts.filter((a) => !a.success).length,
+            };
+        }
+        return summary;
+    }
+}
+/**
+ * Singleton instance for the current session
+ */
+export const stepTracker = new GuidedStepTracker();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilr-dev/cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "AI-powered coding assistant CLI using @compilr-dev/agents",
   "type": "module",
   "main": "dist/index.js",
@@ -14,7 +14,11 @@
     "clean": "rm -rf dist",
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",
-    "prepublishOnly": "npm run lint && npm run build"
+    "prepublishOnly": "npm run lint && npm run build",
+    "test:scroll": "npx tsx scripts/test-scroll-regions.ts",
+    "test:scroll-input": "npx tsx scripts/test-scroll-input.ts",
+    "test:repl-v2": "npx tsx scripts/test-repl-v2.ts",
+    "test:ui": "npx tsx scripts/test-terminal-ui.ts"
   },
   "keywords": [
     "cli",
@@ -46,13 +50,16 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.30.1",
-    "@compilr-dev/agents": "^0.2.1",
-    "@compilr-dev/agents-coding": "^0.1.1",
+    "@compilr-dev/agents": "^0.3.1",
+    "@compilr-dev/agents-coding": "^1.0.2",
+    "@compilr-dev/editor-core": "^0.0.1",
+    "@compilr-dev/ui-core": "^0.0.1",
     "better-sqlite3": "^12.5.0",
     "chalk": "^5.6.2",
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",
-    "picocolors": "^1.1.1"
+    "picocolors": "^1.1.1",
+    "web-tree-sitter": "^0.20.8"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",