opencastle 0.26.1 → 0.27.1

package/src/cli/convoy/types.ts

@@ -1,4 +1,4 @@
-export type ConvoyStatus = 'pending' | 'running' | 'done' | 'failed' | 'gate-failed'
+export type ConvoyStatus = 'pending' | 'running' | 'done' | 'failed' | 'gate-failed' | 'hook-failed'
 
 export type ConvoyTaskStatus =
   | 'pending'
@@ -6,8 +6,13 @@ export type ConvoyTaskStatus =
   | 'running'
   | 'done'
   | 'failed'
+  | 'gate-failed'
+  | 'review-blocked'
   | 'timed-out'
   | 'skipped'
+  | 'hook-failed'
+  | 'disputed'
+  | 'wait-for-input'
 
 export type WorkerStatus = 'spawned' | 'running' | 'done' | 'failed' | 'killed'
 
@@ -26,6 +31,9 @@ export interface ConvoyRecord {
   total_tokens: number | null
   total_cost_usd: string | null
   pipeline_id: string | null
+  circuit_state: string | null
+  review_tokens_total: number | null
+  review_budget: number | null
 }
 
 export interface TaskRecord {
@@ -52,6 +60,24 @@ export interface TaskRecord {
   completion_tokens: number | null
   total_tokens: number | null
   cost_usd: string | null
+  gates: string | null
+  on_exhausted: 'dlq' | 'skip' | 'stop'
+  injected: number
+  provenance: string | null
+  idempotency_key: string | null
+  current_step: number | null
+  total_steps: number | null
+  review_level: string | null
+  review_verdict: string | null
+  review_tokens: number | null
+  review_model: string | null
+  panel_attempts: number
+  dispute_id: string | null
+  drift_score: number | null
+  drift_retried: number
+  outputs?: string | null          // JSON array of TaskOutput
+  inputs?: string | null           // JSON array of TaskInput
+  discovered_issues?: string | null // JSON array
 }
 
 export interface WorkerRecord {
@@ -90,3 +116,146 @@ export interface PipelineRecord {
   total_tokens: number | null
   total_cost_usd: string | null
 }
+
+export interface BuiltInGatesConfig {
+  secret_scan?: boolean
+  blast_radius?: boolean
+  dependency_audit?: 'auto' | boolean
+  regression_test?: 'auto' | boolean
+  browser_test?: 'auto' | boolean
+  gate_timeout?: number
+}
+
+
+export interface BrowserTestConfig {
+  urls: string[]
+  check_console_errors?: boolean
+  visual_diff_threshold?: number
+  a11y?: boolean
+  severity_threshold?: 'critical' | 'serious' | 'moderate' | 'minor'
+  baselines_dir?: string
+}
+export interface GuardConfig {
+  enabled?: boolean      // default: true
+  agent?: string         // optional agent name (e.g. 'session-guard')
+  checks?: string[]      // e.g. ['observability', 'cleanup', 'cost-report']
+}
+
+export interface DlqRecord {
+  id: string
+  convoy_id: string
+  task_id: string
+  agent: string
+  failure_type: string
+  error_output: string | null
+  attempts: number
+  tokens_spent: number | null
+  escalation_task_id: string | null
+  resolved: number
+  resolution: string | null
+  created_at: string
+  resolved_at: string | null
+}
+
+export interface CircuitBreakerConfig {
+  threshold?: number      // failures before Open (default: 3)
+  cooldown_ms?: number    // ms in Open before Half-Open (default: 300000 = 5min)
+  fallback_agent?: string // reassign pending tasks when circuit opens
+}
+
+export interface TaskOutput {
+  name: string
+  type: 'file' | 'summary' | 'json'
+  description?: string
+}
+
+export interface TaskInput {
+  from: string
+  name: string
+  as?: string
+}
+
+export interface ArtifactRecord {
+  id: string
+  convoy_id: string
+  task_id: string
+  name: string
+  type: 'file' | 'summary' | 'json'
+  content: string
+  created_at: string
+}
+
+export interface AgentIdentityRecord {
+  id: string
+  agent: string
+  convoy_id: string
+  task_id: string
+  summary: string
+  created_at: string
+  retention_days: number
+}
+
+export interface StepCondition {
+  step: string         // reference previous step by id
+  exitCode?: { eq?: number; ne?: number; gt?: number; lt?: number }
+  fileExists?: { path: string }
+}
+
+export interface TaskStep {
+  id?: string
+  prompt: string
+  gates?: string[]
+  max_retries?: number // inherits from task if omitted
+  if?: StepCondition
+}
+
+export interface Hook {
+  type: 'review' | 'guard' | 'agent' | 'command' | 'validate'
+  name?: string
+  prompt?: string  // for agent hooks
+  command?: string // for command hooks
+  on?: 'pre_task' | 'post_task' | 'post_convoy'
+}
+
+export interface TaskStepRecord {
+  id: number
+  task_id: string
+  step_index: number
+  prompt: string
+  gates: string | null
+  status: string
+  exit_code: number | null
+  output: string | null
+  started_at: string | null
+  finished_at: string | null
+}
+
+export interface WatchTrigger {
+  type: 'file-change' | 'cron' | 'git-push'
+  glob?: string        // for file-change: glob pattern to watch
+  schedule?: string    // for cron: 5-field cron expression
+  branch?: string      // for git-push: branch name pattern
+  debounce_ms?: number // file-change debounce (default: 500ms)
+}
+
+export interface WatchConfig {
+  triggers: WatchTrigger[]
+  clear_scratchpad?: boolean // clear scratchpad on watch start
+  scratchpad_retention_days?: number // auto-clear scratchpad entries older than N days
+}
+
+export interface ScratchpadRecord {
+  key: string
+  value: string
+  updated_at: string
+}
+
+export interface MCPServerConfig {
+  name: string
+  type: string
+  local?: boolean
+  command?: string
+  args?: string[]
+  url?: string
+  config?: Record<string, unknown>
+}

package/src/cli/destroy.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { existsSync } from 'node:fs'
+
+vi.mock('./prompt.js', () => ({
+  confirm: vi.fn().mockResolvedValue(true),
+  closePrompts: vi.fn(),
+  c: {
+    green: (s: string) => s,
+    dim: (s: string) => s,
+    bold: (s: string) => s,
+    red: (s: string) => s,
+    cyan: (s: string) => s,
+    yellow: (s: string) => s,
+    magenta: (s: string) => s,
+  },
+}))
+
+import destroy from './destroy.js'
+import { confirm } from './prompt.js'
+import type { Manifest } from './types.js'
+
+const START_MARKER = '# >>> OpenCastle managed (do not edit) >>>'
+const END_MARKER = '# <<< OpenCastle managed <<<'
+
+async function writeManifestFile(dir: string, manifest: Partial<Manifest> = {}): Promise<void> {
+  await mkdir(join(dir, '.opencastle'), { recursive: true })
+  const full: Manifest = {
+    version: '1.0.0',
+    ide: 'vscode',
+    ides: ['vscode'],
+    installedAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    managedPaths: { framework: [], customizable: [] },
+    ...manifest,
+  }
+  await writeFile(join(dir, '.opencastle', 'manifest.json'), JSON.stringify(full, null, 2))
+}
+
+async function writeGitignoreWithBlock(dir: string, userEntries = 'node_modules\n'): Promise<void> {
+  const block = [userEntries, '', START_MARKER, '.github/', '!.github/customizations/', END_MARKER, ''].join('\n')
+  await writeFile(join(dir, '.gitignore'), block)
+}
+
+// ── Tests ──────────────────────────────────────────────────────
+
+describe('destroy', () => {
+  let tmpDir: string
+  let cwdSpy: ReturnType<typeof vi.spyOn>
+  let exitSpy: ReturnType<typeof vi.spyOn>
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'oc-destroy-'))
+    cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(tmpDir)
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('process.exit called')
+    })
+    vi.mocked(confirm).mockResolvedValue(true)
+  })
+
+  afterEach(async () => {
+    cwdSpy.mockRestore()
+    exitSpy.mockRestore()
+    await rm(tmpDir, { recursive: true, force: true })
+  })
+
+  it('removes all managed framework files', async () => {
+    await writeManifestFile(tmpDir, {
+      managedPaths: {
+        framework: ['.github/instructions/general.instructions.md', '.github/copilot-instructions.md'],
+        customizable: [],
+      },
+    })
+    await mkdir(join(tmpDir, '.github', 'instructions'), { recursive: true })
+    await writeFile(join(tmpDir, '.github', 'instructions', 'general.instructions.md'), 'content')
+    await writeFile(join(tmpDir, '.github', 'copilot-instructions.md'), 'content')
+
+    await destroy({ pkgRoot: tmpDir, args: [] })
+
+    expect(existsSync(join(tmpDir, '.github', 'instructions', 'general.instructions.md'))).toBe(false)
+    expect(existsSync(join(tmpDir, '.github', 'copilot-instructions.md'))).toBe(false)
+  })
+
+  it('removes .opencastle/ directory', async () => {
+    await writeManifestFile(tmpDir)
+    expect(existsSync(join(tmpDir, '.opencastle'))).toBe(true)
+
+    await destroy({ pkgRoot: tmpDir, args: [] })
+
+    expect(existsSync(join(tmpDir, '.opencastle'))).toBe(false)
+  })
+
+  it('removes legacy .opencastle.json manifest', async () => {
+    await writeManifestFile(tmpDir)
+    const legacyPath = join(tmpDir, '.opencastle.json')
+    await writeFile(legacyPath, JSON.stringify({ version: '0.1.0', ide: 'vscode', installedAt: '', updatedAt: '' }))
+
+    await destroy({ pkgRoot: tmpDir, args: [] })
+
+    expect(existsSync(legacyPath)).toBe(false)
+  })
+
+  it('cleans the gitignore block but keeps user entries', async () => {
+    await writeManifestFile(tmpDir)
+    await writeGitignoreWithBlock(tmpDir, 'node_modules\ndist\n')
+
+    await destroy({ pkgRoot: tmpDir, args: [] })
+
+    const gitignorePath = join(tmpDir, '.gitignore')
+    expect(existsSync(gitignorePath)).toBe(true)
+    const { readFile } = await import('node:fs/promises')
+    const content = await readFile(gitignorePath, 'utf8')
+    expect(content).not.toContain(START_MARKER)
+    expect(content).not.toContain(END_MARKER)
+    expect(content).toContain('node_modules')
+    expect(content).toContain('dist')
+  })
+
+  it('dry-run makes no changes', async () => {
+    await writeManifestFile(tmpDir, {
+      managedPaths: { framework: ['some-file.md'], customizable: [] },
+    })
+    await writeFile(join(tmpDir, 'some-file.md'), 'content')
+    await writeGitignoreWithBlock(tmpDir)
+
+    await destroy({ pkgRoot: tmpDir, args: ['--dry-run'] })
+
+    expect(existsSync(join(tmpDir, 'some-file.md'))).toBe(true)
+    expect(existsSync(join(tmpDir, '.opencastle'))).toBe(true)
+    const { readFile } = await import('node:fs/promises')
+    const gitignore = await readFile(join(tmpDir, '.gitignore'), 'utf8')
+    expect(gitignore).toContain(START_MARKER)
+  })
+
+  it('exits with error when no manifest found', async () => {
+    await expect(destroy({ pkgRoot: tmpDir, args: [] })).rejects.toThrow('process.exit called')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+})

package/src/cli/destroy.ts

@@ -0,0 +1,88 @@
+import { resolve } from 'node:path'
+import { unlink } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { readManifest } from './manifest.js'
+import { removeDirIfExists } from './copy.js'
+import { removeGitignoreBlock } from './gitignore.js'
+import { confirm, closePrompts, c } from './prompt.js'
+import type { CliContext } from './types.js'
+
+export default async function destroy({
+  pkgRoot: _pkgRoot,
+  args,
+}: CliContext): Promise<void> {
+  const projectRoot = process.cwd()
+  const dryRun = args.includes('--dry-run') || args.includes('--dryRun')
+
+  const manifest = await readManifest(projectRoot)
+  if (!manifest) {
+    console.error('  ✗ No OpenCastle installation found.')
+    process.exit(1)
+  }
+
+  const frameworkPaths = manifest.managedPaths?.framework ?? []
+  const customizablePaths = manifest.managedPaths?.customizable ?? []
+  const legacyManifestPath = resolve(projectRoot, '.opencastle.json')
+  const hasLegacy = existsSync(legacyManifestPath)
+
+  console.log(`\n  🏰 OpenCastle destroy\n`)
+  console.log('  This will permanently remove:\n')
+
+  for (const p of frameworkPaths) {
+    console.log(`    ${c.dim(p)}`)
+  }
+  for (const p of customizablePaths) {
+    console.log(`    ${c.dim(p)}`)
+  }
+  console.log(`    ${c.dim('.opencastle/')}`)
+  if (hasLegacy) {
+    console.log(`    ${c.dim('.opencastle.json')}`)
+  }
+  console.log(`    ${c.dim('.gitignore block')}\n`)
+
+  if (dryRun) {
+    console.log('  [dry-run] No files were changed.\n')
+    return
+  }
+
+  const proceed = await confirm(
+    'This will permanently delete all OpenCastle files. Continue?',
+    false
+  )
+  if (!proceed) {
+    console.log('  Aborted.')
+    closePrompts()
+    return
+  }
+
+  let removed = 0
+
+  for (const p of [...frameworkPaths, ...customizablePaths]) {
+    if (p.endsWith('/')) {
+      const dir = resolve(projectRoot, p)
+      await removeDirIfExists(dir)
+      removed++
+    } else {
+      const file = resolve(projectRoot, p)
+      if (existsSync(file)) {
+        await unlink(file)
+        removed++
+      }
+    }
+  }
+
+  await removeDirIfExists(resolve(projectRoot, '.opencastle'))
+  removed++
+
+  if (hasLegacy) {
+    await unlink(legacyManifestPath)
+    removed++
+  }
+
+  const gitignoreResult = await removeGitignoreBlock(projectRoot)
+
+  console.log(`\n  ${c.green('✓')} Removed ${removed} path(s)${gitignoreResult === 'removed' ? ' + .gitignore block' : ''}.`)
+  console.log(`  You can uninstall: ${c.bold('npm uninstall opencastle')}\n`)
+
+  closePrompts()
+}

package/src/cli/gitignore.ts

@@ -72,3 +72,39 @@ export async function updateGitignore(
   await writeFile(gitignorePath, existing + separator + block + '\n', 'utf8')
   return 'updated'
 }
+
+/**
+ * Remove the OpenCastle managed block from `.gitignore`.
+ *
+ * - No-op if no `.gitignore` exists or no block is present.
+ * - Cleans up resulting double blank lines.
+ * - Deletes `.gitignore` if the file becomes empty after removal.
+ * - Returns 'removed' or 'unchanged'.
+ */
+export async function removeGitignoreBlock(
+  projectRoot: string
+): Promise<'removed' | 'unchanged'> {
+  const gitignorePath = resolve(projectRoot, '.gitignore')
+  if (!existsSync(gitignorePath)) return 'unchanged'
+
+  const existing = await readFile(gitignorePath, 'utf8')
+  const startIdx = existing.indexOf(START_MARKER)
+  const endIdx = existing.indexOf(END_MARKER)
+
+  if (startIdx === -1 || endIdx === -1) return 'unchanged'
+
+  const before = existing.slice(0, startIdx)
+  const after = existing.slice(endIdx + END_MARKER.length)
+
+  // Collapse consecutive blank lines left by removal
+  const updated = (before + after).replace(/\n{3,}/g, '\n\n').trimEnd()
+
+  if (!updated) {
+    const { unlink } = await import('node:fs/promises')
+    await unlink(gitignorePath)
+    return 'removed'
+  }
+
+  await writeFile(gitignorePath, updated + '\n', 'utf8')
+  return 'removed'
+}