adaptive-director-skill 0.1.0

package/scripts/route.mjs

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * route.mjs
+ * ──────────
+ * Deterministic routing script.
+ * NO reasoning. Applies fixed rules only.
+ *
+ * Input (stdin JSON or --input flag):
+ *   {
+ *     "taskSize":        "small" | "medium" | "large",
+ *     "phase":           "plan" | "implement" | "review" | "fix" | "verify",
+ *     "budget":          "conservative" | "balanced" | "quality",
+ *     "allowMax":        boolean,
+ *     "delegateEnabled": boolean,
+ *     "currentModel":    string   (optional, for role check)
+ *   }
+ *
+ * Output (stdout JSON):
+ *   {
+ *     "agent":     string,
+ *     "model":     string | null,
+ *     "effort":    "low" | "medium" | "high" | "max",
+ *     "execution": "native" | "delegate"
+ *   }
+ *
+ * Usage:
+ *   echo '{"taskSize":"medium","phase":"review","budget":"balanced","allowMax":false,"delegateEnabled":false}' | node scripts/route.mjs
+ *   node scripts/route.mjs --input '{"taskSize":"medium",...}'
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+// ─── Registry ─────────────────────────────────────────────────────────────────
+
+const REGISTRY_PATH = join(import.meta.dirname ?? '.', '../data/registry.json')
+
+function loadRegistry() {
+  if (!existsSync(REGISTRY_PATH)) {
+    return { models: {}, effort_table: {}, phase_requirements: {} }
+  }
+  return JSON.parse(readFileSync(REGISTRY_PATH, 'utf8'))
+}
+
+// ─── User config ──────────────────────────────────────────────────────────────
+
+const USER_CONFIG_PATH = existsSync(join(homedir(), '.adaptive-director', 'config.yaml'))
+  ? join(homedir(), '.adaptive-director', 'config.yaml')
+  : join(homedir(), '.adaptive-orchestrator', 'config.yaml')
+
+function loadUserConfig() {
+  if (!existsSync(USER_CONFIG_PATH)) return {}
+  // Simple YAML parser (key: value only, no nesting needed here)
+  const raw = readFileSync(USER_CONFIG_PATH, 'utf8')
+  const config = {}
+  for (const line of raw.split('\n')) {
+    const m = line.match(/^(\w[\w.]*?):\s*(.+)$/)
+    if (m) config[m[1].trim()] = m[2].trim()
+  }
+  return config
+}
+
+// ─── Delegate fleet ───────────────────────────────────────────────────────────
+
+function loadDelegateLanes() {
+  const paths = [
+    join(process.cwd(), '.delegate', 'fleet.yaml'),
+    join(homedir(), '.delegate', 'fleet.yaml'),
+  ]
+
+  for (const p of paths) {
+    if (!existsSync(p)) continue
+    try {
+      const raw = readFileSync(p, 'utf8')
+      const lanes = {}
+      let current = null
+      for (const line of raw.split('\n')) {
+        const laneMatch = line.match(/^  (\w[\w-]*):\s*$/)
+        const implMatch = line.match(/^\s+implementer:\s*(.+)$/)
+        const modelMatch = line.match(/^\s+model:\s*(.+)$/)
+        const effortMatch = line.match(/^\s+effort:\s*(.+)$/)
+        if (laneMatch)   { current = laneMatch[1]; lanes[current] = {} }
+        if (current && implMatch)   lanes[current].agent  = implMatch[1].trim()
+        if (current && modelMatch)  lanes[current].model  = modelMatch[1].trim()
+        if (current && effortMatch) lanes[current].effort = effortMatch[1].trim()
+      }
+      return lanes
+    } catch { continue }
+  }
+  return {}
+}
+
+// ─── Scoring ──────────────────────────────────────────────────────────────────
+
+function modelScore(registry, modelId) {
+  return (
+    registry.models[modelId] ??
+    registry.models[modelId?.toLowerCase()] ??
+    registry.models['unknown'] ??
+    { planning: 1, coding: 1, review: 1 }
+  )
+}
+
+function meetsRequirement(registry, modelId, phase) {
+  const score = modelScore(registry, modelId)
+  const req   = registry.phase_requirements?.[phase] ?? {}
+  if (req.min_planning && score.planning < req.min_planning) return false
+  if (req.min_coding   && score.coding   < req.min_coding)   return false
+  if (req.min_review   && score.review   < req.min_review)   return false
+  return true
+}
+
+// Phase-relevant score for ranking
+function phaseScore(registry, modelId, phase) {
+  const s = modelScore(registry, modelId)
+  if (phase === 'plan' || phase === 'review' || phase === 'verify') return s.planning + s.review
+  return s.coding
+}
+
+// ─── Agent → representative model mapping ─────────────────────────────────────
+
+const AGENT_MODEL_MAP = {
+  claude:   'claude-sonnet-4-5',
+  agy:      'claude-sonnet-4-5',
+  codex:    'codex-default',
+  gemini:   'gemini-2-5-pro',
+  opencode: 'gpt-4o',
+  aider:    'gpt-4o',
+  cursor:   'claude-sonnet-4-5',
+  cline:    'claude-sonnet-4-5',
+  copilot:  'gpt-4o',
+}
+
+// Fallback priority order (best-to-acceptable)
+const AGENT_PRIORITY_FOR_PLANNING = ['claude', 'agy', 'gemini', 'opencode', 'cursor', 'cline', 'copilot', 'aider', 'codex']
+const AGENT_PRIORITY_FOR_CODING   = ['codex', 'aider', 'opencode', 'cursor', 'cline', 'claude', 'agy', 'copilot', 'gemini']
+
+// ─── Main routing logic ───────────────────────────────────────────────────────
+
+function route(input) {
+  const {
+    taskSize        = 'medium',
+    phase           = 'implement',
+    budget          = 'balanced',
+    allowMax        = false,
+    delegateEnabled = false,
+    currentModel    = 'unknown',
+  } = input
+
+  const registry   = loadRegistry()
+  const userConfig = loadUserConfig()
+  const lanes      = loadDelegateLanes()
+
+  // ── 1. User explicit override ────────────────────────────────────────────
+  const overrideKey = `agentOverrides.${phase}`
+  const explicitAgent = userConfig[overrideKey] ?? userConfig[`override_${phase}`]
+  if (explicitAgent) {
+    const effort = computeEffort(registry, budget, phase, allowMax)
+    return { agent: explicitAgent, model: null, effort, execution: 'native' }
+  }
+
+  // ── 2. Delegate lane (only when delegate is enabled) ────────────────────
+  if (delegateEnabled && Object.keys(lanes).length > 0) {
+    const laneForPhase = findLaneForPhase(lanes, phase)
+    if (laneForPhase) {
+      const effort = laneForPhase.effort ?? computeEffort(registry, budget, phase, allowMax)
+      return {
+        agent:     laneForPhase.agent,
+        model:     laneForPhase.model ?? null,
+        effort,
+        execution: 'delegate',
+      }
+    }
+  }
+
+  // ── 3. Built-in registry: best available agent for phase ─────────────────
+  const priorityList = (phase === 'plan' || phase === 'review' || phase === 'verify')
+    ? AGENT_PRIORITY_FOR_PLANNING
+    : AGENT_PRIORITY_FOR_CODING
+
+  for (const agentId of priorityList) {
+    const modelId = AGENT_MODEL_MAP[agentId] ?? 'unknown'
+    if (meetsRequirement(registry, modelId, phase)) {
+      const effort = computeEffort(registry, budget, phase, allowMax)
+      return { agent: agentId, model: modelId, effort, execution: 'native' }
+    }
+  }
+
+  // ── 4. Fallback ──────────────────────────────────────────────────────────
+  const effort = computeEffort(registry, budget, phase, allowMax)
+  return { agent: 'claude', model: null, effort, execution: 'native' }
+}
+
+function findLaneForPhase(lanes, phase) {
+  // Map phase to lane name heuristic
+  const keywords = {
+    plan:      ['plan', 'planning'],
+    implement: ['feature', 'impl', 'code', 'build'],
+    review:    ['review', 'check'],
+    fix:       ['fix', 'repair', 'feature'],
+    verify:    ['test', 'verify', 'qa'],
+  }
+  const keys = keywords[phase] ?? [phase]
+  for (const key of keys) {
+    for (const [name, lane] of Object.entries(lanes)) {
+      if (name.toLowerCase().includes(key) && lane.agent) return lane
+    }
+  }
+  // Return first lane as generic fallback if delegate is enabled
+  const first = Object.values(lanes)[0]
+  return first?.agent ? first : null
+}
+
+function computeEffort(registry, budget, phase, allowMax) {
+  const table = registry.effort_table?.[budget] ?? {}
+  let effort  = table[phase] ?? 'medium'
+  if (effort === 'max' && !allowMax) effort = 'high'
+  return effort
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+
+async function main() {
+  let input = {}
+
+  const inputFlag = process.argv.indexOf('--input')
+  if (inputFlag !== -1 && process.argv[inputFlag + 1]) {
+    input = JSON.parse(process.argv[inputFlag + 1])
+  } else if (!process.stdin.isTTY) {
+    const chunks = []
+    for await (const chunk of process.stdin) chunks.push(chunk)
+    const raw = Buffer.concat(chunks).toString('utf8').trim()
+    if (raw) input = JSON.parse(raw)
+  }
+
+  const result = route(input)
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n')
+}
+
+main().catch((err) => {
+  process.stderr.write('route.mjs error: ' + err.message + '\n')
+  process.exit(1)
+})

package/scripts/run-state.mjs

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+/**
+ * run-state.mjs
+ * ──────────────
+ * Manages run workspace files.
+ * All operations are deterministic — no reasoning.
+ *
+ * Commands:
+ *   node scripts/run-state.mjs init     --run-id <id> --task <str> --size <s> --budget <b>
+ *   node scripts/run-state.mjs update   --run-id <id> --status <s> [--phase <p>]
+ *   node scripts/run-state.mjs read     --run-id <id>
+ *   node scripts/run-state.mjs write-phase --run-id <id> --phase <p> --status <s> --summary <str> [--findings-json <json>]
+ *   node scripts/run-state.mjs read-phase  --run-id <id> --phase <p>
+ *   node scripts/run-state.mjs build-brief --run-id <id> --phase <p>
+ *   node scripts/run-state.mjs list
+ */
+
+import {
+  mkdirSync, writeFileSync, readFileSync,
+  existsSync, readdirSync
+} from 'node:fs'
+import { join } from 'node:path'
+import { randomBytes } from 'node:crypto'
+
+// ─── Workspace root ───────────────────────────────────────────────────────────
+
+const RUNS_ROOT = existsSync(join(process.cwd(), '.adaptive-orchestrator', 'runs'))
+  ? join(process.cwd(), '.adaptive-orchestrator', 'runs')
+  : join(process.cwd(), '.adaptive-director', 'runs')
+
+function runDir(runId) { return join(RUNS_ROOT, runId) }
+function metaPath(runId) { return join(runDir(runId), 'metadata.json') }
+function phaseMdPath(runId, phase) { return join(runDir(runId), `${phase}.md`) }
+function phaseJsonPath(runId, phase) { return join(runDir(runId), `${phase}.json`) }
+
+// ─── Commands ─────────────────────────────────────────────────────────────────
+
+function cmdInit(args) {
+  const runId  = args['--run-id']  ?? ('run-' + randomBytes(4).toString('hex'))
+  const task   = args['--task']    ?? ''
+  const size   = args['--size']    ?? 'medium'
+  const budget = args['--budget']  ?? 'balanced'
+
+  mkdirSync(runDir(runId), { recursive: true })
+
+  // task.md
+  writeFileSync(phaseMdPath(runId, 'task'),
+    `# Task\n\n${task}\n\n## Constraints\n\n- Stay in scope\n- Document all decisions\n`, 'utf8')
+
+  // metadata.json
+  const meta = {
+    runId,
+    task,
+    status: 'pending',
+    currentPhase: null,
+    size,
+    budget,
+    allowMax: false,
+    useDelegate: false,
+    routing: [],
+    startedAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  }
+  writeFileSync(metaPath(runId), JSON.stringify(meta, null, 2), 'utf8')
+
+  out({ runId, workspacePath: runDir(runId) })
+}
+
+function cmdUpdate(args) {
+  const runId  = requireArg(args, '--run-id')
+  const status = args['--status']
+  const phase  = args['--phase'] ?? null
+
+  const meta = readMeta(runId)
+  if (status) meta.status = status
+  if (phase !== null) meta.currentPhase = phase
+  meta.updatedAt = new Date().toISOString()
+  writeFileSync(metaPath(runId), JSON.stringify(meta, null, 2), 'utf8')
+  out({ ok: true, runId, status: meta.status, currentPhase: meta.currentPhase })
+}
+
+function cmdRead(args) {
+  const runId = requireArg(args, '--run-id')
+  out(readMeta(runId))
+}
+
+function cmdWritePhase(args) {
+  const runId   = requireArg(args, '--run-id')
+  const phase   = requireArg(args, '--phase')
+  const status  = args['--status'] ?? 'completed'
+  const summary = args['--summary'] ?? ''
+  const findingsRaw = args['--findings-json']
+
+  let findings = []
+  if (findingsRaw) {
+    try { findings = JSON.parse(findingsRaw) } catch { findings = [] }
+  }
+
+  const result = { phase, status, summary, findings }
+
+  // .json (machine contract)
+  writeFileSync(phaseJsonPath(runId, phase), JSON.stringify(result, null, 2), 'utf8')
+
+  // .md (human readable)
+  const lines = [
+    `# ${capitalize(phase)} Result`,
+    '',
+    `**Status:** ${status}`,
+    '',
+    '## Summary',
+    '',
+    summary,
+  ]
+  if (findings.length > 0) {
+    lines.push('', '## Findings', '')
+    for (const f of findings) {
+      lines.push(`### [${f.severity?.toUpperCase() ?? 'NOTE'}] ${f.title ?? ''}`)
+      if (f.file) lines.push(`**File:** \`${f.file}\``)
+      lines.push('', f.description ?? '', '')
+    }
+  }
+  writeFileSync(phaseMdPath(runId, phase), lines.join('\n'), 'utf8')
+
+  out({ ok: true, phase, status })
+}
+
+function cmdReadPhase(args) {
+  const runId = requireArg(args, '--run-id')
+  const phase = requireArg(args, '--phase')
+  const path  = phaseJsonPath(runId, phase)
+  if (!existsSync(path)) { out(null); return }
+  out(JSON.parse(readFileSync(path, 'utf8')))
+}
+
+function cmdBuildBrief(args) {
+  const runId = requireArg(args, '--run-id')
+  const phase = requireArg(args, '--phase')
+
+  const dir   = runDir(runId)
+  const task  = safeRead(join(dir, 'task.md'))
+  const plan  = safeRead(join(dir, 'plan.md'))
+  const impl  = safeRead(join(dir, 'implementation.md'))
+  const rev   = safeRead(join(dir, 'review.md'))
+
+  let brief = ''
+
+  switch (phase) {
+    case 'plan':
+      brief = [
+        task ?? '',
+        '---',
+        '# Your Role: Planner',
+        '',
+        'Inspect the repository and produce a detailed step-by-step plan.',
+        'After inspecting, if the initial task size estimate seems wrong, say so.',
+        '',
+        '## Required Output',
+        '1. Numbered implementation steps',
+        '2. Files/modules involved',
+        '3. Acceptance criteria',
+        '4. Constraints',
+        '5. End with a JSON block:',
+        '```json',
+        '{"recommended_size": "medium", "reason": "..."}',
+        '```',
+      ].join('\n')
+      break
+
+    case 'implement':
+      brief = [
+        task ?? '',
+        '',
+        '---',
+        '',
+        '# Approved Plan',
+        '',
+        plan ?? '(no plan — use best judgment)',
+        '',
+        '---',
+        '',
+        '# Your Role: Implementer',
+        '',
+        '- Implement the approved plan exactly.',
+        '- Stay in scope. Do NOT commit.',
+        '- Report: changed files, completed work, test results, known issues.',
+      ].join('\n')
+      break
+
+    case 'review':
+      brief = [
+        task ?? '',
+        '',
+        '---',
+        '',
+        '# Plan',
+        plan ?? '(no plan)',
+        '',
+        '---',
+        '',
+        '# Implementation Report',
+        impl ?? '(no implementation report)',
+        '',
+        '---',
+        '',
+        '# Your Role: Independent Reviewer',
+        '',
+        'Review the implementation against the plan.',
+        'Classify EVERY finding as exactly one of:',
+        '  CRITICAL — must fix before completion',
+        '  WARNING  — report, do not block',
+        '  SUGGESTION — informational only',
+        '',
+        'Format each finding as:',
+        '  [CRITICAL] <title>',
+        '  File: <filename>',
+        '  <description>',
+      ].join('\n')
+      break
+
+    case 'fix':
+      brief = [
+        task ?? '',
+        '',
+        '---',
+        '',
+        '# Previous Review (with CRITICAL findings)',
+        rev ?? '(no review)',
+        '',
+        '---',
+        '',
+        '# Your Role: Fixer',
+        '',
+        'Fix ONLY the CRITICAL findings listed above.',
+        'Do not redesign or change scope.',
+        'Do NOT commit.',
+        'Report what you changed.',
+      ].join('\n')
+      break
+
+    case 'verify':
+      brief = [
+        task ?? '',
+        '',
+        '---',
+        '',
+        '# Plan',
+        plan ?? '(no plan)',
+        '',
+        '---',
+        '',
+        '# Your Role: Verifier',
+        '',
+        'Verify the implementation:',
+        '- Requirements satisfied?',
+        '- Tests passing?',
+        '- Build successful?',
+        '- All CRITICAL findings resolved?',
+        '- Implementation matches plan?',
+        '',
+        'End with either:',
+        '  VERIFIED — all checks passed',
+        '  BLOCKED  — <reason>',
+      ].join('\n')
+      break
+
+    default:
+      brief = task ?? ''
+  }
+
+  process.stdout.write(brief + '\n')
+}
+
+function cmdList() {
+  if (!existsSync(RUNS_ROOT)) { out([]); return }
+  const dirs = readdirSync(RUNS_ROOT, { withFileTypes: true })
+    .filter(d => d.isDirectory()).map(d => d.name)
+  const runs = dirs.map(id => {
+    try { return JSON.parse(readFileSync(metaPath(id), 'utf8')) } catch { return null }
+  }).filter(Boolean)
+  runs.sort((a, b) => b.startedAt.localeCompare(a.startedAt))
+  out(runs)
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function readMeta(runId) {
+  const path = metaPath(runId)
+  if (!existsSync(path)) throw new Error(`Run not found: ${runId}`)
+  return JSON.parse(readFileSync(path, 'utf8'))
+}
+
+function safeRead(path) {
+  return existsSync(path) ? readFileSync(path, 'utf8') : null
+}
+
+function requireArg(args, key) {
+  if (!args[key]) { process.stderr.write(`Missing required argument: ${key}\n`); process.exit(2) }
+  return args[key]
+}
+
+function out(data) {
+  process.stdout.write(JSON.stringify(data, null, 2) + '\n')
+}
+
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1)
+}
+
+// ─── Arg parser ───────────────────────────────────────────────────────────────
+
+function parseArgs(argv) {
+  const args = {}
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith('--')) {
+      args[argv[i]] = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[++i] : true
+    }
+  }
+  return args
+}
+
+// ─── Entry ────────────────────────────────────────────────────────────────────
+
+const [,, command, ...rest] = process.argv
+const args = parseArgs(rest)
+
+try {
+  switch (command) {
+    case 'init':        cmdInit(args);        break
+    case 'update':      cmdUpdate(args);      break
+    case 'read':        cmdRead(args);        break
+    case 'write-phase': cmdWritePhase(args);  break
+    case 'read-phase':  cmdReadPhase(args);   break
+    case 'build-brief': cmdBuildBrief(args);  break
+    case 'list':        cmdList();            break
+    default:
+      process.stderr.write(`Unknown command: ${command}\n`)
+      process.stderr.write('Commands: init, update, read, write-phase, read-phase, build-brief, list\n')
+      process.exit(2)
+  }
+} catch (err) {
+  process.stderr.write('run-state.mjs error: ' + err.message + '\n')
+  process.exit(1)
+}