opencastle 0.31.3 → 0.31.4

package/src/cli/convoy/spec-builder.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, vi } from 'vitest'
 import { parse as yamlParse } from 'yaml'
 import { parseYaml, validateSpec } from '../run/schema.js'
 import {
@@ -271,12 +271,14 @@ describe('applyPatches', () => {
     expect(patched.branch).toBe('feat/patched-branch')
   })
 
-  it('skips silently when task id does not exist', () => {
+  it('leaves task unchanged when task id does not exist', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     const plan = minimalPlan()
     const patched = applyPatches(plan, [
       { task_id: 'nonexistent', field: 'prompt', value: 'x' },
     ])
     expect(patched.tasks[0].prompt).toBe('Do something useful')
+    warnSpy.mockRestore()
   })
 
   it('returns a new object (original plan unchanged)', () => {
@@ -306,6 +308,54 @@ describe('applyPatches', () => {
     expect(patched.tasks[1].agent).toBe('ui-expert')
     expect(patched.on_failure).toBe('continue')
   })
+
+  it('warns when patch targets unknown task_id', () => {
+    const plan: TaskPlan = {
+      name: 'test',
+      tasks: [{ id: 'task-1', prompt: 'do something' }],
+    }
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const result = applyPatches(plan, [
+      { task_id: 'nonexistent', field: 'prompt', value: 'new prompt' },
+    ])
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('nonexistent')
+    )
+    // Original task unchanged
+    expect(result.tasks[0].prompt).toBe('do something')
+    warnSpy.mockRestore()
+  })
+
+  it('applies valid patches and warns for invalid ones', () => {
+    const plan: TaskPlan = {
+      name: 'test',
+      tasks: [
+        { id: 'task-1', prompt: 'original' },
+        { id: 'task-2', prompt: 'original2' },
+      ],
+    }
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const result = applyPatches(plan, [
+      { task_id: 'task-1', field: 'prompt', value: 'updated' },
+      { task_id: 'ghost', field: 'prompt', value: 'nope' },
+    ])
+    expect(result.tasks[0].prompt).toBe('updated')
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('ghost'))
+    warnSpy.mockRestore()
+  })
+
+  it('does not warn when all patches target valid tasks', () => {
+    const plan: TaskPlan = {
+      name: 'test',
+      tasks: [{ id: 'task-1', prompt: 'original' }],
+    }
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    applyPatches(plan, [
+      { task_id: 'task-1', field: 'prompt', value: 'updated' },
+    ])
+    expect(warnSpy).not.toHaveBeenCalled()
+    warnSpy.mockRestore()
+  })
 })
 
 // ── parseTaskPlan ──────────────────────────────────────────────────────────────
@@ -392,6 +442,62 @@ describe('parseTaskPlan', () => {
     const withTrailing = json + '\n```\nSome extra text'
     expect(parseTaskPlan(withTrailing)).toBeNull()
   })
+
+  it('returns null for duplicate task IDs', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const plan = JSON.stringify({
+      name: 'test',
+      tasks: [
+        { id: 'setup', prompt: 'Do setup' },
+        { id: 'setup', prompt: 'Do setup again' },
+      ],
+    })
+    expect(parseTaskPlan(plan)).toBeNull()
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('setup'))
+    warnSpy.mockRestore()
+  })
+
+  it('returns null for invalid depends_on reference', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const plan = JSON.stringify({
+      name: 'test',
+      tasks: [
+        { id: 'a', prompt: 'Do A' },
+        { id: 'b', prompt: 'Do B', depends_on: ['nonexistent'] },
+      ],
+    })
+    expect(parseTaskPlan(plan)).toBeNull()
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('nonexistent'))
+    warnSpy.mockRestore()
+  })
+
+  it('returns null for dependency cycle', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const plan = JSON.stringify({
+      name: 'test',
+      tasks: [
+        { id: 'a', prompt: 'Do A', depends_on: ['b'] },
+        { id: 'b', prompt: 'Do B', depends_on: ['a'] },
+      ],
+    })
+    expect(parseTaskPlan(plan)).toBeNull()
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('cycle'))
+    warnSpy.mockRestore()
+  })
+
+  it('accepts valid plan with correct dependencies', () => {
+    const plan = JSON.stringify({
+      name: 'test',
+      tasks: [
+        { id: 'a', prompt: 'Do A' },
+        { id: 'b', prompt: 'Do B', depends_on: ['a'] },
+        { id: 'c', prompt: 'Do C', depends_on: ['a', 'b'] },
+      ],
+    })
+    const result = parseTaskPlan(plan)
+    expect(result).not.toBeNull()
+    expect(result!.tasks).toHaveLength(3)
+  })
 })
 
 // ── parsePatches ──────────────────────────────────────────────────────────────

package/src/cli/convoy/spec-builder.ts

@@ -169,6 +169,7 @@ export function buildConvoyYaml(plan: TaskPlan, enrichment?: SpecEnrichment): st
  */
 export function applyPatches(plan: TaskPlan, patches: TaskPatch[]): TaskPlan {
   const clone = structuredClone(plan)
+  let skipped = 0
   for (const patch of patches) {
     if (patch.task_id === '_plan') {
       ;(clone as unknown as Record<string, unknown>)[patch.field] = patch.value
@@ -176,10 +177,15 @@ export function applyPatches(plan: TaskPlan, patches: TaskPatch[]): TaskPlan {
       const task = clone.tasks.find((t) => t.id === patch.task_id)
       if (task) {
         ;(task as unknown as Record<string, unknown>)[patch.field] = patch.value
+      } else {
+        console.warn(`  ⚠ applyPatches: patch targets unknown task "${patch.task_id}" — skipping`)
+        skipped++
       }
-      // task not found: skip silently
     }
   }
+  if (skipped > 0) {
+    console.warn(`  ⚠ applyPatches: ${skipped} of ${patches.length} patches skipped (unknown task IDs)`)
+  }
   return clone
 }
 
@@ -194,7 +200,66 @@ export function parseTaskPlan(jsonText: string): TaskPlan | null {
     for (const task of parsed.tasks as unknown[]) {
       const t = task as Record<string, unknown>
       if (typeof t.id !== 'string' || typeof t.prompt !== 'string') return null
+      if ((t.prompt as string).length === 0) return null
+    }
+
+    // Validate unique task IDs
+    const tasks = parsed.tasks as Array<Record<string, unknown>>
+    const ids = new Set<string>()
+    const duplicates: string[] = []
+    for (const task of tasks) {
+      const id = task.id as string
+      if (ids.has(id)) duplicates.push(id)
+      ids.add(id)
+    }
+    if (duplicates.length > 0) {
+      console.warn(`  ⚠ parseTaskPlan: duplicate task IDs: ${duplicates.join(', ')}`)
+      return null
     }
+
+    // Validate depends_on references
+    for (const task of tasks) {
+      if (Array.isArray(task.depends_on)) {
+        for (const dep of task.depends_on as string[]) {
+          if (!ids.has(dep)) {
+            console.warn(`  ⚠ parseTaskPlan: task "${task.id as string}" depends on unknown task "${dep}"`)
+            return null
+          }
+        }
+      }
+    }
+
+    // Cycle detection (Kahn's algorithm)
+    const inDegree = new Map<string, number>()
+    const adj = new Map<string, string[]>()
+    for (const id of ids) {
+      inDegree.set(id, 0)
+      adj.set(id, [])
+    }
+    for (const task of tasks) {
+      if (Array.isArray(task.depends_on)) {
+        for (const dep of task.depends_on as string[]) {
+          adj.get(dep)!.push(task.id as string)
+          inDegree.set(task.id as string, (inDegree.get(task.id as string) ?? 0) + 1)
+        }
+      }
+    }
+    const queue = [...ids].filter(id => inDegree.get(id) === 0)
+    let visited = 0
+    while (queue.length > 0) {
+      const node = queue.shift()!
+      visited++
+      for (const next of adj.get(node) ?? []) {
+        const deg = (inDegree.get(next) ?? 1) - 1
+        inDegree.set(next, deg)
+        if (deg === 0) queue.push(next)
+      }
+    }
+    if (visited < ids.size) {
+      console.warn(`  ⚠ parseTaskPlan: dependency cycle detected`)
+      return null
+    }
+
     return parsed as unknown as TaskPlan
   } catch {
     return null

package/src/cli/pipeline.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { parseComplexityAssessment, deriveComplexityPath } from './pipeline.js'
+import { parseComplexityAssessment, deriveComplexityPath, validateComplexityGroups, topologicalSortGroups } from './pipeline.js'
 
 const SINGLE_JSON = JSON.stringify({
   original_prompt: 'Build a REST API with user auth',
@@ -151,3 +151,132 @@ describe('deriveComplexityPath', () => {
     )
   })
 })
+
+describe('validateComplexityGroups', () => {
+  it('accepts valid groups', () => {
+    const assessment = {
+      original_prompt: 'test',
+      total_tasks: 6,
+      total_phases: 3,
+      domains: ['frontend', 'api'],
+      complexity: 'medium' as const,
+      recommended_strategy: 'chain' as const,
+      convoy_groups: [
+        { name: 'backend', description: 'API', phases: [1, 2], depends_on: [] },
+        { name: 'frontend', description: 'UI', phases: [3], depends_on: ['backend'] },
+      ],
+    }
+    expect(validateComplexityGroups(assessment)).toEqual({ valid: true, reason: '' })
+  })
+
+  it('rejects groups exceeding max count for small projects', () => {
+    const assessment = {
+      original_prompt: 'test',
+      total_tasks: 10,
+      total_phases: 4,
+      domains: ['a'],
+      complexity: 'medium' as const,
+      recommended_strategy: 'chain' as const,
+      convoy_groups: [
+        { name: 'a', description: 'A', phases: [1], depends_on: [] },
+        { name: 'b', description: 'B', phases: [2], depends_on: [] },
+        { name: 'c-group', description: 'C', phases: [3], depends_on: [] },
+        { name: 'd-group', description: 'D', phases: [4], depends_on: [] },
+      ],
+    }
+    const result = validateComplexityGroups(assessment)
+    expect(result.valid).toBe(false)
+    expect(result.reason).toContain('maximum')
+  })
+
+  it('rejects overlapping phases', () => {
+    const assessment = {
+      original_prompt: 'test',
+      total_tasks: 8,
+      total_phases: 3,
+      domains: ['a'],
+      complexity: 'medium' as const,
+      recommended_strategy: 'chain' as const,
+      convoy_groups: [
+        { name: 'group-a', description: 'A', phases: [1, 2], depends_on: [] },
+        { name: 'group-b', description: 'B', phases: [2, 3], depends_on: [] },
+      ],
+    }
+    const result = validateComplexityGroups(assessment)
+    expect(result.valid).toBe(false)
+    expect(result.reason).toContain('overlap')
+  })
+
+  it('rejects invalid depends_on references', () => {
+    const assessment = {
+      original_prompt: 'test',
+      total_tasks: 8,
+      total_phases: 2,
+      domains: ['a'],
+      complexity: 'medium' as const,
+      recommended_strategy: 'chain' as const,
+      convoy_groups: [
+        { name: 'group-a', description: 'A', phases: [1], depends_on: ['nonexistent'] },
+      ],
+    }
+    const result = validateComplexityGroups(assessment)
+    expect(result.valid).toBe(false)
+    expect(result.reason).toContain('nonexistent')
+  })
+
+  it('rejects dependency cycles', () => {
+    const assessment = {
+      original_prompt: 'test',
+      total_tasks: 8,
+      total_phases: 2,
+      domains: ['a'],
+      complexity: 'medium' as const,
+      recommended_strategy: 'chain' as const,
+      convoy_groups: [
+        { name: 'group-a', description: 'A', phases: [1], depends_on: ['group-b'] },
+        { name: 'group-b', description: 'B', phases: [2], depends_on: ['group-a'] },
+      ],
+    }
+    const result = validateComplexityGroups(assessment)
+    expect(result.valid).toBe(false)
+    expect(result.reason).toContain('cycle')
+  })
+
+  it('rejects non-kebab-case group names', () => {
+    const assessment = {
+      original_prompt: 'test',
+      total_tasks: 8,
+      total_phases: 2,
+      domains: ['a'],
+      complexity: 'medium' as const,
+      recommended_strategy: 'chain' as const,
+      convoy_groups: [
+        { name: 'My Group', description: 'Bad name', phases: [1], depends_on: [] },
+      ],
+    }
+    const result = validateComplexityGroups(assessment)
+    expect(result.valid).toBe(false)
+    expect(result.reason).toContain('kebab')
+  })
+})
+
+describe('topologicalSortGroups', () => {
+  it('sorts groups in dependency order', () => {
+    const groups = [
+      { name: 'c', description: 'C', phases: [3], depends_on: ['b'] },
+      { name: 'a', description: 'A', phases: [1], depends_on: [] },
+      { name: 'b', description: 'B', phases: [2], depends_on: ['a'] },
+    ]
+    const sorted = topologicalSortGroups(groups)
+    expect(sorted.map(g => g.name)).toEqual(['a', 'b', 'c'])
+  })
+
+  it('preserves order for independent groups', () => {
+    const groups = [
+      { name: 'x', description: 'X', phases: [1], depends_on: [] },
+      { name: 'y', description: 'Y', phases: [2], depends_on: [] },
+    ]
+    const sorted = topologicalSortGroups(groups)
+    expect(sorted.map(g => g.name)).toEqual(['x', 'y'])
+  })
+})