opencastle 0.28.0 → 0.30.0

package/src/cli/log.ts

@@ -1,29 +1,18 @@
 import { mkdir, appendFile, stat } from 'node:fs/promises'
-import { readdirSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
 import { join, dirname } from 'node:path'
 import type { CliContext } from './types.js'
 
 const HELP = `
   opencastle log [options]
-  opencastle log merge [--since <ISO-date>] [--until <ISO-date>] [--output <path>]
 
-  Append a structured event to the observability log (events.ndjson),
-  or merge per-convoy NDJSON files into a single file.
+  Append a structured event to the observability log (events.ndjson).
 
-  Subcommands:
-    merge         Merge all .opencastle/logs/convoys/*.ndjson into convoy-events.ndjson
-
-  Options (log append):
+  Options:
     --type <type>          Event type (required): session|delegation|review|panel|dispute
     --<field> <value>      Any field from the event schema (see documentation)
     --logs-dir <path>      Override the logs directory path
     --help, -h             Show this help
 
-  Options (merge):
-    --since <ISO-date>     Only include records at or after this date
-    --until <ISO-date>     Only include records at or before this date
-    --output <path>        Output path (default: .opencastle/logs/convoy-events.ndjson)
-
   Array fields (comma-separated): file_partition, lessons_added, discoveries, reviewing_agents
   Boolean fields: escalated, weighted
   Numeric fields: auto-detected from value
@@ -32,8 +21,6 @@ const HELP = `
     opencastle log --type session --agent Developer --model claude-sonnet-4-6 --task "Fix bug" --outcome success
     opencastle log --type delegation --session_id feat/prj-1 --agent Developer --tier fast --mechanism sub-agent --outcome success
     opencastle log --type panel --panel_key auth-review --verdict pass --pass_count 3 --block_count 0
-    opencastle log merge --since 2026-01-01 --output /tmp/merged.ndjson
-    opencastle log merge
 `
 
 const VALID_TYPES = ['session', 'delegation', 'review', 'panel', 'dispute']
@@ -72,94 +59,6 @@ export async function resolveLogsDir(override?: string | null): Promise<string>
   return join(process.cwd(), '.opencastle', 'logs')
 }
 
-/** Merge per-convoy NDJSON files into a single deduplicated, sorted file. */
-export async function mergeConvoyLogs(options: {
-  since?: string
-  until?: string
-  output?: string
-  basePath?: string
-}): Promise<{ merged: number; deduplicated: number; written: number }> {
-  const base = options.basePath ?? process.cwd()
-  const convoysDir = join(base, '.opencastle', 'logs', 'convoys')
-
-  let files: string[] = []
-  try {
-    files = readdirSync(convoysDir)
-      .filter(f => f.endsWith('.ndjson'))
-      .map(f => join(convoysDir, f))
-  } catch {
-    return { merged: 0, deduplicated: 0, written: 0 }
-  }
-
-  if (files.length === 0) {
-    return { merged: 0, deduplicated: 0, written: 0 }
-  }
-
-  const allRecords: Array<Record<string, unknown>> = []
-  let totalRead = 0
-
-  for (const file of files) {
-    const content = readFileSync(file, 'utf8')
-    const lines = content.split('\n').filter(l => l.trim())
-    for (const line of lines) {
-      try {
-        allRecords.push(JSON.parse(line) as Record<string, unknown>)
-        totalRead++
-      } catch {
-        // skip malformed lines
-      }
-    }
-  }
-
-  // Deduplicate by _event_id — keep first occurrence
-  const seen = new Set<unknown>()
-  const unique: Array<Record<string, unknown>> = []
-  for (const record of allRecords) {
-    const id = record['_event_id']
-    if (id !== undefined) {
-      if (seen.has(id)) continue
-      seen.add(id)
-    }
-    unique.push(record)
-  }
-
-  const deduplicatedCount = totalRead - unique.length
-
-  // Filter by since/until
-  let filtered = unique
-  if (options.since) {
-    const since = options.since
-    filtered = filtered.filter(r => {
-      const ts = r['timestamp'] as string | undefined
-      return ts !== undefined && ts >= since
-    })
-  }
-  if (options.until) {
-    const until = options.until
-    filtered = filtered.filter(r => {
-      const ts = r['timestamp'] as string | undefined
-      return ts !== undefined && ts <= until
-    })
-  }
-
-  // Sort by timestamp ascending
-  filtered.sort((a, b) => {
-    const ta = (a['timestamp'] as string) ?? ''
-    const tb = (b['timestamp'] as string) ?? ''
-    return ta < tb ? -1 : ta > tb ? 1 : 0
-  })
-
-  if (filtered.length === 0) {
-    return { merged: totalRead, deduplicated: deduplicatedCount, written: 0 }
-  }
-
-  const outputPath = options.output ?? join(base, '.opencastle', 'logs', 'convoy-events.ndjson')
-  mkdirSync(dirname(outputPath), { recursive: true })
-  writeFileSync(outputPath, filtered.map(r => JSON.stringify(r)).join('\n') + '\n', 'utf8')
-
-  return { merged: totalRead, deduplicated: deduplicatedCount, written: filtered.length }
-}
-
 /** Append a structured event record to events.ndjson. */
 export async function appendEvent(
   record: Record<string, unknown>,
@@ -178,23 +77,6 @@ export default async function log({ args }: CliContext): Promise<void> {
     return
   }
 
-  // merge subcommand
-  if (args[0] === 'merge') {
-    const mergeArgs = args.slice(1)
-    let since: string | undefined
-    let until: string | undefined
-    let output: string | undefined
-    for (let i = 0; i < mergeArgs.length; i++) {
-      const a = mergeArgs[i]
-      if (a === '--since' && i + 1 < mergeArgs.length) { since = mergeArgs[++i]; continue }
-      if (a === '--until' && i + 1 < mergeArgs.length) { until = mergeArgs[++i]; continue }
-      if (a === '--output' && i + 1 < mergeArgs.length) { output = mergeArgs[++i]; continue }
-    }
-    const result = await mergeConvoyLogs({ since, until, output })
-    console.log(`  Merged: ${result.merged} records, Deduplicated: ${result.deduplicated}, Written: ${result.written}`)
-    return
-  }
-
   let type: string | null = null
   let logsDir: string | null = null
   const fields: Record<string, unknown> = {}

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()
+  })
+})