claude-mycelium 2.0.0 → 2.2.0

package/src/task/planner.ts

@@ -0,0 +1,294 @@
+/**
+ * Task Planning Implementation
+ * Per second-spec §12.1: Task Planning
+ *
+ * LLM-based task decomposition that generates a TaskPlan with steps,
+ * dependency analysis, and risk identification.
+ */
+
+import { callLLM } from '../llm/anthropic-client.js';
+import { Task, TaskPlan, TaskStep } from '../types/index.js';
+import { logDebug, logError } from '../utils/logger.js';
+import fg from 'fast-glob';
+
+/**
+ * Plan a task by using LLM to decompose it into steps
+ */
+export async function planTask(task: Task): Promise<TaskPlan> {
+  logDebug('Planning task', { taskId: task.id, description: task.description });
+
+  try {
+    // Get existing files in target directory
+    const existingFiles = await getExistingFiles(task.target ?? 'src');
+
+    // Build prompts for LLM
+    const systemPrompt = buildPlanningSystemPrompt();
+    const userPrompt = buildPlanningUserPrompt(task, existingFiles);
+
+    // Call LLM to generate plan
+    const response = await callLLM({
+      prompt: userPrompt,
+      systemPrompt,
+      temperature: 0.3, // Lower temperature for more deterministic planning
+      maxTokens: 4000,
+    });
+
+    // Parse JSON plan from response
+    const plan = parseTaskPlanFromResponse(response.content);
+
+    logDebug('Task plan generated', {
+      taskId: task.id,
+      steps: plan.steps.length,
+      complexity: plan.estimated_complexity,
+    });
+
+    return plan;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Failed to plan task', errorObj, { taskId: task.id });
+    throw new Error(`Task planning failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+/**
+ * Analyze dependencies between task steps
+ */
+export function analyzeDependencies(steps: TaskStep[]): Map<number, number[]> {
+  const dependencies = new Map<number, number[]>();
+
+  for (const step of steps) {
+    // Direct dependencies from the step definition
+    dependencies.set(step.order, [...step.depends_on]);
+
+    // Detect implicit file dependencies
+    const implicitDeps = detectImplicitDependencies(step, steps);
+    const allDeps = new Set([...step.depends_on, ...implicitDeps]);
+    dependencies.set(step.order, Array.from(allDeps));
+  }
+
+  return dependencies;
+}
+
+/**
+ * Identify potential risks in the task plan
+ */
+export function identifyRisks(plan: TaskPlan): string[] {
+  const risks: string[] = [...plan.risks];
+
+  // Check for circular dependencies
+  if (hasCircularDependencies(plan.steps)) {
+    risks.push('Circular dependency detected in task steps');
+  }
+
+  // Check for steps with many dependencies
+  const stepsWithManyDeps = plan.steps.filter(s => s.depends_on.length > 3);
+  if (stepsWithManyDeps.length > 0) {
+    risks.push(`${stepsWithManyDeps.length} step(s) have complex dependencies (>3 deps)`);
+  }
+
+  // Check for create mode on existing file patterns
+  const createSteps = plan.steps.filter(s => s.mode === 'create');
+  if (createSteps.length > 5) {
+    risks.push(`Many new files (${createSteps.length}) - may need more validation`);
+  }
+
+  // Check for high complexity tasks
+  if (plan.estimated_complexity === 'large' && plan.steps.length > 10) {
+    risks.push('Large task with many steps - consider breaking down further');
+  }
+
+  return risks;
+}
+
+/**
+ * Get existing files in the target directory
+ */
+async function getExistingFiles(target: string): Promise<string[]> {
+  try {
+    const pattern = `${target}/**/*.{ts,tsx,js,jsx}`;
+    const files = await fg(pattern, {
+      ignore: ['**/node_modules/**', '**/dist/**', '**/*.test.ts', '**/*.spec.ts'],
+      onlyFiles: true,
+    });
+    return files;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Failed to list existing files', errorObj, { target });
+    return [];
+  }
+}
+
+/**
+ * Build system prompt for task planning
+ */
+function buildPlanningSystemPrompt(): string {
+  return `You are a task planning agent.
+
+Given a task description, create a step-by-step plan to accomplish it.
+
+Output your plan as JSON in this exact format:
+{
+  "summary": "Brief description of approach",
+  "steps": [
+    {
+      "order": 1,
+      "description": "What to do",
+      "target_file": "path/to/file.ts",
+      "mode": "create|error_reducer|complexity_reducer|debt_payer|stabilizer",
+      "depends_on": []
+    }
+  ],
+  "estimated_complexity": "small|medium|large",
+  "risks": ["potential risk 1", "potential risk 2"]
+}
+
+Rules:
+- Prefer small, incremental steps over large changes
+- Each step should be independently testable
+- New files must include basic tests
+- Follow existing code patterns
+- mode "create" is for new files only
+- Use error_reducer for fixing bugs
+- Use complexity_reducer for simplifying code
+- Use debt_payer for fixing lint/type issues
+- Use stabilizer for adding tests/docs`;
+}
+
+/**
+ * Build user prompt for task planning
+ */
+function buildPlanningUserPrompt(task: Task, existingFiles: string[]): string {
+  const fileList = existingFiles.length > 50
+    ? `${existingFiles.slice(0, 50).join('\n')}\n... and ${existingFiles.length - 50} more`
+    : existingFiles.join('\n') || '(no files found)';
+
+  const criteriaList = task.acceptance_criteria.length > 0
+    ? task.acceptance_criteria.map(c => `- ${c.description}`).join('\n')
+    : '(none specified)';
+
+  return `## Task
+${task.description}
+
+## Target Directory
+${task.target ?? 'src/'}
+
+## Existing Files
+${fileList}
+
+## Acceptance Criteria
+${criteriaList}
+
+Create a plan to accomplish this task.`;
+}
+
+/**
+ * Parse TaskPlan from LLM response
+ */
+function parseTaskPlanFromResponse(content: string): TaskPlan {
+  // Try to extract JSON from response
+  const jsonMatch = content.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error('Failed to parse task plan from LLM response - no JSON found');
+  }
+
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+
+    // Validate required fields
+    if (!parsed.summary || !Array.isArray(parsed.steps) || !parsed.estimated_complexity) {
+      throw new Error('Invalid task plan structure - missing required fields');
+    }
+
+    // Validate each step
+    for (const step of parsed.steps) {
+      if (typeof step.order !== 'number' ||
+          !step.description ||
+          !step.target_file ||
+          !step.mode) {
+        throw new Error('Invalid task step structure');
+      }
+      // Ensure depends_on is an array
+      step.depends_on = step.depends_on || [];
+      step.completed = false;
+    }
+
+    // Ensure risks is an array
+    parsed.risks = parsed.risks || [];
+
+    return parsed as TaskPlan;
+  } catch (error) {
+    throw new Error(`Failed to parse task plan JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+/**
+ * Detect implicit dependencies between steps based on file relationships
+ */
+function detectImplicitDependencies(step: TaskStep, allSteps: TaskStep[]): number[] {
+  const implicitDeps: number[] = [];
+
+  // If this step modifies a file, it depends on the step that creates it
+  if (step.mode !== 'create') {
+    const createStep = allSteps.find(
+      s => s.mode === 'create' &&
+           s.target_file === step.target_file &&
+           s.order < step.order
+    );
+    if (createStep && !step.depends_on.includes(createStep.order)) {
+      implicitDeps.push(createStep.order);
+    }
+  }
+
+  // If this step creates a test file, it depends on the implementation file step
+  if (step.mode === 'create' && step.target_file.includes('.test.')) {
+    const implPath = step.target_file.replace(/\.test\./, '.');
+    const implStep = allSteps.find(
+      s => s.target_file === implPath && s.order < step.order
+    );
+    if (implStep && !step.depends_on.includes(implStep.order)) {
+      implicitDeps.push(implStep.order);
+    }
+  }
+
+  return implicitDeps;
+}
+
+/**
+ * Check if task steps have circular dependencies
+ */
+function hasCircularDependencies(steps: TaskStep[]): boolean {
+  const visited = new Set<number>();
+  const recursionStack = new Set<number>();
+
+  function hasCycle(stepOrder: number): boolean {
+    if (recursionStack.has(stepOrder)) {
+      return true; // Found a cycle
+    }
+    if (visited.has(stepOrder)) {
+      return false; // Already checked this path
+    }
+
+    visited.add(stepOrder);
+    recursionStack.add(stepOrder);
+
+    const step = steps.find(s => s.order === stepOrder);
+    if (step) {
+      for (const dep of step.depends_on) {
+        if (hasCycle(dep)) {
+          return true;
+        }
+      }
+    }
+
+    recursionStack.delete(stepOrder);
+    return false;
+  }
+
+  for (const step of steps) {
+    if (hasCycle(step.order)) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/task/storage.ts

@@ -0,0 +1,332 @@
+/**
+ * Task Storage Implementation
+ * Per ROADMAP §Phase 5 Week 6 Day 7: Task Storage
+ *
+ * Stores tasks in .agent-meta/tasks/ with one file per task,
+ * tracks status transitions, and links to trace IDs.
+ */
+
+import { Task, TaskStatus } from '../types/index.js';
+import {
+  fileExists,
+  readJsonFile,
+  writeJsonFile,
+  ensureDir,
+  deleteFile,
+} from '../utils/file-utils.js';
+import { logDebug, logError } from '../utils/logger.js';
+import * as path from 'path';
+import * as fs from 'fs';
+
+const TASKS_DIR = '.agent-meta/tasks';
+const ACTIVE_TASKS_FILE = path.join(TASKS_DIR, '_active.json');
+
+/**
+ * Active tasks index structure
+ */
+interface ActiveTasksIndex {
+  updated_at: string;
+  tasks: string[]; // Array of task IDs
+}
+
+/**
+ * Store a task to disk
+ */
+export async function storeTask(task: Task): Promise<void> {
+  try {
+    // Ensure tasks directory exists
+    ensureDir(TASKS_DIR);
+
+    // Write task to its own file
+    const taskFilePath = getTaskFilePath(task.id);
+    writeJsonFile(taskFilePath, task);
+
+    // Update active tasks index
+    if (task.status === 'pending' || task.status === 'planning' || task.status === 'in_progress' || task.status === 'validating') {
+      await addToActiveIndex(task.id);
+    } else {
+      await removeFromActiveIndex(task.id);
+    }
+
+    logDebug('Task stored', {
+      taskId: task.id,
+      status: task.status,
+      filePath: taskFilePath,
+    });
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Failed to store task', errorObj, { taskId: task.id });
+    throw new Error(`Task storage failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+/**
+ * Load a task from disk
+ */
+export async function loadTask(taskId: string): Promise<Task | null> {
+  try {
+    const taskFilePath = getTaskFilePath(taskId);
+
+    if (!fileExists(taskFilePath)) {
+      logDebug('Task file not found', { taskId, filePath: taskFilePath });
+      return null;
+    }
+
+    const task = readJsonFile<Task>(taskFilePath);
+    logDebug('Task loaded', { taskId, status: task.status });
+    return task;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Failed to load task', errorObj, { taskId });
+    return null;
+  }
+}
+
+/**
+ * List all tasks, optionally filtered by status
+ */
+export async function listTasks(statusFilter?: TaskStatus): Promise<Task[]> {
+  try {
+    ensureDir(TASKS_DIR);
+
+    // Get all task files
+    const files = fs.readdirSync(TASKS_DIR).filter(f => f.startsWith('task_') && f.endsWith('.json'));
+
+    const tasks: Task[] = [];
+
+    for (const file of files) {
+      try {
+        const taskFilePath = path.join(TASKS_DIR, file);
+        const task = readJsonFile<Task>(taskFilePath);
+
+        // Apply status filter if provided
+        if (!statusFilter || task.status === statusFilter) {
+          tasks.push(task);
+        }
+      } catch (error) {
+        const errorObj = error instanceof Error ? error : new Error(String(error));
+        logError('Failed to load task file', errorObj, { file });
+        // Continue with other files
+      }
+    }
+
+    // Sort by creation date (newest first)
+    tasks.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+
+    logDebug('Tasks listed', {
+      total: tasks.length,
+      statusFilter,
+    });
+
+    return tasks;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Failed to list tasks', errorObj);
+    return [];
+  }
+}
+
+/**
+ * List active tasks (from index for performance)
+ */
+export async function listActiveTasks(): Promise<Task[]> {
+  try {
+    const index = await getActiveIndex();
+    const tasks: Task[] = [];
+
+    for (const taskId of index.tasks) {
+      const task = await loadTask(taskId);
+      if (task) {
+        tasks.push(task);
+      }
+    }
+
+    return tasks;
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Failed to list active tasks', errorObj);
+    return [];
+  }
+}
+
+/**
+ * Delete a task from storage
+ */
+export async function deleteTask(taskId: string): Promise<void> {
+  try {
+    const taskFilePath = getTaskFilePath(taskId);
+
+    if (fileExists(taskFilePath)) {
+      deleteFile(taskFilePath);
+      logDebug('Task deleted', { taskId });
+    }
+
+    // Remove from active index
+    await removeFromActiveIndex(taskId);
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Failed to delete task', errorObj, { taskId });
+    throw new Error(`Task deletion failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+/**
+ * Update task status and store
+ */
+export async function updateTaskStatus(
+  taskId: string,
+  newStatus: TaskStatus,
+  error?: string
+): Promise<void> {
+  const task = await loadTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} not found`);
+  }
+
+  const oldStatus = task.status;
+  task.status = newStatus;
+
+  if (error) {
+    task.error = error;
+  }
+
+  if (newStatus === 'completed' || newStatus === 'failed') {
+    task.completed_at = new Date().toISOString();
+  }
+
+  await storeTask(task);
+
+  logDebug('Task status updated', {
+    taskId,
+    oldStatus,
+    newStatus,
+    hasError: !!error,
+  });
+}
+
+/**
+ * Get task file path
+ */
+function getTaskFilePath(taskId: string): string {
+  return path.join(TASKS_DIR, `task_${taskId}.json`);
+}
+
+/**
+ * Get active tasks index
+ */
+async function getActiveIndex(): Promise<ActiveTasksIndex> {
+  try {
+    if (fileExists(ACTIVE_TASKS_FILE)) {
+      return readJsonFile<ActiveTasksIndex>(ACTIVE_TASKS_FILE);
+    }
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    logError('Failed to read active tasks index', errorObj);
+  }
+
+  // Return empty index if file doesn't exist or can't be read
+  return {
+    updated_at: new Date().toISOString(),
+    tasks: [],
+  };
+}
+
+/**
+ * Save active tasks index
+ */
+async function saveActiveIndex(index: ActiveTasksIndex): Promise<void> {
+  index.updated_at = new Date().toISOString();
+  writeJsonFile(ACTIVE_TASKS_FILE, index);
+}
+
+/**
+ * Add task to active index
+ */
+async function addToActiveIndex(taskId: string): Promise<void> {
+  const index = await getActiveIndex();
+
+  if (!index.tasks.includes(taskId)) {
+    index.tasks.push(taskId);
+    await saveActiveIndex(index);
+    logDebug('Task added to active index', { taskId });
+  }
+}
+
+/**
+ * Remove task from active index
+ */
+async function removeFromActiveIndex(taskId: string): Promise<void> {
+  const index = await getActiveIndex();
+
+  const initialLength = index.tasks.length;
+  index.tasks = index.tasks.filter(id => id !== taskId);
+
+  if (index.tasks.length < initialLength) {
+    await saveActiveIndex(index);
+    logDebug('Task removed from active index', { taskId });
+  }
+}
+
+/**
+ * Get task history for a file (all tasks that touched it)
+ */
+export async function getTaskHistoryForFile(filePath: string): Promise<Task[]> {
+  const allTasks = await listTasks();
+
+  return allTasks.filter(
+    task =>
+      task.files_created.includes(filePath) ||
+      task.files_modified.includes(filePath)
+  );
+}
+
+/**
+ * Get task statistics
+ */
+export async function getTaskStatistics(): Promise<{
+  total: number;
+  byStatus: Record<TaskStatus, number>;
+  avgCompletionTime: number;
+  successRate: number;
+}> {
+  const allTasks = await listTasks();
+
+  const byStatus: Record<TaskStatus, number> = {
+    pending: 0,
+    planning: 0,
+    in_progress: 0,
+    validating: 0,
+    completed: 0,
+    failed: 0,
+    blocked: 0,
+  };
+
+  let totalCompletionTime = 0;
+  let completedOrFailed = 0;
+
+  for (const task of allTasks) {
+    byStatus[task.status]++;
+
+    if (task.completed_at) {
+      const created = new Date(task.created_at).getTime();
+      const completed = new Date(task.completed_at).getTime();
+      totalCompletionTime += completed - created;
+      completedOrFailed++;
+    }
+  }
+
+  const avgCompletionTime = completedOrFailed > 0
+    ? totalCompletionTime / completedOrFailed
+    : 0;
+
+  const successRate = completedOrFailed > 0
+    ? byStatus.completed / completedOrFailed
+    : 0;
+
+  return {
+    total: allTasks.length,
+    byStatus,
+    avgCompletionTime,
+    successRate,
+  };
+}

package/src/trace/trace-event.ts

@@ -9,25 +9,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import { appendFile, readFile, fileExists, ensureDir } from '../utils/file-utils.js';
 import { logInfo, logError, logDebug } from '../utils/logger.js';
-
-export type Mode = 'error_reducer' | 'complexity_reducer' | 'debt_payer' | 'stabilizer' | 'explorer';
-
-export interface TraceEvent {
-  id: string;
-  timestamp: string;
-  agent_id: string;
-  file_path: string;
-  mode: Mode;
-  gradient_before: number;
-  gradient_after: number;
-  gradient_delta: number;
-  changes_made: string[];
-  tokens_used: number;
-  cost_usd: number;
-  duration_ms: number;
-  success: boolean;
-  error?: string;
-}
+import type { TraceEvent, Mode } from '../types/index.js';
 
 export interface TraceFilters {
   file?: string;
@@ -64,13 +46,13 @@ export async function recordTrace(event: TraceEvent): Promise<void> {
     appendFile(TRACES_FILE, line);
 
     // Log summary
-    const costValue = Number(event.cost_usd) || 0;
+    const costValue = Number(event.cost.estimated_usd) || 0;
     logInfo('Trace recorded', {
       file: event.file_path,
       mode: event.mode,
       delta: event.gradient_delta.toFixed(3),
       cost: `$${costValue.toFixed(4)}`,
-      success: event.success,
+      ciPassed: event.ci_passed,
     });
 
     // Check if cleanup needed (every 100 traces)
@@ -172,7 +154,7 @@ export function calculateEfficiency(traces: TraceEvent[]): number {
   }
 
   const totalDelta = traces.reduce((sum, t) => sum + t.gradient_delta, 0);
-  const totalCost = traces.reduce((sum, t) => sum + t.cost_usd, 0);
+  const totalCost = traces.reduce((sum, t) => sum + (t.cost.estimated_usd || 0), 0);
 
   // Prevent division by zero
   if (totalCost === 0) {
@@ -195,9 +177,9 @@ export function getTraceStats(traces: TraceEvent[]): TraceStats {
     };
   }
 
-  const totalCost = traces.reduce((sum, t) => sum + t.cost_usd, 0);
+  const totalCost = traces.reduce((sum, t) => sum + (t.cost.estimated_usd || 0), 0);
   const totalDelta = traces.reduce((sum, t) => sum + t.gradient_delta, 0);
-  const successCount = traces.filter(t => t.success).length;
+  const successCount = traces.filter(t => t.ci_passed).length;
 
   return {
     totalCost,
@@ -313,12 +295,11 @@ export function calculateCost(tokensIn: number, tokensOut: number, model: string
  * Create a trace event with defaults
  */
 export function createTraceEvent(
-  partial: Omit<TraceEvent, 'id' | 'timestamp' | 'gradient_delta'>
+  partial: Omit<TraceEvent, 'id' | 'timestamp'>
 ): TraceEvent {
   return {
     id: generateTraceId(),
     timestamp: new Date().toISOString(),
-    gradient_delta: partial.gradient_before - partial.gradient_after,
     ...partial,
   };
 }