opencastle 0.27.0 → 0.27.2

package/src/cli/convoy/health.test.ts

@@ -5,8 +5,9 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
 import { createConvoyStore } from './store.js'
 import type { ConvoyStore } from './store.js'
 import type { ConvoyEventEmitter } from './events.js'
-import { createHealthMonitor } from './health.js'
+import { createHealthMonitor, detectDrift } from './health.js'
 import type { HealthMonitorOptions } from './health.js'
+import type { AgentAdapter } from '../types.js'
 
 // ── fixtures ──────────────────────────────────────────────────────────────────
 
@@ -33,6 +34,7 @@ beforeEach(() => {
     emit(type, data, ids) {
       emittedEvents.push({ type, data, ids })
     },
+    close() {},
   }
   store.insertConvoy({
     id: CONVOY_ID,
@@ -71,8 +73,9 @@ function makeTask(
     max_retries: 1,
     files: null,
     depends_on: null,
+    gates: null as string | null,
     ...overrides,
-  }
+  } as Parameters<ConvoyStore['insertTask']>[0]
 }
 
 function makeWorker(
@@ -455,3 +458,62 @@ describe('event emission', () => {
     expect(ids?.worker_id).toBe('worker-1')
   })
 })
+
+// ── detectDrift ───────────────────────────────────────────────────────────────
+
+describe('detectDrift', () => {
+  function makeTaskRecord(adapterName: string | null = null) {
+    store.insertTask(makeTask({ id: 'drift-task', adapter: adapterName }))
+    return store.getTask('drift-task', CONVOY_ID)!
+  }
+
+  function makeAgentAdapter(name: string, output: string): AgentAdapter {
+    return {
+      name,
+      isAvailable: vi.fn().mockResolvedValue(true),
+      execute: vi.fn().mockResolvedValue({ success: true, output, exitCode: 0 }),
+    } as unknown as AgentAdapter
+  }
+
+  it('non-streaming adapter returns score 1.0, drifted=false, and emits a warning', async () => {
+    const taskRecord = makeTaskRecord(null)
+    const adapter = makeAgentAdapter('vscode', 'ok')
+    const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true)
+    try {
+      const result = await detectDrift(taskRecord, adapter)
+      expect(result.score).toBe(1.0)
+      expect(result.drifted).toBe(false)
+      expect(result.explanation).toContain('non-streaming adapter')
+      expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('drift detection skipped'))
+    } finally {
+      stderrSpy.mockRestore()
+    }
+  })
+
+  it('streaming adapter with high confidence score returns drifted=false', async () => {
+    const taskRecord = makeTaskRecord('copilot')
+    const adapter = makeAgentAdapter('copilot', '{"score": 0.95, "explanation": "very confident"}')
+    const result = await detectDrift(taskRecord, adapter)
+    expect(result.score).toBe(0.95)
+    expect(result.drifted).toBe(false)
+    expect(result.explanation).toBe('very confident')
+  })
+
+  it('streaming adapter with low confidence score returns drifted=true', async () => {
+    const taskRecord = makeTaskRecord('copilot')
+    const adapter = makeAgentAdapter('copilot', '{"score": 0.4, "explanation": "not confident"}')
+    const result = await detectDrift(taskRecord, adapter)
+    expect(result.score).toBe(0.4)
+    expect(result.drifted).toBe(true)
+    expect(result.threshold).toBe(0.8)
+  })
+
+  it('parse failure returns score 0.5 and drifted=true (below default threshold)', async () => {
+    const taskRecord = makeTaskRecord('copilot')
+    const adapter = makeAgentAdapter('copilot', 'I cannot rate myself')
+    const result = await detectDrift(taskRecord, adapter)
+    expect(result.score).toBe(0.5)
+    expect(result.drifted).toBe(true)
+    expect(result.explanation).toContain('Could not parse')
+  })
+})

package/src/cli/convoy/health.ts

@@ -1,5 +1,7 @@
 import type { ConvoyStore } from './store.js'
 import type { ConvoyEventEmitter } from './events.js'
+import type { TaskRecord } from './types.js'
+import type { AgentAdapter } from '../types.js'
 
 export interface HealthMonitorOptions {
   store: ConvoyStore
@@ -22,8 +24,7 @@ export interface HealthMonitor {
   check(): void
 }
 
-export function createHealthMonitor(options: HealthMonitorOptions): HealthMonitor {
-  const {
+export function createHealthMonitor(options: HealthMonitorOptions): HealthMonitor {  const {
     store,
     events,
     convoyId,
@@ -109,3 +110,80 @@ export function createHealthMonitor(options: HealthMonitorOptions): HealthMonito
     check,
   }
 }
+
+// ── Drift detection ───────────────────────────────────────────────────────────
+
+export interface DriftCheckResult {
+  score: number
+  explanation: string
+  drifted: boolean
+  threshold: number
+}
+
+export async function detectDrift(
+  taskRecord: TaskRecord,
+  adapter: AgentAdapter,
+  options?: { threshold?: number },
+): Promise<DriftCheckResult> {
+  // Streaming adapters: copilot (vscode adapter), cursor
+  const streamingAdapters = ['copilot', 'cursor']
+  const adapterName = taskRecord.adapter ?? adapter.name
+
+  if (!streamingAdapters.includes(adapterName)) {
+    process.stderr.write(
+      `Warning: drift detection skipped for non-streaming adapter "${adapterName}"\n`,
+    )
+    return {
+      score: 1.0,
+      explanation: 'Drift detection skipped: non-streaming adapter',
+      drifted: false,
+      threshold: options?.threshold ?? 0.8,
+    }
+  }
+
+  const threshold = options?.threshold ?? 0.8
+
+  const confidencePrompt = `Review the work you just completed for task "${taskRecord.id}". Rate your confidence that the implementation is correct and complete on a scale of 0.0 to 1.0. Respond with ONLY a JSON object: {"score": <number>, "explanation": "<brief explanation>"}`
+
+  const confidenceTask = {
+    id: `drift-check-${taskRecord.id}`,
+    prompt: confidencePrompt,
+    agent: taskRecord.agent,
+    timeout: '2m',
+    depends_on: [] as string[],
+    files: [] as string[],
+    description: 'Drift confidence check',
+    max_retries: 0,
+  }
+
+  try {
+    const result = await adapter.execute(confidenceTask, { verbose: false })
+
+    const jsonMatch = result.output.match(/\{[^}]*"score"\s*:\s*([\d.]+)[^}]*"explanation"\s*:\s*"([^"]*)"[^}]*\}/)
+    if (jsonMatch) {
+      const score = Math.max(0, Math.min(1, parseFloat(jsonMatch[1])))
+      const explanation = jsonMatch[2]
+      return { score, explanation, drifted: score < threshold, threshold }
+    }
+
+    const numberMatch = result.output.match(/(0\.\d+|1\.0|1)/)
+    if (numberMatch) {
+      const score = Math.max(0, Math.min(1, parseFloat(numberMatch[1])))
+      return { score, explanation: 'Parsed from raw output', drifted: score < threshold, threshold }
+    }
+
+    return {
+      score: 0.5,
+      explanation: 'Could not parse confidence score from adapter response',
+      drifted: 0.5 < threshold,
+      threshold,
+    }
+  } catch (err) {
+    return {
+      score: 0.5,
+      explanation: `Confidence check failed: ${(err as Error).message}`,
+      drifted: 0.5 < threshold,
+      threshold,
+    }
+  }
+}

package/src/cli/convoy/issues.test.ts

@@ -0,0 +1,143 @@
+import { mkdtempSync, rmSync, realpathSync, writeFileSync, mkdirSync, readFileSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { injectDiscoveredIssuesInstruction, checkDiscoveredIssues, consolidateIssues } from './issues.js'
+
+vi.mock('./gates.js', () => ({
+  scanForSecrets: vi.fn(() => ({ clean: true, findings: [] })),
+}))
+
+const DISCOVERED_REL = 'DISCOVERED-ISSUES.md'
+const KNOWN_REL = 'KNOWN-ISSUES.md'
+
+const DISCOVERED_HEADER = '# Discovered Issues\n\n'
+const KNOWN_HEADER = '# Known Issues\n\n'
+
+function makeBase(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'issues-test-')))
+  return dir
+}
+
+function makeEvents() {
+  const emitted: Array<{ type: string; data?: unknown }> = []
+  return {
+    emit: vi.fn((type: string, data?: unknown) => { emitted.push({ type, data }) }),
+    emitted,
+  }
+}
+
+let tmpDir: string
+
+beforeEach(() => {
+  tmpDir = makeBase()
+  vi.clearAllMocks()
+})
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+describe('injectDiscoveredIssuesInstruction', () => {
+  it('prepends the instruction to the prompt', () => {
+    const result = injectDiscoveredIssuesInstruction('Do the task.')
+    expect(result).toContain('Do the task.')
+    expect(result.indexOf('IMPORTANT')).toBeLessThan(result.indexOf('Do the task.'))
+  })
+
+  it('includes the ISSUE format in the instruction', () => {
+    const result = injectDiscoveredIssuesInstruction('proceed')
+    expect(result).toContain('### ISSUE:')
+  })
+})
+
+describe('checkDiscoveredIssues', () => {
+  it('returns 0 when file does not exist', () => {
+    const events = makeEvents()
+    const count = checkDiscoveredIssues('task-1', events as any, 'convoy-1', tmpDir)
+    expect(count).toBe(0)
+    expect(events.emit).not.toHaveBeenCalled()
+  })
+
+  it('returns 0 when file has no ISSUE entries', () => {
+    writeFileSync(join(tmpDir, DISCOVERED_REL), DISCOVERED_HEADER)
+    const events = makeEvents()
+    const count = checkDiscoveredIssues('task-1', events as any, 'convoy-1', tmpDir)
+    expect(count).toBe(0)
+  })
+
+  it('emits discovered_issue event for each entry', () => {
+    writeFileSync(
+      join(tmpDir, DISCOVERED_REL),
+      DISCOVERED_HEADER +
+      '### ISSUE: Null pointer crash\n- **File:** src/app.ts\n- **Description:** Crashes when null.\n- **Severity:** high\n\n---\n',
+    )
+    const events = makeEvents()
+    const count = checkDiscoveredIssues('task-1', events as any, 'convoy-1', tmpDir)
+    expect(count).toBe(1)
+    expect(events.emit).toHaveBeenCalledWith(
+      'discovered_issue',
+      expect.objectContaining({ title: 'Null pointer crash' }),
+      expect.objectContaining({ task_id: 'task-1', convoy_id: 'convoy-1' }),
+    )
+  })
+
+  it('parses multiple entries', () => {
+    writeFileSync(
+      join(tmpDir, DISCOVERED_REL),
+      DISCOVERED_HEADER +
+      '### ISSUE: Issue one\n- **File:** a.ts\n- **Description:** Desc one.\n\n---\n' +
+      '### ISSUE: Issue two\n- **File:** b.ts\n- **Description:** Desc two.\n\n---\n',
+    )
+    const events = makeEvents()
+    const count = checkDiscoveredIssues('task-x', events as any, 'convoy-y', tmpDir)
+    expect(count).toBe(2)
+    expect(events.emit).toHaveBeenCalledTimes(2)
+  })
+})
+
+describe('consolidateIssues', () => {
+  it('returns zero counts when discovered file does not exist', () => {
+    const result = consolidateIssues(tmpDir)
+    expect(result).toEqual({ moved: 0, skipped: 0 })
+  })
+
+  it('moves entries from discovered to known', () => {
+    writeFileSync(
+      join(tmpDir, DISCOVERED_REL),
+      DISCOVERED_HEADER +
+      '### ISSUE: New bug\n- **File:** src/x.ts\n- **Description:** A bug.\n\n---\n',
+    )
+    const result = consolidateIssues(tmpDir)
+    expect(result.moved).toBe(1)
+    const known = readFileSync(join(tmpDir, KNOWN_REL), 'utf8')
+    expect(known).toContain('New bug')
+  })
+
+  it('deduplicates by title and file', () => {
+    const existingEntry = '### ISSUE: Known bug\n- **File:** src/x.ts\n- **Description:** Already known.\n\n---\n'
+    writeFileSync(join(tmpDir, KNOWN_REL), KNOWN_HEADER + existingEntry)
+    writeFileSync(
+      join(tmpDir, DISCOVERED_REL),
+      DISCOVERED_HEADER +
+      '### ISSUE: Known bug\n- **File:** src/x.ts\n- **Description:** Duplicate.\n\n---\n',
+    )
+    const result = consolidateIssues(tmpDir)
+    expect(result.skipped).toBe(1)
+    expect(result.moved).toBe(0)
+    const known = readFileSync(join(tmpDir, KNOWN_REL), 'utf8')
+    const occurrences = (known.match(/### ISSUE: Known bug/g) || []).length
+    expect(occurrences).toBe(1)
+  })
+
+  it('clears discovered file after consolidation', () => {
+    writeFileSync(
+      join(tmpDir, DISCOVERED_REL),
+      DISCOVERED_HEADER +
+      '### ISSUE: Temp issue\n- **File:** src/y.ts\n- **Description:** Temp.\n\n---\n',
+    )
+    consolidateIssues(tmpDir)
+    const discovered = readFileSync(join(tmpDir, DISCOVERED_REL), 'utf8')
+    expect(discovered).not.toContain('### ISSUE:')
+  })
+})

package/src/cli/convoy/issues.ts

@@ -0,0 +1,136 @@
+import { existsSync, readFileSync, appendFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { scanForSecrets } from './gates.js'
+import type { ConvoyEventEmitter } from './events.js'
+
+const DISCOVERED_PATH = 'DISCOVERED-ISSUES.md'
+const KNOWN_PATH = 'KNOWN-ISSUES.md'
+
+const INJECT_INSTRUCTION =
+  'IMPORTANT: After completing your task, if you notice any pre-existing bugs or issues ' +
+  'unrelated to your task, append them to DISCOVERED-ISSUES.md in the format:\n\n' +
+  '### ISSUE: [title]\n' +
+  '- **File:** [filepath]\n' +
+  '- **Description:** [description]\n' +
+  '- **Severity:** low|medium|high\n\n' +
+  '---\n\n' +
+  'Now proceed with your original task:\n\n'
+
+export function injectDiscoveredIssuesInstruction(prompt: string): string {
+  return INJECT_INSTRUCTION + prompt
+}
+
+interface DiscoveredIssue {
+  title: string
+  file: string
+  description: string
+  severity: string
+}
+
+function parseIssueEntries(content: string): DiscoveredIssue[] {
+  const issues: DiscoveredIssue[] = []
+  const parts = content.split(/(?=### ISSUE:)/)
+  for (const part of parts) {
+    if (!part.trim().startsWith('### ISSUE:')) continue
+    const titleMatch = part.match(/### ISSUE:\s*(.+)/)
+    const fileMatch = part.match(/\*\*File:\*\*\s*(.+)/)
+    const descMatch = part.match(/\*\*Description:\*\*\s*(.+)/)
+    const sevMatch = part.match(/\*\*Severity:\*\*\s*(.+)/)
+    if (titleMatch) {
+      issues.push({
+        title: titleMatch[1].trim(),
+        file: fileMatch ? fileMatch[1].trim() : '',
+        description: descMatch ? descMatch[1].trim() : '',
+        severity: sevMatch ? sevMatch[1].trim() : 'low',
+      })
+    }
+  }
+  return issues
+}
+
+export function checkDiscoveredIssues(
+  taskId: string,
+  events: ConvoyEventEmitter,
+  convoyId: string,
+  basePath?: string,
+): number {
+  const base = basePath ?? process.cwd()
+  const filePath = join(base, DISCOVERED_PATH)
+  if (!existsSync(filePath)) return 0
+
+  const content = readFileSync(filePath, 'utf8')
+  const issues = parseIssueEntries(content)
+
+  for (const issue of issues) {
+    events.emit(
+      'discovered_issue',
+      {
+        task_id: taskId,
+        title: issue.title,
+        file: issue.file,
+        description: issue.description,
+        severity: issue.severity,
+      },
+      { convoy_id: convoyId, task_id: taskId },
+    )
+  }
+
+  return issues.length
+}
+
+export function consolidateIssues(basePath?: string): { moved: number; skipped: number } {
+  const base = basePath ?? process.cwd()
+  const discoveredPath = join(base, DISCOVERED_PATH)
+  const knownPath = join(base, KNOWN_PATH)
+
+  if (!existsSync(discoveredPath)) return { moved: 0, skipped: 0 }
+
+  const discoveredContent = readFileSync(discoveredPath, 'utf8')
+  const discovered = parseIssueEntries(discoveredContent)
+  if (discovered.length === 0) return { moved: 0, skipped: 0 }
+
+  const knownContent = existsSync(knownPath) ? readFileSync(knownPath, 'utf8') : ''
+  let moved = 0
+  let skipped = 0
+  const newEntries: string[] = []
+
+  for (const issue of discovered) {
+    const knownLower = knownContent.toLowerCase()
+    const alreadyKnown =
+      knownLower.includes(issue.title.toLowerCase()) &&
+      issue.file !== '' &&
+      knownLower.includes(issue.file.toLowerCase())
+
+    if (alreadyKnown) {
+      skipped++
+      continue
+    }
+
+    const entry =
+      '\n### ' + issue.title + '\n' +
+      '- **File:** ' + issue.file + '\n' +
+      '- **Description:** ' + issue.description + '\n' +
+      '- **Severity:** ' + issue.severity + '\n\n---\n'
+
+    const scan = scanForSecrets(entry, 'known-issues')
+    if (!scan.clean) continue
+
+    newEntries.push(entry)
+    moved++
+  }
+
+  if (newEntries.length > 0) {
+    if (!existsSync(knownPath)) {
+      writeFileSync(knownPath, '# Known Issues\n\nTracked pre-existing bugs and issues.\n', 'utf8')
+    }
+    appendFileSync(knownPath, newEntries.join(''), 'utf8')
+  }
+
+  writeFileSync(
+    discoveredPath,
+    '# Discovered Issues\n\nIssues discovered by agents during task execution.\n',
+    'utf8',
+  )
+
+  return { moved, skipped }
+}

package/src/cli/convoy/knowledge.test.ts

@@ -0,0 +1,101 @@
+import { mkdtempSync, rmSync, realpathSync, writeFileSync, mkdirSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { buildKnowledgeGraph } from './knowledge.js'
+
+vi.mock('./gates.js', () => ({
+  scanForSecrets: vi.fn(() => ({ clean: true, findings: [] })),
+}))
+
+const KG_REL = '.opencastle/KNOWLEDGE-GRAPH.md'
+
+function makeBase(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'knowledge-test-')))
+  mkdirSync(join(dir, '.opencastle'), { recursive: true })
+  return dir
+}
+
+let tmpDir: string
+
+beforeEach(() => {
+  tmpDir = makeBase()
+  vi.clearAllMocks()
+})
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+const SIMPLE_DIFF = `diff --git a/src/app.ts b/src/app.ts
+index abc..def 100644
+--- a/src/app.ts
++++ b/src/app.ts
+@@ -1,2 +1,3 @@
++import { helper } from './utils.js'
+ const x = 1
+`
+
+const TEST_FILE_DIFF = `diff --git a/src/app.test.ts b/src/app.test.ts
+index abc..def 100644
+--- a/src/app.test.ts
++++ b/src/app.test.ts
+@@ -1,2 +1,3 @@
++import { helper } from './utils.js'
+ const x = 1
+`
+
+const NON_TS_DIFF = `diff --git a/README.md b/README.md
+index abc..def 100644
+--- a/README.md
++++ b/README.md
+@@ -1,2 +1,3 @@
++Some content about importing things
+ existing line
+`
+
+describe('buildKnowledgeGraph', () => {
+  it('creates file with table header when file does not exist', () => {
+    buildKnowledgeGraph(SIMPLE_DIFF, 'convoy-1', tmpDir)
+    const content = readFileSync(join(tmpDir, KG_REL), 'utf8')
+    expect(content).toContain('| source |')
+    expect(content).toContain('| target |')
+  })
+
+  it('extracts import relationships from diff', () => {
+    buildKnowledgeGraph(SIMPLE_DIFF, 'convoy-1', tmpDir)
+    const content = readFileSync(join(tmpDir, KG_REL), 'utf8')
+    expect(content).toContain('src/app.ts')
+    expect(content).toContain('utils.js')
+  })
+
+  it('skips test files', () => {
+    buildKnowledgeGraph(TEST_FILE_DIFF, 'convoy-1', tmpDir)
+    // File should not be created or should be empty (only header)
+    if (require('node:fs').existsSync(join(tmpDir, KG_REL))) {
+      const content = readFileSync(join(tmpDir, KG_REL), 'utf8')
+      // Should only have header, no data rows from test files
+      const lines = content.split('\n').filter((l: string) => l.startsWith('| src/app.test.ts'))
+      expect(lines).toHaveLength(0)
+    }
+  })
+
+  it('skips non-ts/js files', () => {
+    buildKnowledgeGraph(NON_TS_DIFF, 'convoy-1', tmpDir)
+    expect(require('node:fs').existsSync(join(tmpDir, KG_REL))).toBe(false)
+  })
+
+  it('deduplicates existing rows', () => {
+    buildKnowledgeGraph(SIMPLE_DIFF, 'convoy-1', tmpDir)
+    buildKnowledgeGraph(SIMPLE_DIFF, 'convoy-2', tmpDir)
+    const content = readFileSync(join(tmpDir, KG_REL), 'utf8')
+    const rows = content.split('\n').filter((l: string) => l.includes('src/app.ts') && l.includes('utils.js'))
+    expect(rows).toHaveLength(1)
+  })
+
+  it('includes convoy_id in the row', () => {
+    buildKnowledgeGraph(SIMPLE_DIFF, 'convoy-abc123', tmpDir)
+    const content = readFileSync(join(tmpDir, KG_REL), 'utf8')
+    expect(content).toContain('convoy-abc123')
+  })
+})