hone-ai 0.5.0 → 0.10.0

package/src/status.ts

@@ -1,28 +1,28 @@
-import { readdirSync, existsSync } from 'fs';
-import { join } from 'path';
-import { getPlansDir } from './config';
-import { loadTaskFile, calculateStatus } from './prds';
-import type { Task, TaskFile } from './prds';
+import { readdirSync, existsSync } from 'fs'
+import { join } from 'path'
+import { getPlansDir } from './config'
+import { loadTaskFile, calculateStatus } from './prds'
+import type { Task, TaskFile } from './prds'
 
 export interface TaskFileStatus {
-  filename: string;
-  feature: string;
-  completedCount: number;
-  totalCount: number;
-  nextTask: Task | null;
+  filename: string
+  feature: string
+  completedCount: number
+  totalCount: number
+  nextTask: Task | null
 }
 
 /**
  * Get all task files in .plans/ directory
  */
 export function listTaskFiles(): string[] {
-  const plansDir = getPlansDir();
+  const plansDir = getPlansDir()
   if (!existsSync(plansDir)) {
-    return [];
+    return []
   }
-  
-  const files = readdirSync(plansDir);
-  return files.filter(file => file.startsWith('tasks-') && file.endsWith('.yml'));
+
+  const files = readdirSync(plansDir)
+  return files.filter(file => file.startsWith('tasks-') && file.endsWith('.yml'))
 }
 
 /**
@@ -31,64 +31,62 @@ export function listTaskFiles(): string[] {
  */
 export function findNextTask(taskFile: TaskFile): Task | null {
   if (!taskFile.tasks || taskFile.tasks.length === 0) {
-    return null;
+    return null
   }
-  
+
   // Find first pending task where all dependencies are satisfied
   for (const task of taskFile.tasks) {
     if (task.status === 'pending') {
       // Check if all dependencies are completed or cancelled
-      const dependencies = task.dependencies || [];
+      const dependencies = task.dependencies || []
       const allDepsCompleted = dependencies.every(depId => {
-        const depTask = taskFile.tasks.find(t => t.id === depId);
-        return depTask && (depTask.status === 'completed' || depTask.status === 'cancelled');
-      });
-      
+        const depTask = taskFile.tasks.find(t => t.id === depId)
+        return depTask && (depTask.status === 'completed' || depTask.status === 'cancelled')
+      })
+
       if (allDepsCompleted) {
-        return task;
+        return task
       }
     }
   }
-  
-  return null;
+
+  return null
 }
 
 /**
  * Get status for a single task file
  */
 export async function getTaskFileStatus(taskFilename: string): Promise<TaskFileStatus | null> {
-  const taskFile = await loadTaskFile(taskFilename);
+  const taskFile = await loadTaskFile(taskFilename)
   if (!taskFile) {
-    return null;
+    return null
   }
-  
-  const { status, completedCount, totalCount } = calculateStatus(taskFile);
-  
+
+  const { status, completedCount, totalCount } = calculateStatus(taskFile)
+
   // Skip fully completed files
   if (status === 'completed') {
-    return null;
+    return null
   }
-  
-  const nextTask = findNextTask(taskFile);
-  
+
+  const nextTask = findNextTask(taskFile)
+
   return {
     filename: taskFilename,
     feature: taskFile.feature,
     completedCount,
     totalCount,
-    nextTask
-  };
+    nextTask,
+  }
 }
 
 /**
  * List all incomplete task files with their status
  */
 export async function listIncompleteTaskFiles(): Promise<TaskFileStatus[]> {
-  const taskFiles = listTaskFiles();
-  const statusList = await Promise.all(
-    taskFiles.map(file => getTaskFileStatus(file))
-  );
-  
+  const taskFiles = listTaskFiles()
+  const statusList = await Promise.all(taskFiles.map(file => getTaskFileStatus(file)))
+
   // Filter out null (completed files) and return
-  return statusList.filter((s): s is TaskFileStatus => s !== null);
+  return statusList.filter((s): s is TaskFileStatus => s !== null)
 }

package/src/task-generator.test.ts

@@ -1,64 +1,96 @@
-import { describe, test, expect, beforeEach, afterEach, beforeAll, afterAll } from 'bun:test';
-import { generateTasksFromPRD } from './task-generator';
-import { writeFile, mkdir, rm } from 'fs/promises';
-import { join } from 'path';
-import { existsSync } from 'fs';
+import { describe, test, expect, beforeEach, afterEach, beforeAll, afterAll, mock } from 'bun:test'
+import { generateTasksFromPRD } from './task-generator'
+import { writeFile, mkdir, rm, readFile } from 'fs/promises'
+import { join } from 'path'
+import { existsSync } from 'fs'
 
 // Set test environment
-const originalEnv = process.env.BUN_ENV;
+const originalEnv = process.env.BUN_ENV
 beforeAll(() => {
-  process.env.BUN_ENV = 'test';
-});
+  process.env.BUN_ENV = 'test'
+})
 afterAll(() => {
-  process.env.BUN_ENV = originalEnv;
-});
+  process.env.BUN_ENV = originalEnv
+})
 
-const TEST_WORKSPACE = join(process.cwd(), '.test-task-generator');
-const TEST_PLANS_DIR = join(TEST_WORKSPACE, '.plans');
+const TEST_WORKSPACE = join(process.cwd(), '.test-task-generator')
+const TEST_PLANS_DIR = join(TEST_WORKSPACE, '.plans')
 
 describe('task-generator', () => {
   beforeEach(async () => {
+    // Mock AgentClient to avoid real API calls
+    mock.module('./agent-client', () => ({
+      AgentClient: function () {
+        return {
+          messages: {
+            create: mock().mockResolvedValue({
+              content: [
+                {
+                  type: 'text',
+                  text: JSON.stringify([
+                    {
+                      id: 'task-001',
+                      title: 'Test task',
+                      description: 'Test task description',
+                      status: 'pending',
+                      dependencies: [],
+                      acceptance_criteria: ['Task works'],
+                      completed_at: null,
+                    },
+                  ]),
+                },
+              ],
+            }),
+          },
+        }
+      },
+    }))
+
+    // Increase timeout to handle directory operations
     // Create test workspace
     if (existsSync(TEST_WORKSPACE)) {
-      await rm(TEST_WORKSPACE, { recursive: true, force: true });
+      await rm(TEST_WORKSPACE, { recursive: true, force: true })
     }
-    await mkdir(TEST_WORKSPACE, { recursive: true });
-    await mkdir(TEST_PLANS_DIR, { recursive: true });
-    
+    await mkdir(TEST_WORKSPACE, { recursive: true })
+    await mkdir(TEST_PLANS_DIR, { recursive: true })
+
     // Change to test workspace
-    process.chdir(TEST_WORKSPACE);
-  });
-  
+    process.chdir(TEST_WORKSPACE)
+  })
+
   afterEach(async () => {
+    // Restore mocks
+    mock.restore()
+
     // Restore original directory and cleanup
-    process.chdir(join(TEST_WORKSPACE, '..'));
+    process.chdir(join(TEST_WORKSPACE, '..'))
     if (existsSync(TEST_WORKSPACE)) {
-      await rm(TEST_WORKSPACE, { recursive: true, force: true });
+      await rm(TEST_WORKSPACE, { recursive: true, force: true })
     }
-  });
-  
+  })
+
   test('throws error if PRD file does not exist', async () => {
-    const nonExistentPath = join(TEST_PLANS_DIR, 'prd-nonexistent.md');
-    
-    await expect(generateTasksFromPRD(nonExistentPath)).rejects.toThrow('File not found');
-  });
-  
+    const nonExistentPath = join(TEST_PLANS_DIR, 'prd-nonexistent.md')
+
+    await expect(generateTasksFromPRD(nonExistentPath)).rejects.toThrow('File not found')
+  })
+
   test('throws error if PRD filename format is invalid', async () => {
-    const invalidPath = join(TEST_PLANS_DIR, 'invalid-filename.md');
-    await writeFile(invalidPath, '# Test PRD', 'utf-8');
-    
-    await expect(generateTasksFromPRD(invalidPath)).rejects.toThrow('Invalid PRD filename format');
-  });
-  
+    const invalidPath = join(TEST_PLANS_DIR, 'invalid-filename.md')
+    await writeFile(invalidPath, '# Test PRD', 'utf-8')
+
+    await expect(generateTasksFromPRD(invalidPath)).rejects.toThrow('Invalid PRD filename format')
+  })
+
   test('throws error if PRD filename has no feature name', async () => {
-    const invalidPath = join(TEST_PLANS_DIR, 'prd-.md');
-    await writeFile(invalidPath, '# Test PRD', 'utf-8');
-    
-    await expect(generateTasksFromPRD(invalidPath)).rejects.toThrow('Invalid PRD filename format');
-  });
-  
+    const invalidPath = join(TEST_PLANS_DIR, 'prd-.md')
+    await writeFile(invalidPath, '# Test PRD', 'utf-8')
+
+    await expect(generateTasksFromPRD(invalidPath)).rejects.toThrow('Invalid PRD filename format')
+  })
+
   test('extracts feature name correctly from PRD filename', async () => {
-    const prdPath = join(TEST_PLANS_DIR, 'prd-test-feature.md');
+    const prdPath = join(TEST_PLANS_DIR, 'prd-test-feature.md')
     const prdContent = `# PRD: Test Feature
     
 ## Overview
@@ -66,28 +98,23 @@ Simple test feature for unit testing.
 
 ## Requirements
 - REQ-1: Basic requirement
-`;
-    
-    await writeFile(prdPath, prdContent, 'utf-8');
-    
-    // Mock API key for this test
-    const originalApiKey = process.env.ANTHROPIC_API_KEY;
-    process.env.ANTHROPIC_API_KEY = 'test-key';
-    
-    try {
-      // This will fail at the API call, but we're testing the filename parsing
-      await generateTasksFromPRD(prdPath);
-    } catch (error) {
-      // Expected to fail at API call since we're using a fake key
-      // But if it failed at filename parsing, it would have thrown earlier
-      expect(error).toBeDefined();
-    } finally {
-      // Restore original API key
-      if (originalApiKey) {
-        process.env.ANTHROPIC_API_KEY = originalApiKey;
-      } else {
-        delete process.env.ANTHROPIC_API_KEY;
-      }
-    }
-  });
-});
+`
+
+    await writeFile(prdPath, prdContent, 'utf-8')
+
+    // With AgentClient mocked, this should succeed and create the tasks file
+    const result = await generateTasksFromPRD(prdPath)
+
+    // Verify the feature name was correctly extracted from the filename
+    expect(result).toBe('tasks-test-feature.yml')
+
+    // Verify the tasks file was created with correct content
+    const tasksFilePath = join(process.cwd(), '.plans', 'tasks-test-feature.yml')
+    expect(existsSync(tasksFilePath)).toBe(true)
+
+    // Read and verify the content contains the correct feature name
+    const tasksContent = await readFile(tasksFilePath, 'utf-8')
+    expect(tasksContent).toContain('feature: test-feature')
+    expect(tasksContent).toContain('prd: ./prd-test-feature.md')
+  })
+})

package/src/task-generator.ts

@@ -1,84 +1,87 @@
-import { loadConfig, resolveModelForPhase } from './config';
-import { readFile, writeFile } from 'fs/promises';
-import { join, basename } from 'path';
-import { existsSync } from 'fs';
-import { exitWithError, ErrorMessages } from './errors';
-import { AgentClient } from './agent-client';
+import { loadConfig, resolveModelForPhase } from './config'
+import { readFile, writeFile } from 'fs/promises'
+import { join, basename } from 'path'
+import { existsSync } from 'fs'
+import { exitWithError, ErrorMessages } from './errors'
+import { AgentClient } from './agent-client'
 
 interface Task {
-  id: string;
-  title: string;
-  description: string;
-  status: 'pending' | 'in_progress' | 'completed';
-  dependencies: string[];
-  acceptance_criteria: string[];
-  completed_at: string | null;
+  id: string
+  title: string
+  description: string
+  status: 'pending' | 'in_progress' | 'completed'
+  dependencies: string[]
+  acceptance_criteria: string[]
+  completed_at: string | null
 }
 
 interface TasksFile {
-  feature: string;
-  prd: string;
-  created_at: string;
-  updated_at: string;
-  tasks: Task[];
+  feature: string
+  prd: string
+  created_at: string
+  updated_at: string
+  tasks: Task[]
 }
 
 export async function generateTasksFromPRD(prdFilePath: string): Promise<string> {
   // Validate PRD file exists
   if (!existsSync(prdFilePath)) {
-    const { message, details } = ErrorMessages.FILE_NOT_FOUND(prdFilePath);
-    exitWithError(message, details);
+    const { message, details } = ErrorMessages.FILE_NOT_FOUND(prdFilePath)
+    exitWithError(message, details)
   }
-  
+
   // Read PRD content
-  const prdContent = await readFile(prdFilePath, 'utf-8');
-  
+  const prdContent = await readFile(prdFilePath, 'utf-8')
+
   // Extract feature name from PRD filename (prd-feature-name.md -> feature-name)
-  const prdFilename = basename(prdFilePath);
-  const featureMatch = prdFilename.match(/^prd-(.+)\.md$/);
+  const prdFilename = basename(prdFilePath)
+  const featureMatch = prdFilename.match(/^prd-(.+)\.md$/)
   if (!featureMatch || !featureMatch[1]) {
-    throw new Error(`Invalid PRD filename format: ${prdFilename}. Expected: prd-<feature-name>.md`);
+    throw new Error(`Invalid PRD filename format: ${prdFilename}. Expected: prd-<feature-name>.md`)
   }
-  const featureName = featureMatch[1];
-  
-  console.log('\nAnalyzing PRD and generating tasks...');
-  
-  const tasks = await generateTasksWithAI(prdContent);
-  
+  const featureName = featureMatch[1]
+
+  console.log('\nAnalyzing PRD and generating tasks...')
+
+  const tasks = await generateTasksWithAI(prdContent)
+
   // Create tasks file
-  const now = new Date().toISOString();
+  const now = new Date().toISOString()
   const tasksFile: TasksFile = {
     feature: featureName,
     prd: `./${prdFilename}`,
     created_at: now,
     updated_at: now,
-    tasks
-  };
-  
+    tasks,
+  }
+
   // Convert to YAML format
-  const yamlContent = formatAsYAML(tasksFile);
-  
+  const yamlContent = formatAsYAML(tasksFile)
+
   // Save to .plans/tasks-<feature-name>.yml
-  const tasksFilename = `tasks-${featureName}.yml`;
-  const tasksFilePath = join(process.cwd(), '.plans', tasksFilename);
-  
-  await writeFile(tasksFilePath, yamlContent, 'utf-8');
-  
-  console.log(`✓ Generated ${tasks.length} tasks`);
-  console.log(`✓ Saved to .plans/${tasksFilename}\n`);
-  
-  return tasksFilename;
+  const tasksFilename = `tasks-${featureName}.yml`
+  const tasksFilePath = join(process.cwd(), '.plans', tasksFilename)
+
+  await writeFile(tasksFilePath, yamlContent, 'utf-8')
+
+  console.log(`✓ Generated ${tasks.length} tasks`)
+  console.log(`✓ Saved to .plans/${tasksFilename}\n`)
+  console.log(
+    `Now run "hone run .plans/${tasksFilename} -i ${tasks.length}" to execute the tasks\n`
+  )
+
+  return tasksFilename
 }
 
 async function generateTasksWithAI(prdContent: string): Promise<Task[]> {
-  const config = await loadConfig();
-  const model = resolveModelForPhase(config, 'prdToTasks');
-  
+  const config = await loadConfig()
+  const model = resolveModelForPhase(config, 'prdToTasks')
+
   const client = new AgentClient({
     agent: config.defaultAgent,
-    model
-  });
-  
+    model,
+  })
+
   const systemPrompt = `You are a technical project manager breaking down a PRD into implementable tasks.
 
 Generate an ordered list of tasks following these guidelines:
@@ -99,7 +102,7 @@ Generate an ordered list of tasks following these guidelines:
    - Standard features
    - Polish and refinements
 
-3. **Dependencies**: 
+3. **Dependencies**:
    - Identify which tasks must complete before others
    - Use task IDs in dependencies array
    - Keep dependency chains reasonable (don't over-constrain)
@@ -122,7 +125,7 @@ Example output:
     "completed_at": null
   },
   {
-    "id": "task-002", 
+    "id": "task-002",
     "title": "Implement core API client",
     "description": "Create API client with authentication, error handling, and retry logic. Should support all required endpoints.",
     "status": "pending",
@@ -136,98 +139,108 @@ Example output:
   }
 ]
 
-Now analyze this PRD and generate tasks:`;
+Now analyze this PRD and generate tasks:`
 
   try {
     const response = await client.messages.create({
       max_tokens: 8000,
-      messages: [{
-        role: 'user',
-        content: prdContent
-      }],
-      system: systemPrompt
-    });
-    
-    const content = response.content[0];
+      messages: [
+        {
+          role: 'user',
+          content: prdContent,
+        },
+      ],
+      system: systemPrompt,
+    })
+
+    const content = response.content[0]
     if (!content || content.type !== 'text') {
-      throw new Error('Invalid response from AI');
+      throw new Error('Invalid response from AI')
     }
-    
+
     // Extract JSON array from response (handle cases where AI wraps in markdown code blocks)
-    let jsonText = content.text.trim();
-    const jsonMatch = jsonText.match(/```(?:json)?\s*(\[[\s\S]*\])\s*```/);
+    let jsonText = content.text.trim()
+    const jsonMatch = jsonText.match(/```(?:json)?\s*(\[[\s\S]*\])\s*```/)
     if (jsonMatch && jsonMatch[1]) {
-      jsonText = jsonMatch[1];
+      jsonText = jsonMatch[1]
     }
-    
+
     try {
-      const tasks = JSON.parse(jsonText);
-      
+      const tasks = JSON.parse(jsonText)
+
       if (!Array.isArray(tasks)) {
-        throw new Error('Response is not an array');
+        throw new Error('Response is not an array')
       }
-      
+
       // Validate task structure
       for (const task of tasks) {
-        if (!task.id || !task.title || !task.description || !task.status || 
-            !Array.isArray(task.dependencies) || !Array.isArray(task.acceptance_criteria)) {
-          throw new Error(`Invalid task structure: ${JSON.stringify(task)}`);
+        if (
+          !task.id ||
+          !task.title ||
+          !task.description ||
+          !task.status ||
+          !Array.isArray(task.dependencies) ||
+          !Array.isArray(task.acceptance_criteria)
+        ) {
+          throw new Error(`Invalid task structure: ${JSON.stringify(task)}`)
         }
       }
-      
-      return tasks;
+
+      return tasks
     } catch (error) {
-      throw new Error(`Failed to parse AI response as JSON: ${error instanceof Error ? error.message : error}`);
+      throw new Error(
+        `Failed to parse AI response as JSON: ${error instanceof Error ? error.message : error}`
+      )
     }
   } catch (error) {
-    const { message, details } = ErrorMessages.NETWORK_ERROR_FINAL(error);
-    exitWithError(message, details);
-    throw error; // Never reached but satisfies TypeScript
+    const { message, details } = ErrorMessages.NETWORK_ERROR_FINAL(error)
+    exitWithError(message, details)
+    throw error // Never reached but satisfies TypeScript
   }
 }
 
 function formatAsYAML(tasksFile: TasksFile): string {
-  const lines: string[] = [];
-  
-  lines.push(`feature: ${tasksFile.feature}`);
-  lines.push(`prd: ${tasksFile.prd}`);
-  lines.push(`created_at: ${tasksFile.created_at}`);
-  lines.push(`updated_at: ${tasksFile.updated_at}`);
-  lines.push('');
-  lines.push('tasks:');
-  
+  const lines: string[] = []
+
+  lines.push(`feature: ${tasksFile.feature}`)
+  lines.push(`prd: ${tasksFile.prd}`)
+  lines.push(`created_at: ${tasksFile.created_at}`)
+  lines.push(`updated_at: ${tasksFile.updated_at}`)
+  lines.push('')
+  lines.push('tasks:')
+
   for (const task of tasksFile.tasks) {
-    lines.push(`  - id: ${task.id}`);
-    lines.push(`    title: "${task.title}"`);
-    
+    lines.push(`  - id: ${task.id}`)
+    lines.push(`    title: "${task.title}"`)
+
     // Multi-line description with proper YAML indentation
-    lines.push(`    description: |`);
-    const descLines = task.description.split('\n');
+    lines.push(`    description: |`)
+    const descLines = task.description.split('\n')
     for (const line of descLines) {
-      lines.push(`      ${line}`);
+      lines.push(`      ${line}`)
     }
-    
-    lines.push(`    status: ${task.status}`);
-    
+
+    lines.push(`    status: ${task.status}`)
+
     // Dependencies
     if (task.dependencies.length === 0) {
-      lines.push(`    dependencies: []`);
+      lines.push(`    dependencies: []`)
     } else {
-      lines.push(`    dependencies:`);
+      lines.push(`    dependencies:`)
       for (const dep of task.dependencies) {
-        lines.push(`      - ${dep}`);
+        lines.push(`      - ${dep}`)
       }
     }
-    
+
     // Acceptance criteria
-    lines.push(`    acceptance_criteria:`);
+    lines.push(`    acceptance_criteria:`)
     for (const criterion of task.acceptance_criteria) {
-      lines.push(`      - "${criterion}"`);
+      lines.push(`      - "${criterion}"`)
     }
-    
-    lines.push(`    completed_at: ${task.completed_at || 'null'}`);
-    lines.push('');
+
+    lines.push(`    completed_at: ${task.completed_at || 'null'}`)
+    lines.push('')
   }
-  
-  return lines.join('\n');
+
+  return lines.join('\n')
 }