@agile-vibe-coding/avc 0.2.3 → 0.3.2

package/cli/seed-processor.js

@@ -136,8 +136,17 @@ class SeedProcessor {
    */
   async getProviderForStageInstance(stageName) {
     const stageConfig = this.stagesConfig?.[stageName] || {};
-    const provider = stageConfig.provider || this._providerName;
-    const model = stageConfig.model || this._modelName;
+    let provider = stageConfig.provider || this._providerName;
+    let model = stageConfig.model || this._modelName;
+
+    // Resolve to an available provider if current one has no credentials
+    const resolved = await LLMProvider.resolveAvailableProvider(provider, model);
+    if (resolved.fellBack) {
+      console.warn(`[WARN] ${provider} has no API key — falling back to ${resolved.provider} for stage "${stageName}"`);
+      provider = resolved.provider;
+      model = resolved.model;
+    }
+
     const cacheKey = `${stageName}:${provider}:${model}`;
 
     if (this._stageProviders[cacheKey]) return this._stageProviders[cacheKey];
@@ -397,6 +406,11 @@ Decompose this Story into:
 
 Return your response as JSON following the exact structure specified in your instructions.`;
 
+    // If previous iteration had violations, include them so the LLM can fix
+    if (contextData._previousViolations?.length > 0) {
+      prompt += `\n\n## PREVIOUS VALIDATION ISSUES (FIX THESE)\n\nYour previous decomposition had these issues:\n${contextData._previousViolations.map(v => `- [${v.severity}] ${v.description}: ${v.fix || ''}`).join('\n')}\n\nPlease fix ALL issues in your new decomposition.`;
+    }
+
     this.debug('[INFO] Calling LLM for Task/Subtask decomposition', {
       provider: this._providerName,
       model: this._modelName,
@@ -428,36 +442,134 @@ Return your response as JSON following the exact structure specified in your ins
     return hierarchy;
   }
 
-  // STAGE 4: Validate Task/Subtask structure
-  validateTaskSubtaskStructure(hierarchy) {
-    this.debug('[INFO] validateTaskSubtaskStructure() called', { taskCount: hierarchy.tasks?.length });
-
+  // STAGE 4: Structural validation (deterministic, no LLM)
+  // Returns issues array instead of throwing — enables retry loop
+  _validateStructure(hierarchy) {
+    const issues = [];
     const { tasks } = hierarchy;
 
+    if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
+      issues.push({ severity: 'critical', category: 'structure', description: 'No tasks array in decomposition', fix: 'Return a tasks array with 2-5 tasks' });
+      return issues;
+    }
+
     if (tasks.length < 2 || tasks.length > 5) {
-      this.debug('[WARNING] Unexpected task count', { count: tasks.length, expected: '2-5' });
-      sendWarning(`Expected 2-5 Tasks, got ${tasks.length}`);
+      issues.push({ severity: 'minor', category: 'structure', description: `Expected 2-5 tasks, got ${tasks.length}`, fix: `Adjust to 2-5 tasks` });
     }
 
     for (const task of tasks) {
+      // ID format
+      if (!task.id || !task.id.match(/^context-\d{4}-\d{4}-\d{4}[a-z]?$/)) {
+        issues.push({ severity: 'critical', category: 'structure', description: `Invalid Task ID: ${task.id}`, fix: `Use format context-XXXX-XXXX-XXXX` });
+      }
+      // Subtask count
       const subtaskCount = task.subtasks?.length || 0;
       if (subtaskCount < 1 || subtaskCount > 3) {
-        this.debug('[WARNING] Unexpected subtask count', { task: task.name, count: subtaskCount, expected: '1-3' });
-        sendWarning(`Task ${task.name} has ${subtaskCount} Subtasks (expected 1-3)`);
+        issues.push({ severity: 'minor', category: 'structure', description: `Task "${task.name}" has ${subtaskCount} subtasks (expected 1-3)`, fix: 'Adjust subtask count' });
       }
+      // Subtask IDs
+      for (const subtask of task.subtasks || []) {
+        if (!subtask.id || !subtask.id.match(/^context-\d{4}-\d{4}-\d{4}-\d{4}$/)) {
+          issues.push({ severity: 'critical', category: 'structure', description: `Invalid Subtask ID: ${subtask.id}`, fix: `Use format context-XXXX-XXXX-XXXX-XXXX` });
+        }
+      }
+      // Missing acceptance criteria
+      if (!task.acceptance || task.acceptance.length === 0) {
+        issues.push({ severity: 'major', category: 'quality', description: `Task "${task.name}" has no acceptance criteria`, fix: 'Add 2-5 testable acceptance criteria' });
+      }
+    }
+
+    return issues;
+  }
 
-      // Validate Task ID format (context-XXXX-XXXX-XXXX)
-      if (!task.id || !task.id.match(/^context-\d{4}-\d{4}-\d{4}$/)) {
-        throw new Error(`Invalid Task ID format: ${task.id}`);
+  // STAGE 4b: Semantic validation via LLM (optional, if provider available)
+  async _validateSemantics(hierarchy, contextData) {
+    try {
+      const agentInstructions = fs.readFileSync(
+        path.join(this.agentsPath, 'seed-validator.md'), 'utf8'
+      );
+
+      const { storyWork } = contextData;
+      const threshold = this.stagesConfig?.validation?.acceptanceThreshold ?? 80;
+
+      const prompt = `## Story\n\n**Name:** ${storyWork.name}\n**Description:** ${storyWork.description}\n**Acceptance Criteria:**\n${(storyWork.acceptance || []).map((ac, i) => `${i + 1}. ${ac}`).join('\n')}\n\n## Decomposition\n\n${JSON.stringify(hierarchy.tasks, null, 2)}\n\n## Acceptance Threshold\n${threshold}`;
+
+      const provider = await this.getProviderForStageInstance('validation');
+      const result = await provider.generateJSON(prompt, agentInstructions);
+      return result;
+    } catch (err) {
+      this.debug('[WARNING] Semantic validation failed — skipping', { error: err.message });
+      return { score: 100, passed: true, issues: [] };
+    }
+  }
+
+  // Decompose→Validate→Refine loop
+  async decomposeWithValidation(contextData, progressCallback = null) {
+    const maxIterations = this.stagesConfig?.decomposition?.maxIterationsSeed
+      ?? this.stagesConfig?.maxValidationIterations ?? 3;
+    const threshold = this.stagesConfig?.validation?.acceptanceThreshold ?? 80;
+
+    let hierarchy = null;
+    let allIssues = [];
+    let bestHierarchy = null;
+    let bestScore = 0;
+
+    for (let iter = 1; iter <= maxIterations; iter++) {
+      progressCallback?.(`Decomposing story (iteration ${iter}/${maxIterations})...`);
+      this.debug(`[INFO] Decompose iteration ${iter}/${maxIterations}`);
+
+      // Inject violations from previous iteration into context
+      if (allIssues.length > 0) {
+        contextData._previousViolations = allIssues;
       }
 
-      // Validate Subtask ID format (context-XXXX-XXXX-XXXX-XXXX)
-      for (const subtask of task.subtasks || []) {
-        if (!subtask.id || !subtask.id.match(/^context-\d{4}-\d{4}-\d{4}-\d{4}$/)) {
-          throw new Error(`Invalid Subtask ID format: ${subtask.id}`);
+      hierarchy = await this.decomposeIntoTasksSubtasks(contextData);
+
+      // Structural validation (deterministic)
+      const structuralIssues = this._validateStructure(hierarchy);
+      const hasCritical = structuralIssues.some(i => i.severity === 'critical');
+
+      if (hasCritical) {
+        this.debug(`[WARNING] Structural issues (iter ${iter})`, { issues: structuralIssues });
+        allIssues = structuralIssues;
+        if (iter === maxIterations) {
+          this.debug('[ERROR] Max iterations with critical structural issues — using best result');
+          break;
         }
+        continue; // Retry — don't bother with semantic validation if structure is broken
+      }
+
+      // Semantic validation (LLM)
+      progressCallback?.(`Validating decomposition (iteration ${iter}/${maxIterations})...`);
+      const semanticResult = await this._validateSemantics(hierarchy, contextData);
+      const score = semanticResult?.score ?? 100;
+
+      // Track best result
+      if (score > bestScore) {
+        bestScore = score;
+        bestHierarchy = JSON.parse(JSON.stringify(hierarchy));
+      }
+
+      allIssues = [
+        ...structuralIssues,
+        ...(semanticResult?.issues || []),
+      ];
+
+      this.debug(`[INFO] Validation result (iter ${iter})`, { score, issueCount: allIssues.length, passed: semanticResult?.passed });
+
+      if (semanticResult?.passed || score >= threshold) {
+        progressCallback?.(`Validation passed (score: ${score}, threshold: ${threshold})`);
+        break;
+      }
+
+      if (iter === maxIterations) {
+        progressCallback?.(`Max iterations — accepting score ${score} (threshold: ${threshold})`);
+        this.debug(`[WARNING] Max iterations reached — accepting best score ${bestScore}`);
       }
     }
+
+    // Use best result if final iteration didn't improve
+    return bestHierarchy && bestScore > (hierarchy?._score ?? 0) ? bestHierarchy : hierarchy;
   }
 
   // STAGE 5-6: Generate contexts
@@ -723,13 +835,9 @@ Return your response as JSON following the exact structure specified in your ins
       sendInfo('Reading Story context...');
       const contextData = this.readStoryContext();
 
-      // Stage 3: Decompose
-      this.debug('[INFO] Stage 2b: Decomposing Story into Tasks/Subtasks via LLM');
-      let hierarchy = await this.decomposeIntoTasksSubtasks(contextData);
-
-      // Stage 4: Validate
-      this.debug('[INFO] Stage 2c: Validating decomposition structure');
-      this.validateTaskSubtaskStructure(hierarchy);
+      // Stage 3+4: Decompose with validation loop
+      this.debug('[INFO] Stage 2b: Decomposing Story with validation loop');
+      let hierarchy = await this.decomposeWithValidation(contextData);
 
       // Stage 5-7: Generate contexts and write files
       this.debug('[INFO] Stage 2/3: Generating context files and writing to disk');
@@ -789,4 +897,66 @@ Return your response as JSON following the exact structure specified in your ins
   }
 }
 
+  /**
+   * Worker-compatible execution — uses callbacks instead of REPL output functions.
+   * Called by seed-worker.js (forked process).
+   *
+   * @param {Function} progressCallback - (message, substep?, meta?) → void
+   * @param {Function} [itemWrittenCallback] - ({ itemId, itemType }) → void
+   * @param {Function} [cancelledCheck] - () → boolean, returns true if cancelled
+   * @returns {Promise<{ taskCount: number, subtaskCount: number, taskIds: string[] }>}
+   */
+  async executeWithCallback(progressCallback, itemWrittenCallback = null, cancelledCheck = null) {
+    const execStartTime = Date.now();
+    this.debug('[INFO] SeedProcessor.executeWithCallback() started', {
+      storyId: this.storyId,
+      provider: this._providerName,
+      model: this._modelName,
+    });
+
+    // Stage 1: Validate
+    progressCallback?.('Validating prerequisites...');
+    if (cancelledCheck?.()) throw new Error('CEREMONY_CANCELLED');
+    this.validatePrerequisites();
+
+    // Stage 2a: Read context
+    progressCallback?.('Reading story context...');
+    if (cancelledCheck?.()) throw new Error('CEREMONY_CANCELLED');
+    const contextData = this.readStoryContext();
+
+    // Stage 2b+2c: Decompose with validation loop
+    if (cancelledCheck?.()) throw new Error('CEREMONY_CANCELLED');
+    let hierarchy = await this.decomposeWithValidation(contextData, progressCallback);
+
+    // Stage 3: Write files
+    progressCallback?.('Writing task and subtask files...');
+    if (cancelledCheck?.()) throw new Error('CEREMONY_CANCELLED');
+
+    // Temporarily override _itemWrittenCallback on writeTaskSubtaskFiles
+    const origCallback = this._itemWrittenCallback;
+    this._itemWrittenCallback = itemWrittenCallback;
+    const { taskCount, subtaskCount, taskIds } = await this.writeTaskSubtaskFiles(hierarchy, contextData);
+    this._itemWrittenCallback = origCallback;
+
+    // Stage 4: Update parent story
+    progressCallback?.('Updating story metadata...');
+    this.updateStoryWorkJson(taskIds);
+
+    // Finalize token tracking
+    if (this.llmProvider) {
+      this.tokenTracker.finalizeRun(this.ceremonyName);
+    }
+
+    const duration = Date.now() - execStartTime;
+    this.debug('[INFO] SeedProcessor.executeWithCallback() complete', {
+      storyId: this.storyId,
+      duration: `${duration}ms`,
+      taskCount,
+      subtaskCount,
+    });
+
+    return { taskCount, subtaskCount, taskIds };
+  }
+}
+
 export { SeedProcessor };