popeye-cli 2.2.0 → 2.7.0

package/src/state/index.ts

@@ -578,6 +578,10 @@ export interface ProjectProgressAnalysis {
   statusMismatch: boolean;  // true if status='complete' but work is incomplete
   planMismatch: boolean;    // true if plan file has more tasks than state
 
+  // Pipeline state (when applicable)
+  pipelinePhase?: string;       // Current pipeline phase (e.g. 'DONE', 'STUCK', 'IMPLEMENTATION')
+  pipelineTerminal: boolean;    // true if pipeline is in DONE or STUCK state
+
   // Milestone breakdown (from state)
   totalMilestones: number;
   completedMilestones: number;
@@ -780,14 +784,42 @@ export async function analyzeProjectProgress(projectDir: string): Promise<Projec
     : 0;
 
   // Determine if actually complete - must match plan if plan has more tasks
-  const isActuallyComplete = totalMilestones > 0 &&
-    completedMilestones === totalMilestones &&
-    completedTasks === totalTasks &&
-    !planMismatch; // Can't be complete if plan has more tasks
+  // v2.4.6: When no milestones/tasks exist in state but project was explicitly
+  // marked complete (status='complete' + phase='complete'), trust the status.
+  // completeProject() only sets both to 'complete' after build verification passes.
+  const noTrackingData = totalMilestones === 0 && totalTasks === 0;
+  const explicitlyCompleted = state.status === 'complete' && state.phase === 'complete';
+
+  // Pipeline state detection — pipeline truth overrides milestone truth.
+  // RECOVERY_LOOP is treated as stuck-like: the pipeline was interrupted mid-recovery
+  // and will just re-fail without new guidance.
+  const pipelinePhase = state.pipeline?.pipelinePhase;
+  const pipelineStuckLike = pipelinePhase === 'STUCK' || pipelinePhase === 'RECOVERY_LOOP';
+  const pipelineTerminal = pipelinePhase === 'DONE' || pipelineStuckLike;
+  const pipelineDone = pipelinePhase === 'DONE';
+
+  let isActuallyComplete: boolean;
+  if (noTrackingData && pipelinePhase) {
+    // Pipeline project: pipeline state is the source of truth.
+    // DONE = complete, STUCK = not complete.
+    // planMismatch is irrelevant — pipeline projects don't track milestones.
+    isActuallyComplete = pipelineDone;
+  } else if (noTrackingData) {
+    // Legacy project with no tracking: trust explicit completion only
+    isActuallyComplete = explicitlyCompleted && !planMismatch;
+  } else {
+    // Standard milestone-based: all milestones + tasks must be complete
+    isActuallyComplete = totalMilestones > 0 &&
+      completedMilestones === totalMilestones &&
+      completedTasks === totalTasks &&
+      !planMismatch; // Can't be complete if plan has more tasks
+  }
 
-  // Check for status mismatch
+  // Check for status mismatch.
+  // Pipeline terminal states are handled separately — not "mismatches".
   const statusMismatch = (state.status === 'complete' || state.phase === 'complete') &&
-    (!isActuallyComplete || planMismatch);
+    (!isActuallyComplete || planMismatch) &&
+    !pipelineTerminal;
 
   // Find next items to work on
   let nextMilestone: { id: string; name: string } | undefined;
@@ -836,6 +868,15 @@ export async function analyzeProjectProgress(projectDir: string): Promise<Projec
   if (planMismatch) {
     progressSummary = `PLAN MISMATCH: State has ${completedTasks}/${totalTasks} tasks but plan has ${planTaskCount} tasks. ` +
       `Only ${percentComplete}% of plan completed.`;
+  } else if (isActuallyComplete && pipelineDone && noTrackingData) {
+    progressSummary = 'Project completed via pipeline';
+  } else if (isActuallyComplete && noTrackingData) {
+    progressSummary = 'Project completed (no milestone tracking data)';
+  } else if (pipelineStuckLike) {
+    const failedAt = state.pipeline?.failedPhase ?? 'unknown';
+    const recoveryCount = state.pipeline?.recoveryCount ?? 0;
+    const label = pipelinePhase === 'RECOVERY_LOOP' ? 'PIPELINE STUCK (in recovery)' : 'PIPELINE STUCK';
+    progressSummary = `${label}: Failed at ${failedAt} after ${recoveryCount} recovery attempts`;
   } else if (isActuallyComplete) {
     progressSummary = `All ${totalTasks} tasks complete across ${totalMilestones} milestones`;
   } else if (statusMismatch) {
@@ -848,6 +889,8 @@ export async function analyzeProjectProgress(projectDir: string): Promise<Projec
     isActuallyComplete,
     statusMismatch,
     planMismatch,
+    pipelinePhase,
+    pipelineTerminal,
     totalMilestones,
     completedMilestones,
     inProgressMilestones,
@@ -927,6 +970,15 @@ export async function verifyProjectCompletion(projectDir: string): Promise<{
  * @returns Updated state
  */
 export async function resetIncompleteProject(projectDir: string): Promise<ProjectState> {
+  const current = await loadProject(projectDir);
+
+  // Pipeline projects should not be reset via legacy path —
+  // legacy reset changes phase/status but not pipeline.pipelinePhase,
+  // creating inconsistent state. Pipeline resume handles its own recovery.
+  if (current.pipeline?.pipelinePhase) {
+    return current;
+  }
+
   const verification = await verifyProjectCompletion(projectDir);
 
   if (verification.isComplete) {
@@ -955,8 +1007,8 @@ export async function resetIncompleteProject(projectDir: string): Promise<Projec
   }
 
   // Reset any failed tasks to pending for retry
-  const current = await loadProject(projectDir);
-  const updatedMilestones = current.milestones.map(m => ({
+  const latestState = await loadProject(projectDir);
+  const updatedMilestones = latestState.milestones.map(m => ({
     ...m,
     // Reset milestone status if it was incorrectly marked complete
     status: m.tasks.every(t => t.status === 'complete')

package/src/types/consensus.ts

@@ -35,6 +35,7 @@ export interface ConsensusResult {
   analysis: string;
   strengths: string[];
   concerns: string[];
+  blockingIssues: string[];
   recommendations: string[];
   approved: boolean;
   rawResponse: string;

package/src/types/workflow.ts

@@ -11,6 +11,8 @@ import type { TestPlanOutput } from './tester.js';
 import { TestPlanOutputSchema, TestVerdictSchema } from './tester.js';
 import type { DbConfig } from './database.js';
 import { DbConfigSchema } from './database.js';
+import { PipelineStateSchema } from '../pipeline/types.js';
+import type { PipelineState } from '../pipeline/types.js';
 
 /**
  * Workflow phases
@@ -244,6 +246,8 @@ export interface ProjectState {
   auditLastRunAt?: string;
   /** Unique identifier for the audit run */
   auditRunId?: string;
+  /** Pipeline execution state — persisted for resume across sessions (v2.4.5) */
+  pipeline?: PipelineState;
 }
 
 /**
@@ -271,6 +275,7 @@ export const ProjectStateSchema = z.object({
         analysis: z.string(),
         strengths: z.array(z.string()),
         concerns: z.array(z.string()),
+        blockingIssues: z.array(z.string()).default([]),
         recommendations: z.array(z.string()),
         approved: z.boolean(),
         rawResponse: z.string(),
@@ -296,6 +301,7 @@ export const ProjectStateSchema = z.object({
   auditRecoveryInProgress: z.boolean().optional(),
   auditLastRunAt: z.string().optional(),
   auditRunId: z.string().optional(),
+  pipeline: PipelineStateSchema.optional(),
 });
 
 /**

package/src/upgrade/handlers.ts

@@ -21,7 +21,7 @@ import {
   generateRootDockerCompose,
 } from '../generators/templates/fullstack.js';
 import { loadState, saveState } from '../state/persistence.js';
-import { buildWebsiteContext, resolveBrandAssets, validateWebsiteContext } from '../generators/website-context.js';
+import { buildWebsiteContext, resolveBrandAssets, validateWebsiteContext, extractDocPathsFromText } from '../generators/website-context.js';
 import type { WebsiteContentContext } from '../generators/website-context.js';
 import { resolveWorkspaceRoot } from '../generators/workspace-root.js';
 import { loadWebsiteStrategy } from '../workflow/website-strategy.js';
@@ -61,11 +61,17 @@ export async function buildUpgradeContentContext(
   projectName: string,
 ): Promise<{ context?: WebsiteContentContext; warning?: string }> {
   try {
+    // Load state once for idea text + brand context
+    const state = await loadState(projectDir);
+
     // Build context from user docs (scans projectDir + parent via getScanDirectories)
-    const context = await buildWebsiteContext(projectDir, projectName);
+    // Extract extra doc paths from state idea text if available
+    const extraDocPaths = state?.idea ? extractDocPathsFromText(state.idea) : [];
+    const context = await buildWebsiteContext(
+      projectDir, projectName, state?.specification ?? state?.idea, extraDocPaths,
+    );
 
     // Apply brand context from state if available
-    const state = await loadState(projectDir);
     if (state?.brandContext?.primaryColor) {
       context.brand = { ...context.brand, primaryColor: state.brandContext.primaryColor };
     }

package/src/workflow/consensus.ts

@@ -1176,6 +1176,7 @@ export async function runOptimizedConsensusProcess(
       score: combinedScore,
       analysis: combinedAnalysis,
       concerns: allConcerns,
+      blockingIssues: [],
       recommendations: allRecommendations,
       approved: combinedScore >= threshold,
       strengths: [],

package/src/workflow/website-strategy.ts

@@ -13,6 +13,7 @@ import type {
   BrandAssetsContract,
 } from '../types/website-strategy.js';
 import { WebsiteStrategySchema } from '../types/website-strategy.js';
+import { formatWebsiteStrategy } from '../shared/website-strategy-format.js';
 import { createClient } from '../adapters/openai.js';
 
 /** File name for persisted strategy */
@@ -187,42 +188,7 @@ Respond with ONLY valid JSON, no markdown code fences or explanation.`;
 export function formatStrategyForPlanContext(
   strategy: WebsiteStrategyDocument
 ): string {
-  const lines: string[] = [];
-
-  lines.push(`### Target Customer`);
-  lines.push(`- Persona: ${strategy.icp.primaryPersona}`);
-  lines.push(`- Pain points: ${strategy.icp.painPoints.join(', ')}`);
-  lines.push('');
-
-  lines.push(`### Positioning`);
-  lines.push(`- Category: ${strategy.positioning.category}`);
-  lines.push(`- Value proposition: ${strategy.positioning.valueProposition}`);
-  lines.push(`- Differentiators: ${strategy.positioning.differentiators.join(', ')}`);
-  lines.push('');
-
-  lines.push(`### Messaging`);
-  lines.push(`- Headline: ${strategy.messaging.headline}`);
-  lines.push(`- Subheadline: ${strategy.messaging.subheadline}`);
-  lines.push('');
-
-  lines.push(`### SEO Keywords`);
-  lines.push(`- Primary: ${strategy.seoStrategy.primaryKeywords.join(', ')}`);
-  lines.push(`- Secondary: ${strategy.seoStrategy.secondaryKeywords.join(', ')}`);
-  lines.push('');
-
-  lines.push(`### Site Architecture`);
-  for (const page of strategy.siteArchitecture.pages) {
-    lines.push(`- ${page.path} (${page.pageType}): ${page.purpose}`);
-  }
-  lines.push('');
-
-  lines.push(`### Conversion Strategy`);
-  lines.push(`- Primary CTA: "${strategy.conversionStrategy.primaryCta.text}" -> ${strategy.conversionStrategy.primaryCta.href}`);
-  lines.push(`- Secondary CTA: "${strategy.conversionStrategy.secondaryCta.text}" -> ${strategy.conversionStrategy.secondaryCta.href}`);
-  lines.push(`- Trust signals: ${strategy.conversionStrategy.trustSignals.join(', ')}`);
-  lines.push(`- Lead capture: ${strategy.conversionStrategy.leadCapture}`);
-
-  return lines.join('\n');
+  return formatWebsiteStrategy(strategy);
 }
 
 /**

package/src/workflow/website-updater.ts

@@ -9,7 +9,7 @@ import path from 'node:path';
 import type { ProjectState } from '../types/workflow.js';
 import type { OutputLanguage } from '../types/project.js';
 import { isWorkspace } from '../types/project.js';
-import { buildWebsiteContext, resolveBrandAssets, validateWebsiteContext } from '../generators/website-context.js';
+import { buildWebsiteContext, resolveBrandAssets, validateWebsiteContext, extractDocPathsFromText } from '../generators/website-context.js';
 import { resolveWorkspaceRoot } from '../generators/workspace-root.js';
 import { generateWebsiteLandingPage } from '../generators/templates/website-landing.js';
 import { generateWebsitePricingPage } from '../generators/templates/website-pricing.js';
@@ -52,10 +52,12 @@ export async function updateWebsiteContent(
 
   // Build content context from user docs and specification
   const parentDir = path.dirname(projectDir);
+  const extraDocPaths = state.idea ? extractDocPathsFromText(state.idea) : [];
   const context = await buildWebsiteContext(
     parentDir,
     state.name,
-    state.specification
+    state.specification,
+    extraDocPaths,
   );
 
   // Apply brand context from state if available

package/tests/adapters/gemini.test.ts

@@ -0,0 +1,165 @@
+/**
+ * Tests for Gemini adapter - parseConsensusResponse
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseConsensusResponse } from '../../src/adapters/gemini.js';
+
+describe('Gemini parseConsensusResponse', () => {
+  it('should parse a complete response with blocking issues', () => {
+    const response = `
+ANALYSIS:
+Well-structured plan with clear goals.
+
+STRENGTHS:
+- Good module separation
+- Clear API design
+
+CONCERNS:
+- Consider adding rate limiting
+
+BLOCKING_ISSUES:
+- Missing authentication middleware
+- No input validation strategy
+
+RECOMMENDATIONS:
+- Add rate limiting middleware
+
+CONSENSUS: 72%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(72);
+    expect(result.approved).toBe(false);
+    expect(result.concerns).toEqual(['Consider adding rate limiting']);
+    expect(result.blockingIssues).toEqual([
+      'Missing authentication middleware',
+      'No input validation strategy',
+    ]);
+    expect(result.recommendations).toEqual(['Add rate limiting middleware']);
+  });
+
+  it('should return empty blocking issues when "None"', () => {
+    const response = `
+ANALYSIS:
+Excellent plan.
+
+STRENGTHS:
+- Comprehensive coverage
+
+CONCERNS:
+- Minor naming inconsistencies
+
+BLOCKING_ISSUES:
+- None
+
+RECOMMENDATIONS:
+- Standardize naming conventions
+
+CONSENSUS: 96%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(96);
+    expect(result.approved).toBe(true);
+    expect(result.blockingIssues).toEqual([]);
+    expect(result.concerns).toHaveLength(1);
+  });
+
+  it('should handle missing BLOCKING_ISSUES section (backward compat)', () => {
+    const response = `
+ANALYSIS:
+Good plan overall.
+
+STRENGTHS:
+- Solid architecture design
+
+CONCERNS:
+- Some performance issue to watch
+
+RECOMMENDATIONS:
+- Optimize database queries
+
+CONSENSUS: 88%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.blockingIssues).toEqual([]);
+    expect(result.score).toBe(88);
+  });
+
+  it('should filter none-variant blocking issues like "No blocking issues found"', () => {
+    const response = `
+ANALYSIS:
+Good plan with solid foundation.
+
+STRENGTHS:
+- Clean design
+
+CONCERNS:
+- Minor performance concern
+
+BLOCKING_ISSUES:
+- No blocking issues found
+
+RECOMMENDATIONS:
+- Optimize queries
+
+CONSENSUS: 91%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should filter "None identified" from blocking issues', () => {
+    const response = `
+ANALYSIS:
+Thorough review complete.
+
+STRENGTHS:
+- Well-structured code
+
+CONCERNS:
+- Could use more tests
+
+BLOCKING_ISSUES:
+- None identified
+
+RECOMMENDATIONS:
+- Add integration tests
+
+CONSENSUS: 89%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should handle ALL-CAPS format for blocking issues', () => {
+    const response = `
+ANALYSIS:
+Detailed review of the plan.
+
+STRENGTHS:
+- Good structure
+
+CONCERNS:
+- Minor issue noted
+
+BLOCKING_ISSUES:
+- Critical security flaw
+
+RECOMMENDATIONS:
+- Fix security
+
+CONSENSUS: 60%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.blockingIssues).toEqual(['Critical security flaw']);
+    expect(result.recommendations).toEqual(['Fix security']);
+  });
+});

package/tests/adapters/grok.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Tests for Grok adapter - parseConsensusResponse
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseConsensusResponse } from '../../src/adapters/grok.js';
+
+describe('Grok parseConsensusResponse', () => {
+  it('should parse a complete response with blocking issues', () => {
+    const response = `
+ANALYSIS:
+Solid plan with room for improvement.
+
+STRENGTHS:
+- Clean API design
+- Good test coverage plan
+
+CONCERNS:
+- Consider adding monitoring
+
+BLOCKING_ISSUES:
+- Missing database migration strategy
+- No rollback plan defined
+
+RECOMMENDATIONS:
+- Add observability layer
+
+CONSENSUS: 70%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(70);
+    expect(result.approved).toBe(false);
+    expect(result.concerns).toEqual(['Consider adding monitoring']);
+    expect(result.blockingIssues).toEqual([
+      'Missing database migration strategy',
+      'No rollback plan defined',
+    ]);
+  });
+
+  it('should return empty blocking issues when "None"', () => {
+    const response = `
+ANALYSIS:
+Great plan.
+
+STRENGTHS:
+- Well-structured
+
+CONCERNS:
+- Minor style inconsistencies
+
+BLOCKING_ISSUES:
+- None
+
+RECOMMENDATIONS:
+- Apply consistent formatting
+
+CONSENSUS: 95%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(95);
+    expect(result.approved).toBe(true);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should filter none-variant blocking issues like "No blocking issues found"', () => {
+    const response = `
+ANALYSIS:
+Solid implementation plan.
+
+STRENGTHS:
+- Good architecture
+
+CONCERNS:
+- Consider monitoring
+
+BLOCKING_ISSUES:
+- No blocking issues found
+
+RECOMMENDATIONS:
+- Add monitoring
+
+CONSENSUS: 93%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should filter "None identified" from blocking issues', () => {
+    const response = `
+ANALYSIS:
+Well-considered approach.
+
+STRENGTHS:
+- Comprehensive coverage
+
+CONCERNS:
+- Minor style issues
+
+BLOCKING_ISSUES:
+- None identified
+
+RECOMMENDATIONS:
+- Standardize formatting
+
+CONSENSUS: 91%
+`;
+    const result = parseConsensusResponse(response);
+    expect(result.blockingIssues).toEqual([]);
+  });
+
+  it('should handle missing BLOCKING_ISSUES section (backward compat)', () => {
+    const response = `
+ANALYSIS:
+Reasonable plan.
+
+STRENGTHS:
+- Good overall approach
+
+CONCERNS:
+- Needs more detail
+
+RECOMMENDATIONS:
+- Expand on implementation details
+
+CONSENSUS: 82%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.blockingIssues).toEqual([]);
+    expect(result.score).toBe(82);
+  });
+});