opencastle 0.26.1 → 0.27.1

package/src/cli/run/schema.ts

@@ -34,30 +34,89 @@ export function parseTimeout(timeout: string): number {
 }
 
 interface RawSpec {
-  name?: unknown
-  concurrency?: unknown
-  on_failure?: unknown
-  adapter?: unknown
-  tasks?: unknown
-  version?: unknown
-  defaults?: unknown
-  gates?: unknown
-  gate_retries?: unknown
-  branch?: unknown
-  depends_on_convoy?: unknown
+  name?: string
+  concurrency?: number | string
+  on_failure?: string
+  adapter?: string
+  tasks?: RawTask[]
+  version?: number
+  defaults?: {
+    timeout?: string
+    model?: string
+    max_retries?: number
+    agent?: string
+    adapter?: string
+    mcp_servers?: unknown[]
+    mcp_approve_all?: unknown
+    mcp_server_approval_timeout?: unknown
+    built_in_gates?: unknown
+    browser_test?: unknown
+    review?: unknown
+    reviewer_model?: unknown
+    review_budget?: unknown
+    on_review_budget_exceeded?: unknown
+    max_concurrent_reviews?: unknown
+    review_heuristics?: unknown
+    max_swarm_concurrency?: unknown
+  }
+  gates?: string[]
+  gate_retries?: number
+  branch?: string
+  depends_on_convoy?: string[]
+  guard?: unknown
 }
 
 interface RawTask {
-  id?: unknown
-  prompt?: unknown
-  agent?: unknown
-  timeout?: unknown
-  depends_on?: unknown
-  files?: unknown
-  description?: unknown
-  model?: unknown
-  max_retries?: unknown
-  adapter?: unknown
+  id?: string
+  prompt?: string
+  agent?: string
+  timeout?: string
+  depends_on?: string[]
+  files?: string[]
+  description?: string
+  model?: string
+  max_retries?: number
+  adapter?: string
+  built_in_gates?: unknown
+  browser_test?: unknown
+  review?: string
+}
+
+/**
+ * Validate a browser_test config object for the given prefix.
+ */
+function validateBrowserTestConfig(value: unknown, prefix: string, errors: string[]): void {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    errors.push(`\`${prefix}\` must be an object`)
+    return
+  }
+  const bt = value as Record<string, unknown>
+  if (bt.urls === undefined) {
+    errors.push(`\`${prefix}.urls\` is required`)
+  } else if (!Array.isArray(bt.urls) || (bt.urls as unknown[]).length === 0) {
+    errors.push(`\`${prefix}.urls\` must be a non-empty array`)
+  } else if (!(bt.urls as unknown[]).every((u) => typeof u === 'string')) {
+    errors.push(`\`${prefix}.urls\` must be an array of strings`)
+  }
+  if (bt.check_console_errors !== undefined && typeof bt.check_console_errors !== 'boolean') {
+    errors.push(`\`${prefix}.check_console_errors\` must be a boolean`)
+  }
+  if (bt.visual_diff_threshold !== undefined) {
+    const vdt = Number(bt.visual_diff_threshold)
+    if (!Number.isFinite(vdt) || vdt < 0 || vdt > 1) {
+      errors.push(`\`${prefix}.visual_diff_threshold\` must be a number between 0 and 1`)
+    }
+  }
+  if (bt.a11y !== undefined && typeof bt.a11y !== 'boolean') {
+    errors.push(`\`${prefix}.a11y\` must be a boolean`)
+  }
+  const validSeverities = ['critical', 'serious', 'moderate', 'minor']
+  if (bt.severity_threshold !== undefined && !validSeverities.includes(bt.severity_threshold as string)) {
+    errors.push(`\`${prefix}.severity_threshold\` must be one of: ${validSeverities.join(', ')}`)
+  }
+  if (bt.baselines_dir !== undefined && typeof bt.baselines_dir !== 'string') {
+    errors.push(`\`${prefix}.baselines_dir\` must be a string`)
+  }
 }
 
 /**
@@ -79,9 +138,13 @@ export function validateSpec(spec: unknown): ValidationResult {
 
   // Concurrency
   if (s.concurrency !== undefined) {
-    const c = Number(s.concurrency)
-    if (!Number.isInteger(c) || c < 1) {
-      errors.push('`concurrency` must be an integer >= 1')
+    if (s.concurrency === 'auto') {
+      // valid swarm mode
+    } else {
+      const c = Number(s.concurrency)
+      if (!Number.isInteger(c) || c < 1 || c > 50) {
+        errors.push('`concurrency` must be an integer between 1 and 50, or "auto"')
+      }
     }
   }
 
@@ -142,6 +205,158 @@ export function validateSpec(spec: unknown): ValidationResult {
       if (d.adapter !== undefined && typeof d.adapter !== 'string') {
         errors.push('`defaults.adapter` must be a string')
       }
+
+      // MCP servers validation (Phase 19.7)
+      if (d.mcp_servers !== undefined) {
+        if (!Array.isArray(d.mcp_servers)) {
+          errors.push('`defaults.mcp_servers` must be an array')
+        } else {
+          for (let j = 0; j < (d.mcp_servers as unknown[]).length; j++) {
+            const server = (d.mcp_servers as unknown[])[j]
+            const sp = `defaults.mcp_servers[${j}]`
+            if (!server || typeof server !== 'object' || Array.isArray(server)) {
+              errors.push(`\`${sp}\` must be an object`)
+              continue
+            }
+            const srv = server as Record<string, unknown>
+            if (!srv.name || typeof srv.name !== 'string') {
+              errors.push(`\`${sp}.name\` is required and must be a string`)
+            }
+            if (!srv.type || typeof srv.type !== 'string') {
+              errors.push(`\`${sp}.type\` is required and must be a string`)
+            }
+            if (srv.local !== undefined && typeof srv.local !== 'boolean') {
+              errors.push(`\`${sp}.local\` must be a boolean`)
+            }
+            if (srv.command !== undefined && typeof srv.command !== 'string') {
+              errors.push(`\`${sp}.command\` must be a string`)
+            }
+            if (srv.args !== undefined) {
+              if (!Array.isArray(srv.args) || !(srv.args as unknown[]).every(a => typeof a === 'string')) {
+                errors.push(`\`${sp}.args\` must be an array of strings`)
+              }
+            }
+            if (srv.url !== undefined && typeof srv.url !== 'string') {
+              errors.push(`\`${sp}.url\` must be a string`)
+            }
+            if (srv.config !== undefined) {
+              if (!srv.config || typeof srv.config !== 'object' || Array.isArray(srv.config)) {
+                errors.push(`\`${sp}.config\` must be an object`)
+              }
+            }
+          }
+        }
+      }
+
+      // mcp_approve_all validation
+      if (d.mcp_approve_all !== undefined && typeof d.mcp_approve_all !== 'boolean') {
+        errors.push('`defaults.mcp_approve_all` must be a boolean')
+      }
+
+      // mcp_server_approval_timeout validation
+      if (d.mcp_server_approval_timeout !== undefined) {
+        const t = Number(d.mcp_server_approval_timeout)
+        if (!Number.isFinite(t) || t <= 0) {
+          errors.push('`defaults.mcp_server_approval_timeout` must be a number greater than 0')
+        }
+      }
+
+      // built_in_gates validation
+      if (d.built_in_gates !== undefined) {
+        if (!d.built_in_gates || typeof d.built_in_gates !== 'object' || Array.isArray(d.built_in_gates)) {
+          errors.push('`defaults.built_in_gates` must be an object')
+        } else {
+          const bg = d.built_in_gates as Record<string, unknown>
+          const boolOrAutoFields = ['secret_scan', 'blast_radius', 'dependency_audit', 'regression_test', 'browser_test'] as const
+          for (const field of boolOrAutoFields) {
+            if (bg[field] !== undefined && typeof bg[field] !== 'boolean' && bg[field] !== 'auto') {
+              errors.push(`\`defaults.built_in_gates.${field}\` must be a boolean or "auto"`)
+            }
+          }
+          if (bg.gate_timeout !== undefined) {
+            const gt = Number(bg.gate_timeout)
+            if (!Number.isFinite(gt) || gt <= 0) {
+              errors.push('`defaults.built_in_gates.gate_timeout` must be a number greater than 0')
+            }
+          }
+        }
+      }
+
+      // browser_test config validation
+      if (d.browser_test !== undefined) {
+        validateBrowserTestConfig(d.browser_test, 'defaults.browser_test', errors)
+      }
+
+      // review validation
+      const VALID_REVIEW = ['auto', 'fast', 'panel', 'none']
+      if (d.review !== undefined && !VALID_REVIEW.includes(d.review as string)) {
+        errors.push('`defaults.review` must be one of: ' + VALID_REVIEW.join(', '))
+      }
+      if (d.reviewer_model !== undefined && typeof d.reviewer_model !== 'string') {
+        errors.push('`defaults.reviewer_model` must be a string')
+      }
+      if (d.review_budget !== undefined) {
+        const rb = Number(d.review_budget)
+        if (!Number.isInteger(rb) || rb < 1) {
+          errors.push('`defaults.review_budget` must be a positive integer')
+        }
+      }
+      const VALID_BUDGET_EXCEEDED = ['skip', 'downgrade', 'stop']
+      if (
+        d.on_review_budget_exceeded !== undefined &&
+        !VALID_BUDGET_EXCEEDED.includes(d.on_review_budget_exceeded as string)
+      ) {
+        errors.push(
+          '`defaults.on_review_budget_exceeded` must be one of: ' + VALID_BUDGET_EXCEEDED.join(', '),
+        )
+      }
+      if (d.max_concurrent_reviews !== undefined) {
+        const mcr = Number(d.max_concurrent_reviews)
+        if (!Number.isInteger(mcr) || mcr < 1) {
+          errors.push('`defaults.max_concurrent_reviews` must be a positive integer')
+        }
+      }
+      if (d.review_heuristics !== undefined) {
+        if (
+          !d.review_heuristics ||
+          typeof d.review_heuristics !== 'object' ||
+          Array.isArray(d.review_heuristics)
+        ) {
+          errors.push('`defaults.review_heuristics` must be an object')
+        } else {
+          const rh = d.review_heuristics as Record<string, unknown>
+          for (const field of ['panel_paths', 'panel_agents', 'auto_pass_agents'] as const) {
+            if (rh[field] !== undefined) {
+              if (
+                !Array.isArray(rh[field]) ||
+                !(rh[field] as unknown[]).every((v) => typeof v === 'string')
+              ) {
+                errors.push(
+                  `\`defaults.review_heuristics.${field}\` must be an array of strings`,
+                )
+              }
+            }
+          }
+          if (rh.auto_pass_max_lines !== undefined) {
+            const apl = Number(rh.auto_pass_max_lines)
+            if (!Number.isInteger(apl) || apl < 1) {
+              errors.push('`defaults.review_heuristics.auto_pass_max_lines` must be a positive integer')
+            }
+          }
+          if (rh.auto_pass_max_files !== undefined) {
+            const apf = Number(rh.auto_pass_max_files)
+            if (!Number.isInteger(apf) || apf < 1) {
+              errors.push('`defaults.review_heuristics.auto_pass_max_files` must be a positive integer')
+            }
+          }
+        }
+      }
+      if (d.max_swarm_concurrency !== undefined) {
+        const msc = Number(d.max_swarm_concurrency)
+        if (!Number.isInteger(msc) || msc < 1 || msc > 50) {
+          errors.push('`defaults.max_swarm_concurrency` must be an integer between 1 and 50')
+        }
+      }
     }
   }
 
@@ -168,6 +383,28 @@ export function validateSpec(spec: unknown): ValidationResult {
     errors.push('`branch` must be a string')
   }
 
+  // guard config validation
+  if (s.guard !== undefined) {
+    const g = s.guard as Record<string, unknown>
+    if (!g || typeof g !== 'object' || Array.isArray(g)) {
+      errors.push('`guard` must be an object')
+    } else {
+      if (g.enabled !== undefined && typeof g.enabled !== 'boolean') {
+        errors.push('`guard.enabled` must be a boolean')
+      }
+      if (g.agent !== undefined && typeof g.agent !== 'string') {
+        errors.push('`guard.agent` must be a string')
+      }
+      if (g.checks !== undefined) {
+        if (!Array.isArray(g.checks)) {
+          errors.push('`guard.checks` must be an array of non-empty strings')
+        } else if (!(g.checks as unknown[]).every((c) => typeof c === 'string' && c.length > 0)) {
+          errors.push('`guard.checks` must be an array of non-empty strings')
+        }
+      }
+    }
+  }
+
   // Tasks: required unless this is a version:2 pipeline spec with depends_on_convoy
   const isPipeline =
     s.version === 2 &&
@@ -264,6 +501,40 @@ export function validateSpec(spec: unknown): ValidationResult {
     if (task.adapter !== undefined && typeof task.adapter !== 'string') {
       errors.push(`${prefix}: \`adapter\` must be a string`)
     }
+
+    // built_in_gates (task-level)
+    if (task.built_in_gates !== undefined) {
+      if (!task.built_in_gates || typeof task.built_in_gates !== 'object' || Array.isArray(task.built_in_gates)) {
+        errors.push(`${prefix}: \`built_in_gates\` must be an object`)
+      } else {
+        const bg = task.built_in_gates as Record<string, unknown>
+        const boolOrAutoFields = ['secret_scan', 'blast_radius', 'dependency_audit', 'regression_test', 'browser_test'] as const
+        for (const field of boolOrAutoFields) {
+          if (bg[field] !== undefined && typeof bg[field] !== 'boolean' && bg[field] !== 'auto') {
+            errors.push(`${prefix}: \`built_in_gates.${field}\` must be a boolean or "auto"`)
+          }
+        }
+        if (bg.gate_timeout !== undefined) {
+          const gt = Number(bg.gate_timeout)
+          if (!Number.isFinite(gt) || gt <= 0) {
+            errors.push(`${prefix}: \`built_in_gates.gate_timeout\` must be a number greater than 0`)
+          }
+        }
+      }
+    }
+
+    // browser_test (task-level)
+    if (task.browser_test !== undefined) {
+      validateBrowserTestConfig(task.browser_test, `${prefix}.browser_test`, errors)
+    }
+
+    // review (task-level)
+    if (task.review !== undefined) {
+      const VALID_TASK_REVIEW = ['auto', 'fast', 'panel', 'none']
+      if (!VALID_TASK_REVIEW.includes(task.review as string)) {
+        errors.push(`${prefix}: \`review\` must be one of: ${VALID_TASK_REVIEW.join(', ')}`)
+      }
+    }
   }
 
   // DAG cycle detection
@@ -324,7 +595,7 @@ function detectCycles(tasks: Array<{ id: string; depends_on?: string[] }>): stri
  */
 export function applyDefaults(spec: Record<string, unknown>): TaskSpec {
   const s = spec as Record<string, unknown>
-  s.concurrency = s.concurrency !== undefined ? Number(s.concurrency) : 1
+  s.concurrency = s.concurrency === 'auto' ? 'auto' : (s.concurrency !== undefined ? Number(s.concurrency) : 1)
   s.on_failure = (s.on_failure as string) || 'continue'
   // Leave adapter empty so run.ts can auto-detect the best available CLI
   s.adapter = (s.adapter as string) || ''
@@ -358,6 +629,10 @@ export function applyDefaults(spec: Record<string, unknown>): TaskSpec {
     if (task.adapter === undefined && d.adapter !== undefined) {
       task.adapter = d.adapter
     }
+    // review: task-level overrides defaults
+    if (task.review === undefined && d.review !== undefined) {
+      task.review = d.review
+    }
   }
 
   return s as unknown as TaskSpec