dual-brain 4.6.0 → 4.7.1

package/hooks/config-validator.mjs

@@ -1,156 +0,0 @@
-/**
- * config-validator.mjs — Validates orchestrator.json on load.
- *
- * Exports:
- *   validateConfig(config) → { valid: boolean, errors: string[], warnings: string[] }
- *   loadAndValidateConfig(configPath) → { config, validation }
- *
- * On invalid config: logs errors via error-channel.mjs, returns sensible defaults.
- * On unknown top-level keys: warns (potential typos).
- */
-
-import { readFileSync } from 'fs';
-import { logHookError } from './error-channel.mjs';
-
-// ---------------------------------------------------------------------------
-// Known top-level keys (anything else triggers a typo warning)
-// ---------------------------------------------------------------------------
-const KNOWN_TOP_LEVEL_KEYS = new Set([
-  'subscriptions',
-  'tiers',
-  'routing',
-  'routing_rules',
-  'quality_gate',
-  'pricing_verified',
-  'budgets',
-  'providers',
-  'dual_thinking',
-]);
-
-// ---------------------------------------------------------------------------
-// Sensible defaults for graceful degradation
-// ---------------------------------------------------------------------------
-const DEFAULT_CONFIG = {
-  subscriptions: {
-    claude: {
-      plan: '$100',
-      models: {
-        opus:   { tier: 'think',   name: 'opus',   provider: 'claude' },
-        sonnet: { tier: 'execute', name: 'sonnet', provider: 'claude' },
-        haiku:  { tier: 'search',  name: 'haiku',  provider: 'claude' },
-      },
-    },
-  },
-  tiers: {
-    search:  { description: 'Read-only lookups' },
-    execute: { description: 'Implementation and edits' },
-    think:   { description: 'Architecture and review' },
-  },
-  routing: {
-    strategy: 'hybrid-specialized-balanced',
-  },
-  quality_gate: {
-    enabled: true,
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Validation
-// ---------------------------------------------------------------------------
-
-/**
- * Validate an orchestrator config object.
- * Returns { valid, errors, warnings }.
- */
-export function validateConfig(config) {
-  const errors = [];
-  const warnings = [];
-
-  if (!config || typeof config !== 'object') {
-    errors.push('Config is not a valid object');
-    return { valid: false, errors, warnings };
-  }
-
-  // Required top-level keys
-  const requiredKeys = ['subscriptions', 'tiers', 'routing', 'quality_gate'];
-  for (const key of requiredKeys) {
-    if (!(key in config)) {
-      errors.push(`Missing required top-level key: "${key}"`);
-    }
-  }
-
-  // Unknown top-level keys (typo detection)
-  for (const key of Object.keys(config)) {
-    if (!KNOWN_TOP_LEVEL_KEYS.has(key)) {
-      warnings.push(`Unknown top-level key: "${key}" — possible typo?`);
-    }
-  }
-
-  // Validate subscriptions structure
-  if (config.subscriptions && typeof config.subscriptions === 'object') {
-    for (const [providerName, provider] of Object.entries(config.subscriptions)) {
-      if (!provider.models || typeof provider.models !== 'object') {
-        errors.push(`subscriptions.${providerName} missing "models" object`);
-        continue;
-      }
-      for (const [modelName, meta] of Object.entries(provider.models)) {
-        if (!meta.tier) {
-          errors.push(`subscriptions.${providerName}.models.${modelName} missing "tier"`);
-        }
-      }
-    }
-  }
-
-  // Validate tiers has search, execute, think
-  if (config.tiers && typeof config.tiers === 'object') {
-    for (const required of ['search', 'execute', 'think']) {
-      if (!(required in config.tiers)) {
-        errors.push(`tiers missing required tier: "${required}"`);
-      }
-    }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-  };
-}
-
-/**
- * Load orchestrator.json from disk, validate it, log issues, and return
- * either the parsed config or sensible defaults on failure.
- */
-export function loadAndValidateConfig(configPath) {
-  let config;
-  try {
-    config = JSON.parse(readFileSync(configPath, 'utf8'));
-  } catch (err) {
-    logHookError('config-validator', 'load', err, { configPath });
-    return { config: DEFAULT_CONFIG, validation: { valid: false, errors: [`Failed to parse config: ${err.message}`], warnings: [] } };
-  }
-
-  const validation = validateConfig(config);
-
-  // Log errors
-  for (const err of validation.errors) {
-    logHookError('config-validator', 'validate', new Error(err), { configPath });
-  }
-
-  // Log warnings to stderr (non-fatal)
-  for (const warn of validation.warnings) {
-    process.stderr.write(`[config-validator] WARNING: ${warn}\n`);
-  }
-
-  // If invalid, merge defaults for missing keys
-  if (!validation.valid) {
-    const merged = { ...DEFAULT_CONFIG, ...config };
-    if (!config.subscriptions) merged.subscriptions = DEFAULT_CONFIG.subscriptions;
-    if (!config.tiers) merged.tiers = DEFAULT_CONFIG.tiers;
-    if (!config.routing) merged.routing = DEFAULT_CONFIG.routing;
-    if (!config.quality_gate) merged.quality_gate = DEFAULT_CONFIG.quality_gate;
-    return { config: merged, validation };
-  }
-
-  return { config, validation };
-}

package/hooks/confirmation-policy.mjs

@@ -1,167 +0,0 @@
-#!/usr/bin/env node
-/**
- * confirmation-policy.mjs — Centralized confirmation policy for Ship Captain.
- *
- * Single source of truth for "should we prompt the user?"
- * Controls automation level based on risk level and user flags.
- *
- * Exports: getConfirmationPolicy, resolveMode, aggregateRisk, formatConfirmation
- */
-
-// Risk level ordering for comparison
-const RISK_ORDER = ['low', 'medium', 'high', 'critical'];
-
-// Steps that are mutations (vs. validation steps)
-const MUTATION_STEPS = new Set(['edit', 'pr', 'push']);
-// Steps that are validation (auto-run in careful mode too)
-const VALIDATION_STEPS = new Set(['test', 'gate']);
-// Heal step: a fix attempt — auto-runs unless in careful mode (where user confirms)
-const HEAL_STEPS = new Set(['heal']);
-
-/**
- * getConfirmationPolicy({ risk, mode, step })
- *
- * @param {object} options
- * @param {'low'|'medium'|'high'|'critical'} options.risk
- * @param {'default'|'yolo'|'careful'|'plan-only'} options.mode
- * @param {'plan'|'edit'|'test'|'gate'|'heal'|'pr'|'push'} options.step
- * @returns {{ shouldConfirm: boolean, shouldBlock: boolean, reason: string }}
- */
-export function getConfirmationPolicy({ risk, mode, step }) {
-  const safeMode = mode || 'default';
-  const safeRisk = risk || 'low';
-  const safeStep = step || 'plan';
-
-  // PLAN-ONLY mode: block all mutations, allow plan display; skip heal (no mutations)
-  if (safeMode === 'plan-only') {
-    if (safeStep === 'plan') {
-      return { shouldConfirm: false, shouldBlock: false, reason: 'Plan-only mode — showing plan' };
-    }
-    if (HEAL_STEPS.has(safeStep)) {
-      return {
-        shouldConfirm: false,
-        shouldBlock: true,
-        reason: 'Plan-only mode — skipping heal (no mutations)',
-      };
-    }
-    return {
-      shouldConfirm: false,
-      shouldBlock: true,
-      reason: 'Plan-only mode — no mutations',
-    };
-  }
-
-  // YOLO mode: no confirmations for any step at any risk level; auto-heal
-  if (safeMode === 'yolo') {
-    if (safeRisk === 'critical') {
-      return {
-        shouldConfirm: false,
-        shouldBlock: false,
-        reason: '⚠ YOLO mode on critical risk surface',
-      };
-    }
-    return { shouldConfirm: false, shouldBlock: false, reason: 'YOLO mode — proceeding automatically' };
-  }
-
-  // CAREFUL mode: confirm every mutation/plan step; validation steps auto-run;
-  //               heal step requires confirmation before each attempt
-  if (safeMode === 'careful') {
-    if (VALIDATION_STEPS.has(safeStep)) {
-      return { shouldConfirm: false, shouldBlock: false, reason: 'Validation step — auto-run' };
-    }
-    if (HEAL_STEPS.has(safeStep)) {
-      return {
-        shouldConfirm: true,
-        shouldBlock: false,
-        reason: 'Careful mode — confirming heal attempt',
-      };
-    }
-    return {
-      shouldConfirm: true,
-      shouldBlock: false,
-      reason: `Careful mode — confirming ${safeStep} step`,
-    };
-  }
-
-  // DEFAULT mode: risk-based policy
-  // Heal step: auto-heal for all risk levels — it's just a fix attempt, no worse than the original change
-  if (safeMode === 'default') {
-    if (HEAL_STEPS.has(safeStep)) {
-      return {
-        shouldConfirm: false,
-        shouldBlock: false,
-        reason: 'Heal step — auto-proceeding (fix attempt only)',
-      };
-    }
-    if (safeRisk === 'critical') {
-      return {
-        shouldConfirm: false,
-        shouldBlock: true,
-        reason: 'Critical risk requires --yolo flag',
-      };
-    }
-    if (safeRisk === 'high') {
-      if (safeStep === 'edit' || safeStep === 'pr') {
-        return {
-          shouldConfirm: true,
-          shouldBlock: false,
-          reason: `High-risk step requires confirmation before ${safeStep}`,
-        };
-      }
-      return { shouldConfirm: false, shouldBlock: false, reason: 'High risk — auto-proceeding for non-critical step' };
-    }
-    // low or medium: no confirmations
-    return { shouldConfirm: false, shouldBlock: false, reason: 'Low/medium risk — proceeding automatically' };
-  }
-
-  // Fallback: treat unknown modes as default/no-confirm
-  return { shouldConfirm: false, shouldBlock: false, reason: 'Unknown mode — proceeding automatically' };
-}
-
-/**
- * resolveMode(argv) — Parse CLI flags into a mode string.
- *
- * @param {string[]} argv  Process argv array (e.g. process.argv)
- * @returns {'default'|'yolo'|'careful'|'plan-only'}
- */
-export function resolveMode(argv) {
-  const args = argv || [];
-  if (args.includes('--yolo')) return 'yolo';
-  if (args.includes('--careful')) return 'careful';
-  if (args.includes('--plan-only') || args.includes('--dry-run')) return 'plan-only';
-  return 'default';
-}
-
-/**
- * aggregateRisk(risks) — Return the highest risk level from an array.
- *
- * @param {string[]} risks  Array of risk strings
- * @returns {'low'|'medium'|'high'|'critical'}
- */
-export function aggregateRisk(risks) {
-  if (!Array.isArray(risks) || risks.length === 0) return 'low';
-  let maxIndex = 0;
-  for (const r of risks) {
-    const idx = RISK_ORDER.indexOf(r);
-    if (idx > maxIndex) maxIndex = idx;
-  }
-  return RISK_ORDER[maxIndex];
-}
-
-/**
- * formatConfirmation(step, risk, reason) — Format a human-readable confirmation prompt.
- *
- * @param {string} step
- * @param {string} risk
- * @param {string} reason
- * @returns {string}
- */
-export function formatConfirmation(step, risk, reason) {
-  if (risk === 'critical') {
-    return `\u{1F534} Critical risk detected: ${reason}. This requires explicit approval. Continue? [Y/n]`;
-  }
-  if (risk === 'high') {
-    return `⚠ High-risk step: ${reason}. Continue? [Y/n]`;
-  }
-  return `\u{2139} ${reason} (step: ${step}). Continue? [Y/n]`;
-}

package/hooks/error-channel.mjs

@@ -1,68 +0,0 @@
-/**
- * error-channel.mjs — Lightweight error logger for dual-brain hooks.
- *
- * Exports:
- *   logHookError(hookName, operation, error, context?)  → append to errors.jsonl
- *   getRecentErrors(hours?)                             → array of recent error entries
- */
-
-import { appendFileSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ERROR_FILE = join(__dirname, 'errors.jsonl');
-
-const PRUNE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
-const PRUNE_INTERVAL_MS = 60 * 1000; // 1 minute
-let lastPruneCheck = 0;
-
-function maybePrune() {
-  const now = Date.now();
-  if (now - lastPruneCheck < PRUNE_INTERVAL_MS) return;
-  lastPruneCheck = now;
-
-  try {
-    const raw = readFileSync(ERROR_FILE, 'utf8');
-    const cutoff = now - PRUNE_MAX_AGE_MS;
-    const kept = raw.split('\n').filter(line => {
-      if (!line) return false;
-      try {
-        const entry = JSON.parse(line);
-        return Date.parse(entry.timestamp) >= cutoff;
-      } catch { return true; } // keep unparseable lines
-    });
-    writeFileSync(ERROR_FILE, kept.length > 0 ? kept.join('\n') + '\n' : '');
-  } catch {
-    // File doesn't exist or can't be read — nothing to prune
-  }
-}
-
-export function logHookError(hookName, operation, error, context = {}) {
-  const entry = JSON.stringify({
-    timestamp: new Date().toISOString(),
-    hook: hookName,
-    operation,
-    error: error?.message || String(error),
-    stack: error?.stack || null,
-    context,
-  });
-  try {
-    appendFileSync(ERROR_FILE, entry + '\n');
-  } catch {
-    // Last resort — can't even log. Silently drop.
-  }
-  maybePrune();
-}
-
-export function getRecentErrors(hours = 24) {
-  const cutoff = Date.now() - hours * 60 * 60 * 1000;
-  try {
-    const raw = readFileSync(ERROR_FILE, 'utf8');
-    return raw.split('\n').filter(Boolean).map(line => {
-      try { return JSON.parse(line); } catch { return null; }
-    }).filter(e => e && Date.parse(e.timestamp) >= cutoff);
-  } catch {
-    return [];
-  }
-}