hone-ai 0.5.0 → 0.10.0

package/src/run.ts

@@ -1,16 +1,16 @@
-import { existsSync } from 'fs';
-import { resolve } from 'path';
-import type { AgentType } from './config';
-import { loadConfig, resolveModelForPhase } from './config';
-import { spawnAgent, isAgentAvailable } from './agent';
-import { constructPrompt, type PromptPhase } from './prompt';
-import { exitWithError, ErrorMessages, parseAgentError } from './errors';
+import { existsSync } from 'fs'
+import { resolve } from 'path'
+import type { AgentType } from './config'
+import { loadConfig, resolveModelForPhase } from './config'
+import { spawnAgent, isAgentAvailable } from './agent'
+import { constructPrompt, type PromptPhase } from './prompt'
+import { exitWithError, ErrorMessages, parseAgentError } from './errors'
 
 export interface ExecuteTasksOptions {
-  tasksFile: string;
-  iterations: number;
-  agent: AgentType;
-  skipPhase?: 'review';
+  tasksFile: string
+  iterations: number
+  agent: AgentType
+  skipPhase?: 'review'
 }
 
 /**
@@ -18,226 +18,226 @@ export interface ExecuteTasksOptions {
  * Runs for the specified number of iterations or until all tasks complete.
  */
 export async function executeTasks(options: ExecuteTasksOptions): Promise<void> {
-  const { tasksFile, iterations, agent, skipPhase } = options;
-  
+  const { tasksFile, iterations, agent, skipPhase } = options
+
   // Validate tasks file exists
-  const tasksPath = resolve(tasksFile);
+  const tasksPath = resolve(tasksFile)
   if (!existsSync(tasksPath)) {
-    const { message, details } = ErrorMessages.FILE_NOT_FOUND(tasksPath);
-    exitWithError(message, details);
+    const { message, details } = ErrorMessages.FILE_NOT_FOUND(tasksPath)
+    exitWithError(message, details)
   }
-  
+
   // Validate iterations is a positive integer
   if (!Number.isInteger(iterations) || iterations < 1) {
-    throw new Error('Iterations must be a positive integer');
+    throw new Error('Iterations must be a positive integer')
   }
-  
+
   // Check if agent is available
-  const available = await isAgentAvailable(agent);
+  const available = await isAgentAvailable(agent)
   if (!available) {
-    const { message, details } = ErrorMessages.AGENT_NOT_FOUND(agent);
-    exitWithError(message, details);
+    const { message, details } = ErrorMessages.AGENT_NOT_FOUND(agent)
+    exitWithError(message, details)
   }
-  
+
   // Extract feature name from tasks file name
-  const featureName = extractFeatureName(tasksPath);
+  const featureName = extractFeatureName(tasksPath)
   if (!featureName) {
-    throw new Error(`Could not extract feature name from tasks file: ${tasksFile}`);
+    throw new Error(`Could not extract feature name from tasks file: ${tasksFile}`)
   }
-  
+
   // Load config
-  const config = await loadConfig();
-  
-  console.log(`Using agent: ${agent}`);
-  console.log(`Tasks file: ${tasksFile}`);
-  console.log(`Feature: ${featureName}`);
-  console.log(`Iterations: ${iterations}`);
+  const config = await loadConfig()
+
+  console.log(`Using agent: ${agent}`)
+  console.log(`Tasks file: ${tasksFile}`)
+  console.log(`Feature: ${featureName}`)
+  console.log(`Iterations: ${iterations}`)
   if (skipPhase) {
-    console.log(`Skipping phase: ${skipPhase}`);
+    console.log(`Skipping phase: ${skipPhase}`)
   }
-  console.log('');
-  
+  console.log('')
+
   // Main iteration loop
   for (let i = 1; i <= iterations; i++) {
-    console.log(`\n${'='.repeat(80)}`);
-    console.log(`ITERATION ${i}/${iterations}`);
-    console.log('='.repeat(80));
-    console.log('');
-    
+    console.log(`\n${'='.repeat(80)}`)
+    console.log(`ITERATION ${i}/${iterations}`)
+    console.log('='.repeat(80))
+    console.log('')
+
     // Phase 1: Implement
-    console.log('Phase 1: Implement');
-    console.log('-'.repeat(80));
+    console.log('Phase 1: Implement')
+    console.log('-'.repeat(80))
     const implementPrompt = constructPrompt({
       phase: 'implement',
       featureName,
-      config
-    });
-    
-    const implementModel = resolveModelForPhase(config, 'implement', agent);
-    
+      config,
+    })
+
+    const implementModel = resolveModelForPhase(config, 'implement', agent)
+
     const implementResult = await spawnAgent({
       agent,
       prompt: implementPrompt,
       workingDir: process.cwd(),
-      model: implementModel
-    });
-    
+      model: implementModel,
+    })
+
     if (implementResult.exitCode !== 0) {
       // Parse error type for better user feedback
-      const errorInfo = parseAgentError(implementResult.stderr, implementResult.exitCode);
-      
+      const errorInfo = parseAgentError(implementResult.stderr, implementResult.exitCode)
+
       if (errorInfo.type === 'model_unavailable') {
-        const { message, details } = ErrorMessages.MODEL_UNAVAILABLE(implementModel, agent);
-        exitWithError(message, details);
+        const { message, details } = ErrorMessages.MODEL_UNAVAILABLE(implementModel, agent)
+        exitWithError(message, details)
       } else if (errorInfo.type === 'rate_limit') {
-        const { message, details } = ErrorMessages.RATE_LIMIT_ERROR(agent, errorInfo.retryAfter);
-        exitWithError(message, details);
+        const { message, details } = ErrorMessages.RATE_LIMIT_ERROR(agent, errorInfo.retryAfter)
+        exitWithError(message, details)
       } else if (errorInfo.type === 'spawn_failed') {
-        const { message, details } = ErrorMessages.AGENT_SPAWN_FAILED(agent, implementResult.stderr);
-        exitWithError(message, details);
+        const { message, details } = ErrorMessages.AGENT_SPAWN_FAILED(agent, implementResult.stderr)
+        exitWithError(message, details)
       }
-      
+
       // Generic error message for other failures
-      console.error('\n✗ Implement phase failed');
-      console.error('\nThe agent encountered an error during task implementation.');
-      console.error('The task has NOT been marked as completed.');
-      console.error('When you run hone again, it will retry the same task.');
-      console.error(`\nAgent exit code: ${implementResult.exitCode}`);
+      console.error('\n✗ Implement phase failed')
+      console.error('\nThe agent encountered an error during task implementation.')
+      console.error('The task has NOT been marked as completed.')
+      console.error('When you run hone again, it will retry the same task.')
+      console.error(`\nAgent exit code: ${implementResult.exitCode}`)
       if (implementResult.stderr) {
-        console.error('\nError output:');
-        console.error(implementResult.stderr);
+        console.error('\nError output:')
+        console.error(implementResult.stderr)
       }
-      throw new Error(`Implement phase failed with exit code ${implementResult.exitCode}`);
+      throw new Error(`Implement phase failed with exit code ${implementResult.exitCode}`)
     }
-    
+
     // Extract task ID from output
-    const completedTaskId = extractTaskId(implementResult.stdout, 'TASK_COMPLETED');
+    const completedTaskId = extractTaskId(implementResult.stdout, 'TASK_COMPLETED')
     if (completedTaskId) {
-      console.log(`\n✓ Task ${completedTaskId} implementation complete`);
+      console.log(`\n✓ Task ${completedTaskId} implementation complete`)
     } else {
-      console.warn('\n⚠ Warning: No TASK_COMPLETED marker found in output');
+      console.warn('\n⚠ Warning: No TASK_COMPLETED marker found in output')
     }
-    
+
     // Check if all tasks are complete
     if (implementResult.stdout.includes('<promise>COMPLETE</promise>')) {
-      console.log('\n✓ All tasks completed!');
-      return;
+      console.log('\n✓ All tasks completed!')
+      return
     }
-    
+
     // Phase 2: Review (unless skipped)
-    let reviewFeedback: string | undefined;
+    let reviewFeedback: string | undefined
     if (skipPhase !== 'review') {
-      console.log('\nPhase 2: Review');
-      console.log('-'.repeat(80));
+      console.log('\nPhase 2: Review')
+      console.log('-'.repeat(80))
       const reviewPrompt = constructPrompt({
         phase: 'review',
         featureName,
         config,
-        taskId: completedTaskId
-      });
-      
-      const reviewModel = resolveModelForPhase(config, 'review', agent);
-      
+        taskId: completedTaskId,
+      })
+
+      const reviewModel = resolveModelForPhase(config, 'review', agent)
+
       const reviewResult = await spawnAgent({
         agent,
         prompt: reviewPrompt,
         workingDir: process.cwd(),
-        model: reviewModel
-      });
-      
+        model: reviewModel,
+      })
+
       if (reviewResult.exitCode !== 0) {
         // Parse error type for better user feedback
-        const errorInfo = parseAgentError(reviewResult.stderr, reviewResult.exitCode);
-        
+        const errorInfo = parseAgentError(reviewResult.stderr, reviewResult.exitCode)
+
         if (errorInfo.type === 'model_unavailable') {
-          const { message, details } = ErrorMessages.MODEL_UNAVAILABLE(reviewModel, agent);
-          exitWithError(message, details);
+          const { message, details } = ErrorMessages.MODEL_UNAVAILABLE(reviewModel, agent)
+          exitWithError(message, details)
         } else if (errorInfo.type === 'rate_limit') {
-          const { message, details } = ErrorMessages.RATE_LIMIT_ERROR(agent, errorInfo.retryAfter);
-          exitWithError(message, details);
+          const { message, details } = ErrorMessages.RATE_LIMIT_ERROR(agent, errorInfo.retryAfter)
+          exitWithError(message, details)
         } else if (errorInfo.type === 'spawn_failed') {
-          const { message, details } = ErrorMessages.AGENT_SPAWN_FAILED(agent, reviewResult.stderr);
-          exitWithError(message, details);
+          const { message, details } = ErrorMessages.AGENT_SPAWN_FAILED(agent, reviewResult.stderr)
+          exitWithError(message, details)
         }
-        
+
         // Generic error message for other failures
-        console.error('\n✗ Review phase failed');
-        console.error('\nThe agent encountered an error during task review.');
-        console.error('The task has NOT been marked as completed.');
-        console.error('When you run hone again, it will retry the same task.');
-        console.error(`\nAgent exit code: ${reviewResult.exitCode}`);
+        console.error('\n✗ Review phase failed')
+        console.error('\nThe agent encountered an error during task review.')
+        console.error('The task has NOT been marked as completed.')
+        console.error('When you run hone again, it will retry the same task.')
+        console.error(`\nAgent exit code: ${reviewResult.exitCode}`)
         if (reviewResult.stderr) {
-          console.error('\nError output:');
-          console.error(reviewResult.stderr);
+          console.error('\nError output:')
+          console.error(reviewResult.stderr)
         }
-        throw new Error(`Review phase failed with exit code ${reviewResult.exitCode}`);
+        throw new Error(`Review phase failed with exit code ${reviewResult.exitCode}`)
       }
-      
-      reviewFeedback = reviewResult.stdout;
+
+      reviewFeedback = reviewResult.stdout
     } else {
-      console.log('\nPhase 2: Review (skipped)');
+      console.log('\nPhase 2: Review (skipped)')
     }
-    
+
     // Phase 3: Finalize
-    console.log('\nPhase 3: Finalize');
-    console.log('-'.repeat(80));
+    console.log('\nPhase 3: Finalize')
+    console.log('-'.repeat(80))
     const finalizePrompt = constructPrompt({
       phase: 'finalize',
       featureName,
       config,
       taskId: completedTaskId,
-      reviewFeedback
-    });
-    
-    const finalizeModel = resolveModelForPhase(config, 'finalize', agent);
-    
+      reviewFeedback,
+    })
+
+    const finalizeModel = resolveModelForPhase(config, 'finalize', agent)
+
     const finalizeResult = await spawnAgent({
       agent,
       prompt: finalizePrompt,
       workingDir: process.cwd(),
-      model: finalizeModel
-    });
-    
+      model: finalizeModel,
+    })
+
     if (finalizeResult.exitCode !== 0) {
       // Parse error type for better user feedback
-      const errorInfo = parseAgentError(finalizeResult.stderr, finalizeResult.exitCode);
-      
+      const errorInfo = parseAgentError(finalizeResult.stderr, finalizeResult.exitCode)
+
       if (errorInfo.type === 'model_unavailable') {
-        const { message, details } = ErrorMessages.MODEL_UNAVAILABLE(finalizeModel, agent);
-        exitWithError(message, details);
+        const { message, details } = ErrorMessages.MODEL_UNAVAILABLE(finalizeModel, agent)
+        exitWithError(message, details)
       } else if (errorInfo.type === 'rate_limit') {
-        const { message, details } = ErrorMessages.RATE_LIMIT_ERROR(agent, errorInfo.retryAfter);
-        exitWithError(message, details);
+        const { message, details } = ErrorMessages.RATE_LIMIT_ERROR(agent, errorInfo.retryAfter)
+        exitWithError(message, details)
       } else if (errorInfo.type === 'spawn_failed') {
-        const { message, details } = ErrorMessages.AGENT_SPAWN_FAILED(agent, finalizeResult.stderr);
-        exitWithError(message, details);
+        const { message, details } = ErrorMessages.AGENT_SPAWN_FAILED(agent, finalizeResult.stderr)
+        exitWithError(message, details)
       }
-      
+
       // Generic error message for other failures
-      console.error('\n✗ Finalize phase failed');
-      console.error('\nThe agent encountered an error during task finalization.');
-      console.error('The task may not have been properly committed or marked as completed.');
-      console.error('Review the git status and task file manually before continuing.');
-      console.error(`\nAgent exit code: ${finalizeResult.exitCode}`);
+      console.error('\n✗ Finalize phase failed')
+      console.error('\nThe agent encountered an error during task finalization.')
+      console.error('The task may not have been properly committed or marked as completed.')
+      console.error('Review the git status and task file manually before continuing.')
+      console.error(`\nAgent exit code: ${finalizeResult.exitCode}`)
       if (finalizeResult.stderr) {
-        console.error('\nError output:');
-        console.error(finalizeResult.stderr);
+        console.error('\nError output:')
+        console.error(finalizeResult.stderr)
       }
-      throw new Error(`Finalize phase failed with exit code ${finalizeResult.exitCode}`);
+      throw new Error(`Finalize phase failed with exit code ${finalizeResult.exitCode}`)
     }
-    
+
     // Verify task was finalized
-    const finalizedTaskId = extractTaskId(finalizeResult.stdout, 'FINALIZED');
+    const finalizedTaskId = extractTaskId(finalizeResult.stdout, 'FINALIZED')
     if (finalizedTaskId) {
-      console.log(`\n✓ Iteration ${i} complete - Task ${finalizedTaskId} finalized`);
+      console.log(`\n✓ Iteration ${i} complete - Task ${finalizedTaskId} finalized`)
     } else {
-      console.log(`\n✓ Iteration ${i} complete`);
+      console.log(`\n✓ Iteration ${i} complete`)
     }
   }
-  
-  console.log(`\n${'='.repeat(80)}`);
-  console.log(`Completed ${iterations} iterations`);
-  console.log('='.repeat(80));
+
+  console.log(`\n${'='.repeat(80)}`)
+  console.log(`Completed ${iterations} iterations`)
+  console.log('='.repeat(80))
 }
 
 /**
@@ -245,8 +245,8 @@ export async function executeTasks(options: ExecuteTasksOptions): Promise<void>
  * Expected format: tasks-<feature-name>.yml or .plans/tasks-<feature-name>.yml
  */
 function extractFeatureName(tasksPath: string): string | undefined {
-  const match = tasksPath.match(/tasks-([^/]+)\.yml$/);
-  return match ? match[1] : undefined;
+  const match = tasksPath.match(/tasks-([^/]+)\.yml$/)
+  return match ? match[1] : undefined
 }
 
 /**
@@ -254,7 +254,7 @@ function extractFeatureName(tasksPath: string): string | undefined {
  * Looks for patterns like "TASK_COMPLETED: task-123" or "FINALIZED: task-123"
  */
 function extractTaskId(output: string, marker: 'TASK_COMPLETED' | 'FINALIZED'): string | undefined {
-  const regex = new RegExp(`${marker}:\\s*([\\w-]+)`, 'i');
-  const match = output.match(regex);
-  return match ? match[1] : undefined;
+  const regex = new RegExp(`${marker}:\\s*([\\w-]+)`, 'i')
+  const match = output.match(regex)
+  return match ? match[1] : undefined
 }

package/src/status.test.ts

@@ -1,6 +1,6 @@
-import { describe, test, expect } from 'bun:test';
-import { findNextTask } from './status';
-import type { TaskFile } from './prds';
+import { describe, test, expect } from 'bun:test'
+import { findNextTask } from './status'
+import type { TaskFile } from './prds'
 
 describe('status', () => {
   describe('findNextTask', () => {
@@ -16,22 +16,22 @@ describe('status', () => {
             title: 'Task 1',
             description: 'First task',
             status: 'pending',
-            dependencies: []
+            dependencies: [],
           },
           {
             id: 'task-2',
             title: 'Task 2',
             description: 'Second task',
             status: 'pending',
-            dependencies: []
-          }
-        ]
-      };
-      
-      const next = findNextTask(taskFile);
-      expect(next?.id).toBe('task-1');
-    });
-    
+            dependencies: [],
+          },
+        ],
+      }
+
+      const next = findNextTask(taskFile)
+      expect(next?.id).toBe('task-1')
+    })
+
     test('skips pending task with incomplete dependencies', () => {
       const taskFile: TaskFile = {
         feature: 'test',
@@ -44,22 +44,22 @@ describe('status', () => {
             title: 'Task 1',
             description: 'First task',
             status: 'pending',
-            dependencies: []
+            dependencies: [],
           },
           {
             id: 'task-2',
             title: 'Task 2',
             description: 'Second task',
             status: 'pending',
-            dependencies: ['task-1']
-          }
-        ]
-      };
-      
-      const next = findNextTask(taskFile);
-      expect(next?.id).toBe('task-1');
-    });
-    
+            dependencies: ['task-1'],
+          },
+        ],
+      }
+
+      const next = findNextTask(taskFile)
+      expect(next?.id).toBe('task-1')
+    })
+
     test('returns pending task when dependencies completed', () => {
       const taskFile: TaskFile = {
         feature: 'test',
@@ -72,22 +72,22 @@ describe('status', () => {
             title: 'Task 1',
             description: 'First task',
             status: 'completed',
-            dependencies: []
+            dependencies: [],
           },
           {
             id: 'task-2',
             title: 'Task 2',
             description: 'Second task',
             status: 'pending',
-            dependencies: ['task-1']
-          }
-        ]
-      };
-      
-      const next = findNextTask(taskFile);
-      expect(next?.id).toBe('task-2');
-    });
-    
+            dependencies: ['task-1'],
+          },
+        ],
+      }
+
+      const next = findNextTask(taskFile)
+      expect(next?.id).toBe('task-2')
+    })
+
     test('returns null when no pending tasks', () => {
       const taskFile: TaskFile = {
         feature: 'test',
@@ -100,15 +100,15 @@ describe('status', () => {
             title: 'Task 1',
             description: 'First task',
             status: 'completed',
-            dependencies: []
-          }
-        ]
-      };
-      
-      const next = findNextTask(taskFile);
-      expect(next).toBeNull();
-    });
-    
+            dependencies: [],
+          },
+        ],
+      }
+
+      const next = findNextTask(taskFile)
+      expect(next).toBeNull()
+    })
+
     test('returns null when all pending tasks blocked by dependencies', () => {
       const taskFile: TaskFile = {
         feature: 'test',
@@ -121,39 +121,39 @@ describe('status', () => {
             title: 'Task 1',
             description: 'First task',
             status: 'pending',
-            dependencies: []
+            dependencies: [],
           },
           {
             id: 'task-2',
             title: 'Task 2',
             description: 'Second task',
             status: 'pending',
-            dependencies: ['task-1']
-          }
-        ]
-      };
-      
+            dependencies: ['task-1'],
+          },
+        ],
+      }
+
       // Mark task-1 as something other than completed
       if (taskFile.tasks[0]) {
-        taskFile.tasks[0].status = 'in_progress';
+        taskFile.tasks[0].status = 'in_progress'
       }
-      
-      const next = findNextTask(taskFile);
-      expect(next).toBeNull();
-    });
-    
+
+      const next = findNextTask(taskFile)
+      expect(next).toBeNull()
+    })
+
     test('handles empty task list', () => {
       const taskFile: TaskFile = {
         feature: 'test',
         prd: './prd-test.md',
         created_at: '2026-01-28',
         updated_at: '2026-01-28',
-        tasks: []
-      };
-      
-      const next = findNextTask(taskFile);
-      expect(next).toBeNull();
-    });
+        tasks: [],
+      }
+
+      const next = findNextTask(taskFile)
+      expect(next).toBeNull()
+    })
 
     test('treats cancelled tasks as satisfied dependencies', () => {
       const taskFile: TaskFile = {
@@ -167,21 +167,21 @@ describe('status', () => {
             title: 'Task 1',
             description: 'First task',
             status: 'cancelled',
-            dependencies: []
+            dependencies: [],
           },
           {
             id: 'task-2',
             title: 'Task 2',
             description: 'Second task',
             status: 'pending',
-            dependencies: ['task-1']
-          }
-        ]
-      };
-      
-      const next = findNextTask(taskFile);
-      expect(next?.id).toBe('task-2');
-    });
+            dependencies: ['task-1'],
+          },
+        ],
+      }
+
+      const next = findNextTask(taskFile)
+      expect(next?.id).toBe('task-2')
+    })
 
     test('skips cancelled tasks when searching for next', () => {
       const taskFile: TaskFile = {
@@ -195,20 +195,20 @@ describe('status', () => {
             title: 'Task 1',
             description: 'First task',
             status: 'cancelled',
-            dependencies: []
+            dependencies: [],
           },
           {
             id: 'task-2',
             title: 'Task 2',
             description: 'Second task',
             status: 'pending',
-            dependencies: []
-          }
-        ]
-      };
-      
-      const next = findNextTask(taskFile);
-      expect(next?.id).toBe('task-2');
-    });
-  });
-});
+            dependencies: [],
+          },
+        ],
+      }
+
+      const next = findNextTask(taskFile)
+      expect(next?.id).toBe('task-2')
+    })
+  })
+})