opencastle 0.29.0 → 0.30.0

package/src/cli/pipeline.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect } from 'vitest'
+import { parseComplexityAssessment } from './pipeline.js'
+
+const SINGLE_PRD = `# My Feature — PRD
+
+## Overview
+Some overview.
+
+## Risks & Open Questions
+None identified.
+
+## Complexity Assessment
+
+\`\`\`json
+{
+  "total_tasks": 4,
+  "total_phases": 2,
+  "domains": ["api", "frontend"],
+  "estimated_duration_minutes": 60,
+  "complexity": "medium",
+  "recommended_strategy": "single",
+  "chain_rationale": "",
+  "convoy_groups": [
+    {
+      "name": "full-implementation",
+      "description": "All phases in a single convoy",
+      "phases": [1, 2],
+      "depends_on": []
+    }
+  ]
+}
+\`\`\`
+`
+
+const CHAIN_PRD = `# Big Feature — PRD
+
+## Overview
+Big feature.
+
+## Risks & Open Questions
+None identified.
+
+## Complexity Assessment
+
+\`\`\`json
+{
+  "total_tasks": 12,
+  "total_phases": 4,
+  "domains": ["database", "api", "frontend", "testing"],
+  "estimated_duration_minutes": 240,
+  "complexity": "high",
+  "recommended_strategy": "chain",
+  "chain_rationale": "Database schema changes have no frontend dependencies and can be validated independently.",
+  "convoy_groups": [
+    {
+      "name": "database-setup",
+      "description": "Schema changes and migrations",
+      "phases": [1],
+      "depends_on": []
+    },
+    {
+      "name": "api-integration",
+      "description": "API routes and server logic",
+      "phases": [2],
+      "depends_on": ["database-setup"]
+    },
+    {
+      "name": "frontend-testing",
+      "description": "UI components and test suite",
+      "phases": [3, 4],
+      "depends_on": ["api-integration"]
+    }
+  ]
+}
+\`\`\`
+`
+
+const NO_SECTION_PRD = `# Feature — PRD
+
+## Overview
+Plain prd with no complexity section.
+
+## Risks & Open Questions
+None.
+`
+
+const MALFORMED_JSON_PRD = `# Feature — PRD
+
+## Complexity Assessment
+
+\`\`\`json
+{ "total_tasks": 3, "broken": 
+\`\`\`
+`
+
+const UNFENCED_JSON_PRD = `# Feature — PRD
+
+## Complexity Assessment
+
+The complexity is medium.
+
+total_tasks: 3, total_phases: 2
+`
+
+const OTHER_JSON_PRD = `# Feature — PRD
+
+## Overview
+Some feature with json-like content: \`{"key": "value"}\`
+
+Another block:
+\`\`\`json
+{"not": "complexity"}
+\`\`\`
+
+## Complexity Assessment
+
+\`\`\`json
+{
+  "total_tasks": 6,
+  "total_phases": 3,
+  "domains": ["api", "frontend"],
+  "complexity": "medium",
+  "recommended_strategy": "single",
+  "convoy_groups": [
+    {
+      "name": "impl",
+      "description": "All phases",
+      "phases": [1, 2, 3],
+      "depends_on": []
+    }
+  ]
+}
+\`\`\`
+`
+
+describe('parseComplexityAssessment', () => {
+  it('returns null when PRD has no Complexity Assessment section', () => {
+    expect(parseComplexityAssessment(NO_SECTION_PRD)).toBeNull()
+  })
+
+  it('returns null when JSON is malformed', () => {
+    expect(parseComplexityAssessment(MALFORMED_JSON_PRD)).toBeNull()
+  })
+
+  it('parses a valid single strategy assessment', () => {
+    const result = parseComplexityAssessment(SINGLE_PRD)
+    expect(result).not.toBeNull()
+    expect(result?.recommended_strategy).toBe('single')
+    expect(result?.complexity).toBe('medium')
+    expect(result?.total_tasks).toBe(4)
+    expect(result?.total_phases).toBe(2)
+    expect(result?.domains).toEqual(['api', 'frontend'])
+    expect(result?.convoy_groups).toHaveLength(1)
+    expect(result?.convoy_groups[0].name).toBe('full-implementation')
+  })
+
+  it('parses a valid chain strategy assessment with multiple groups', () => {
+    const result = parseComplexityAssessment(CHAIN_PRD)
+    expect(result).not.toBeNull()
+    expect(result?.recommended_strategy).toBe('chain')
+    expect(result?.complexity).toBe('high')
+    expect(result?.convoy_groups).toHaveLength(3)
+    expect(result?.convoy_groups[0].name).toBe('database-setup')
+    expect(result?.convoy_groups[1].depends_on).toEqual(['database-setup'])
+    expect(result?.convoy_groups[2].phases).toEqual([3, 4])
+  })
+
+  it('handles missing optional fields gracefully', () => {
+    const prd = `# Feature — PRD\n\n## Complexity Assessment\n\n\`\`\`json\n{\n  "total_tasks": 3,\n  "total_phases": 1,\n  "domains": ["api"],\n  "complexity": "low",\n  "recommended_strategy": "single",\n  "convoy_groups": [{"name": "all", "description": "All", "phases": [1], "depends_on": []}]\n}\n\`\`\`\n`
+    const result = parseComplexityAssessment(prd)
+    expect(result).not.toBeNull()
+    expect(result?.estimated_duration_minutes).toBeUndefined()
+    expect(result?.chain_rationale).toBeUndefined()
+  })
+
+  it('returns null when JSON block is not fenced properly', () => {
+    expect(parseComplexityAssessment(UNFENCED_JSON_PRD)).toBeNull()
+  })
+
+  it('correctly extracts JSON even when PRD has other JSON-like content elsewhere', () => {
+    const result = parseComplexityAssessment(OTHER_JSON_PRD)
+    expect(result).not.toBeNull()
+    expect(result?.total_tasks).toBe(6)
+    expect(result?.recommended_strategy).toBe('single')
+  })
+
+  it('returns null when required fields are missing from JSON', () => {
+    const prd = `# Feature — PRD\n\n## Complexity Assessment\n\n\`\`\`json\n{"total_tasks": 3}\n\`\`\`\n`
+    expect(parseComplexityAssessment(prd)).toBeNull()
+  })
+})

package/src/cli/pipeline.ts

@@ -1,10 +1,56 @@
-import { readFile } from 'node:fs/promises'
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { resolve } from 'node:path'
+import { resolve, dirname } from 'node:path'
+import { stringify } from 'yaml'
 import { c, confirm, closePrompts } from './prompt.js'
 import { runPromptStep } from './plan.js'
 import type { CliContext } from './types.js'
 
+export interface ConvoyGroup {
+  name: string
+  description: string
+  phases: number[]
+  depends_on: string[]
+}
+
+export interface ComplexityAssessment {
+  total_tasks: number
+  total_phases: number
+  domains: string[]
+  estimated_duration_minutes?: number
+  complexity: 'low' | 'medium' | 'high'
+  recommended_strategy: 'single' | 'chain'
+  chain_rationale?: string
+  convoy_groups: ConvoyGroup[]
+}
+
+export function parseComplexityAssessment(prdContent: string): ComplexityAssessment | null {
+  const sectionMatch = prdContent.match(/## Complexity Assessment\s+([\s\S]*?)(?=\n## |\n# |$)/)
+  if (!sectionMatch) return null
+
+  const sectionContent = sectionMatch[1]
+  const jsonMatch = sectionContent.match(/```json\s*([\s\S]*?)```/)
+  if (!jsonMatch) return null
+
+  try {
+    const parsed = JSON.parse(jsonMatch[1].trim()) as ComplexityAssessment
+    // Validate required fields
+    if (
+      typeof parsed.total_tasks !== 'number' ||
+      typeof parsed.total_phases !== 'number' ||
+      !Array.isArray(parsed.domains) ||
+      !parsed.complexity ||
+      !parsed.recommended_strategy ||
+      !Array.isArray(parsed.convoy_groups)
+    ) {
+      return null
+    }
+    return parsed
+  } catch {
+    return null
+  }
+}
+
 const HELP = `
   opencastle pipeline [options]
 
@@ -12,9 +58,10 @@ const HELP = `
 
     Step 1 — Generate PRD        (generate-prd)
     Step 2 — Validate PRD        (validate-prd)
-    Step 3 — Generate convoy spec (generate-convoy, using PRD as BDO)
-    Step 4 — Validate convoy spec (validate-convoy)
-    Step 5 — Fix convoy spec      (fix-convoy, up to 2 retries if invalid)
+    Step 3 — Fix PRD             (fix-prd, up to 2 retries if invalid)
+    Step 4 — Generate convoy spec (generate-convoy, using PRD as BDO)
+    Step 5 — Validate convoy spec (validate-convoy)
+    Step 6 — Fix convoy spec      (fix-convoy, up to 2 retries if invalid)
 
   Options:
     --text, -t <text>        Feature prompt text (required, unless --prd is set)
@@ -137,7 +184,7 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     }
   }
 
-  const totalSteps = opts.skipValidation ? 3 : 5
+  const totalSteps = opts.skipValidation ? 3 : 6
   const sharedOpts = {
     adapterName: opts.adapter ?? undefined,
     verbose: opts.verbose,
@@ -196,20 +243,254 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     }
 
     if (!result.isValid) {
-      console.log(c.red(`  ✗ PRD validation failed.\n`))
-      console.log(result.errors ?? result.rawOutput)
+      let prdValidationErrors = result.errors ?? result.rawOutput
+      console.log(c.yellow(`  ⚠ PRD has validation issues — attempting auto-fix…\n`))
+      console.log(c.dim(prdValidationErrors))
+      console.log()
+
+      // ── Step 3: Fix PRD (up to 2 retries) ──────────────────────────────────
+      const MAX_PRD_FIX_RETRIES = 2
+      let fixedPrdContent = prdContent
+      let prdFixed = false
+
+      for (let attempt = 1; attempt <= MAX_PRD_FIX_RETRIES; attempt++) {
+        const label = `Fix PRD attempt ${attempt}/${MAX_PRD_FIX_RETRIES}…`
+        console.log(stepLabel(3, totalSteps, label))
+
+        try {
+          await runPromptStep({
+            ...sharedOpts,
+            template: 'fix-prd',
+            goalText: fixedPrdContent,
+            contextText: prdValidationErrors,
+            outputPath: prdPath, // overwrite in place
+          })
+        } catch (err) {
+          console.error(`\n  ✗ Step 3 (attempt ${attempt}) failed: ${err instanceof Error ? err.message : String(err)}`)
+          process.exit(1)
+        }
+
+        console.log(c.dim(`  Re-validating after fix…`))
+
+        fixedPrdContent = await readFile(prdPath, 'utf8')
+
+        let revalidation
+        try {
+          revalidation = await runPromptStep({
+            ...sharedOpts,
+            template: 'validate-prd',
+            goalText: fixedPrdContent,
+          })
+        } catch (err) {
+          console.error(`\n  ✗ Re-validation failed: ${err instanceof Error ? err.message : String(err)}`)
+          process.exit(1)
+        }
+
+        if (revalidation.isValid) {
+          console.log(c.green(`  ✓ PRD fixed and validated\n`))
+          prdFixed = true
+          break
+        }
+
+        prdValidationErrors = revalidation.errors ?? revalidation.rawOutput
+
+        if (attempt < MAX_PRD_FIX_RETRIES) {
+          console.log(c.yellow(`  ⚠ Still has issues after fix attempt ${attempt} — retrying…\n`))
+          console.log(c.dim(prdValidationErrors))
+          console.log()
+        }
+      }
+
+      if (!prdFixed) {
+        console.log(c.red(`\n  ✗ Could not auto-fix the PRD after ${MAX_PRD_FIX_RETRIES} attempts.\n`))
+        console.log(`  Remaining issues:\n`)
+        console.log(prdValidationErrors)
+        console.log(
+          c.dim(`\n  The PRD has been saved to ${relPath(prdPath)} with the best available fixes.\n`) +
+            c.dim(`  Review the remaining issues above and edit the file manually, then re-run with:\n`) +
+            `    opencastle pipeline --prd ${relPath(prdPath)}${opts.adapter ? ` --adapter ${opts.adapter}` : ''}\n`
+        )
+        process.exit(1)
+      }
+    } else {
+      console.log(c.green(`  ✓ PRD is valid\n`))
+    }
+  }
+
+  // ── Complexity-aware strategy decision ────────────────────────────────────
+  const prdContentForComplexity = await readFile(prdPath, 'utf8')
+  const complexity = parseComplexityAssessment(prdContentForComplexity)
+
+  if (complexity) {
+    if (complexity.recommended_strategy === 'chain' && complexity.convoy_groups.length > 1) {
       console.log(
-        c.dim(`\n  Fix the PRD at ${relPath(prdPath)} and re-run with:\n`) +
-          `    opencastle pipeline --prd ${relPath(prdPath)}${opts.adapter ? ` --adapter ${opts.adapter}` : ''}\n`
+        c.cyan(`  ℹ`) +
+          ` Complexity: ${complexity.complexity} | Strategy: chain | ${complexity.convoy_groups.length} convoy groups\n`
+      )
+      console.log(`  Chain plan:`)
+      for (let i = 0; i < complexity.convoy_groups.length; i++) {
+        const g = complexity.convoy_groups[i]
+        const depStr =
+          g.depends_on.length > 0 ? ` → depends on: ${g.depends_on.join(', ')}` : ''
+        console.log(
+          `    ${i + 1}. ${g.name.padEnd(20)} (phases: ${g.phases.join(', ')})${depStr}`
+        )
+      }
+      console.log()
+
+      const convoyDir = resolve(process.cwd(), '.opencastle', 'convoys')
+      await mkdir(convoyDir, { recursive: true })
+
+      const genBaseStep = opts.skipValidation ? 2 : 4
+      const groupSpecPaths: string[] = []
+      const totalGroupSteps =
+        (opts.skipValidation ? 2 : 3) + complexity.convoy_groups.length * (opts.skipValidation ? 1 : 2)
+
+      for (let i = 0; i < complexity.convoy_groups.length; i++) {
+        const group = complexity.convoy_groups[i]
+        const groupStep = genBaseStep + i * (opts.skipValidation ? 1 : 2)
+
+        console.log(
+          stepLabel(
+            groupStep,
+            totalGroupSteps,
+            `Generating convoy spec for group: ${group.name}…`
+          )
+        )
+
+        const chainContext = JSON.stringify({
+          mode: 'chain_subset',
+          group_name: group.name,
+          group_description: group.description,
+          group_phases: group.phases,
+          depends_on_groups: group.depends_on,
+          total_groups: complexity.convoy_groups.length,
+          group_index: i + 1,
+        })
+
+        const groupSpecPath = resolve(convoyDir, `${group.name}.convoy.yml`)
+
+        let groupResult
+        try {
+          groupResult = await runPromptStep({
+            ...sharedOpts,
+            template: 'generate-convoy',
+            filePath: prdPath,
+            contextText: chainContext,
+            outputPath: groupSpecPath,
+          })
+        } catch (err) {
+          console.error(
+            `\n  ✗ Step ${groupStep} failed: ${err instanceof Error ? err.message : String(err)}`
+          )
+          process.exit(1)
+        }
+
+        const resolvedGroupSpecPath = groupResult.outputPath ?? groupSpecPath
+        groupSpecPaths.push(resolvedGroupSpecPath)
+
+        console.log(c.green(`  ✓ Group spec written to ${relPath(resolvedGroupSpecPath)}\n`))
+
+        if (!opts.skipValidation) {
+          const valStep = groupStep + 1
+          console.log(stepLabel(valStep, totalGroupSteps, `Validating spec: ${group.name}…`))
+
+          const groupSpecContent = await readFile(resolvedGroupSpecPath, 'utf8')
+          let groupValidation
+          try {
+            groupValidation = await runPromptStep({
+              ...sharedOpts,
+              template: 'validate-convoy',
+              goalText: groupSpecContent,
+            })
+          } catch (err) {
+            console.error(
+              `\n  ✗ Validation failed for group ${group.name}: ${err instanceof Error ? err.message : String(err)}`
+            )
+            process.exit(1)
+          }
+
+          if (!groupValidation.isValid) {
+            console.log(c.yellow(`  ⚠ Spec has issues — attempting one auto-fix…\n`))
+            console.log(c.dim(groupValidation.errors ?? groupValidation.rawOutput))
+            console.log()
+
+            try {
+              await runPromptStep({
+                ...sharedOpts,
+                template: 'fix-convoy',
+                goalText: groupSpecContent,
+                contextText: groupValidation.errors ?? groupValidation.rawOutput,
+                outputPath: resolvedGroupSpecPath,
+              })
+            } catch (err) {
+              console.error(
+                `\n  ✗ Fix failed for group ${group.name}: ${err instanceof Error ? err.message : String(err)}`
+              )
+              process.exit(1)
+            }
+
+            console.log(c.dim(`  Applied fix for ${group.name}\n`))
+          } else {
+            console.log(c.green(`  ✓ Spec valid\n`))
+          }
+        }
+      }
+
+      // Build master pipeline spec (version 2)
+      const featureNameMatch = prdContentForComplexity.match(/^# (.+?)\s*(?:—|-)?\s*PRD/m)
+      const featureName = featureNameMatch
+        ? featureNameMatch[1].trim().toLowerCase().replace(/[^a-z0-9]+/g, '-')
+        : 'feature'
+
+      const branchMatch = prdContentForComplexity.match(/`feat\/([^`]+)`/)
+      const branch = branchMatch ? `feat/${branchMatch[1]}` : `feat/${featureName}`
+
+      const masterSpec = {
+        name: featureNameMatch ? featureNameMatch[1].trim() : 'Feature Pipeline',
+        version: 2,
+        branch,
+        on_failure: 'stop',
+        depends_on_convoy: groupSpecPaths.map(p => relPath(p)),
+      }
+
+      const masterSpecPath = resolve(convoyDir, `${featureName}-pipeline.convoy.yml`)
+      await writeFile(masterSpecPath, stringify(masterSpec), 'utf8')
+
+      console.log(c.green(`  ✓ Generated convoy chain:\n`))
+      for (const p of groupSpecPaths) {
+        console.log(`    ${relPath(p)}`)
+      }
+      console.log(`    ${relPath(masterSpecPath)} ${c.dim('(master)')}`)
+      console.log()
+      console.log(
+        `  ${c.dim('Preview:')} npx opencastle run -f ${relPath(masterSpecPath)} --dry-run\n` +
+          `  ${c.dim('Execute:')} npx opencastle run -f ${relPath(masterSpecPath)}\n`
       )
-      process.exit(1)
-    }
 
-    console.log(c.green(`  ✓ PRD is valid\n`))
+      try {
+        const shouldRun = await confirm('Run the convoy chain now?', true)
+        if (shouldRun) {
+          closePrompts()
+          const runModule = await import('./run.js')
+          const runArgs = ['-f', masterSpecPath]
+          if (opts.adapter) runArgs.push('-a', opts.adapter)
+          if (opts.verbose) runArgs.push('--verbose')
+          await runModule.default({ args: runArgs, pkgRoot })
+        }
+      } finally {
+        closePrompts()
+      }
+      return
+    } else {
+      console.log(
+        c.cyan(`  ℹ`) + ` Complexity: ${complexity.complexity} | Strategy: single\n`
+      )
+    }
   }
 
-  // ── Step 3: Generate convoy spec ──────────────────────────────────────────
-  const genStep = opts.skipValidation ? 2 : 3
+  // ── Step 4: Generate convoy spec ──────────────────────────────────────────
+  const genStep = opts.skipValidation ? 2 : 4
   console.log(stepLabel(genStep, totalSteps, 'Generating convoy spec…'))
 
   let specPath: string
@@ -233,8 +514,8 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     return
   }
 
-  // ── Step 4: Validate convoy spec ──────────────────────────────────────────
-  console.log(stepLabel(4, totalSteps, 'Validating convoy spec…'))
+  // ── Step 5: Validate convoy spec ──────────────────────────────────────────
+  console.log(stepLabel(5, totalSteps, 'Validating convoy spec…'))
 
   const specContent = await readFile(specPath, 'utf8')
   let validationErrors: string
@@ -248,7 +529,7 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
         goalText: specContent,
       })
     } catch (err) {
-      console.error(`\n  ✗ Step 4 failed: ${err instanceof Error ? err.message : String(err)}`)
+      console.error(`\n  ✗ Step 5 failed: ${err instanceof Error ? err.message : String(err)}`)
       process.exit(1)
     }
 
@@ -264,13 +545,13 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
     console.log()
   }
 
-  // ── Step 5: Fix convoy spec (up to 2 retries) ─────────────────────────────
+  // ── Step 6: Fix convoy spec (up to 2 retries) ─────────────────────────────
   const MAX_FIX_RETRIES = 2
   let fixedSpecContent = specContent
 
   for (let attempt = 1; attempt <= MAX_FIX_RETRIES; attempt++) {
     const label = `Fix attempt ${attempt}/${MAX_FIX_RETRIES}…`
-    console.log(stepLabel(5, totalSteps, label))
+    console.log(stepLabel(6, totalSteps, label))
 
     let fixResult
     try {
@@ -282,7 +563,7 @@ export default async function pipeline({ args, pkgRoot }: CliContext): Promise<v
         outputPath: specPath, // overwrite in place
       })
     } catch (err) {
-      console.error(`\n  ✗ Step 5 (attempt ${attempt}) failed: ${err instanceof Error ? err.message : String(err)}`)
+      console.error(`\n  ✗ Step 6 (attempt ${attempt}) failed: ${err instanceof Error ? err.message : String(err)}`)
       process.exit(1)
     }