brain-dev 0.1.0

package/bin/lib/config.cjs

@@ -0,0 +1,452 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { readState, writeState, atomicWriteSync } = require('./state.cjs');
+
+// ─── Constants ──────────────────────────────────────────────────────────────
+
+const CATEGORIES = ['Workflow', 'Models', 'Enforcement', 'Monitoring', 'Complexity', 'Storm', 'ADR'];
+
+const SCHEMA = {
+  'mode': { type: 'enum', values: ['interactive', 'yolo'], default: 'interactive', category: 'Workflow', description: 'Execution mode preset (sets multiple flags)' },
+  'depth': { type: 'enum', values: ['shallow', 'standard', 'deep'], default: 'deep', category: 'Workflow', description: 'Verification depth (shallow=L1, standard=L1+L2, deep=L1+L2+L3)' },
+  'workflow.parallelization': { type: 'boolean', default: false, category: 'Workflow', description: 'Enable parallel wave execution' },
+  'workflow.mapper_parallelization': { type: 'boolean', default: true, category: 'Workflow', description: 'Enable parallel codebase mapping' },
+  'workflow.advocate': { type: 'boolean', default: true, category: 'Workflow', description: "Enable Devil's Advocate on plans" },
+  'workflow.auto_recover': { type: 'boolean', default: false, category: 'Workflow', description: 'Auto-recovery on verification failure' },
+  'agents.model': { type: 'string', default: 'inherit', category: 'Models', description: 'Default model for all agents' },
+  'agents.profile': { type: 'enum', values: ['quality', 'balanced', 'budget'], default: 'quality', category: 'Models', description: 'Active model profile preset' },
+  'enforcement.level': { type: 'enum', values: ['hard', 'balanced', 'soft'], default: 'hard', category: 'Enforcement', description: 'Skill enforcement strictness' },
+  'enforcement.business_paths': { type: 'string[]', default: ['commands/*.cjs', 'lib/*.cjs'], category: 'Enforcement', description: 'Glob patterns for business logic paths (TDD mandatory in balanced)', local: true },
+  'enforcement.non_business_paths': { type: 'string[]', default: ['templates/*.md', 'SKILL.md', 'hooks/*.sh', '.planning/**', '*.json'], category: 'Enforcement', description: 'Glob patterns for non-business paths (TDD optional in balanced)', local: true },
+  'monitoring.enabled': { type: 'boolean', default: true, category: 'Monitoring', description: 'Enable context monitoring' },
+  'monitoring.warning_threshold': { type: 'number', default: 35, min: 10, max: 50, category: 'Monitoring', description: 'Context warning threshold (%)' },
+  'monitoring.critical_threshold': { type: 'number', default: 25, min: 5, max: 40, category: 'Monitoring', description: 'Context critical threshold (%)' },
+  'complexity.default_budget': { type: 'number', default: 60, min: 20, max: 100, category: 'Complexity', description: 'Default complexity budget score' },
+  'storm.port': { type: 'number', default: 3456, min: 1024, max: 65535, category: 'Storm', description: 'Brainstorm server port', local: true },
+  'storm.auto_open': { type: 'boolean', default: true, category: 'Storm', description: 'Auto-open browser on storm start', local: true },
+  'adr.auto_create': { type: 'boolean', default: true, category: 'ADR', description: 'Auto-create ADRs for significant decisions' },
+  'adr.status_lifecycle': { type: 'boolean', default: true, category: 'ADR', description: 'Enable ADR status transitions' },
+};
+
+const PROFILES = {
+  quality: {
+    description: 'All agents use highest quality model',
+    models: {}
+  },
+  balanced: {
+    description: 'Quality for planning, efficient for checking',
+    models: {
+      'plan-checker': 'claude-sonnet-4-20250514',
+      verifier: 'claude-sonnet-4-20250514',
+      researcher: 'claude-sonnet-4-20250514'
+    }
+  },
+  budget: {
+    description: 'Minimize token cost',
+    models: {
+      executor: 'claude-sonnet-4-20250514',
+      researcher: 'claude-haiku-4-20250514',
+      'plan-checker': 'claude-haiku-4-20250514',
+      verifier: 'claude-haiku-4-20250514',
+      debugger: 'claude-haiku-4-20250514',
+      mapper: 'claude-haiku-4-20250514'
+    }
+  }
+};
+
+const MODE_PRESETS = {
+  yolo: {
+    'workflow.advocate': false,
+    'workflow.auto_recover': true,
+    'workflow.parallelization': true,
+    'enforcement.level': 'soft'
+  },
+  interactive: {
+    'workflow.advocate': true,
+    'workflow.auto_recover': false,
+    'workflow.parallelization': false,
+    'enforcement.level': 'hard'
+  }
+};
+
+const ENFORCEMENT_GRADUATED = {
+  scaffolding: { hard: 'balanced', balanced: 'soft', soft: 'soft' },
+  standard: { hard: 'hard', balanced: 'balanced', soft: 'soft' },
+  production: { soft: 'balanced', balanced: 'hard', hard: 'hard' }
+};
+
+const LOCAL_FIELDS = ['storm.port', 'storm.auto_open', 'enforcement.business_paths', 'enforcement.non_business_paths'];
+
+// ─── Utility Functions ──────────────────────────────────────────────────────
+
+function getNestedValue(obj, dotPath) {
+  return dotPath.split('.').reduce((o, k) => (o != null ? o[k] : undefined), obj);
+}
+
+function setNestedValue(obj, dotPath, value) {
+  const result = deepMerge({}, obj);
+  const keys = dotPath.split('.');
+  const last = keys.pop();
+  let parent = result;
+  for (const k of keys) {
+    if (!parent[k] || typeof parent[k] !== 'object') parent[k] = {};
+    parent = parent[k];
+  }
+  parent[last] = value;
+  return result;
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (
+      source[key] && typeof source[key] === 'object' && !Array.isArray(source[key]) &&
+      result[key] && typeof result[key] === 'object' && !Array.isArray(result[key])
+    ) {
+      result[key] = deepMerge(result[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, (_, i) => {
+    const row = new Array(n + 1);
+    row[0] = i;
+    return row;
+  });
+  for (let j = 1; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1]
+        ? dp[i - 1][j - 1]
+        : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+
+function suggestKey(input, schemaKeys) {
+  let best = null, bestDist = Infinity;
+  for (const key of schemaKeys) {
+    const d = levenshtein(input.toLowerCase(), key.toLowerCase());
+    if (d < bestDist && d <= 3) { best = key; bestDist = d; }
+  }
+  return best;
+}
+
+function coerceValue(value, schemaEntry) {
+  if (value === undefined || value === null) return value;
+
+  switch (schemaEntry.type) {
+    case 'boolean':
+      if (typeof value === 'string') {
+        if (value === 'true') return true;
+        if (value === 'false') return false;
+      }
+      return value;
+    case 'number':
+      if (typeof value === 'string') {
+        const n = parseInt(value, 10);
+        if (!isNaN(n)) return n;
+      }
+      return value;
+    case 'string[]':
+      if (typeof value === 'string') {
+        return value.split(',').map(s => s.trim());
+      }
+      return value;
+    default:
+      return value;
+  }
+}
+
+// ─── Global Defaults Path ───────────────────────────────────────────────────
+
+function getGlobalDefaultsPath() {
+  return path.join(os.homedir(), '.brain', 'defaults.json');
+}
+
+function readGlobalDefaults() {
+  const p = getGlobalDefaultsPath();
+  if (!fs.existsSync(p)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeGlobalDefaults(data) {
+  const dir = path.dirname(getGlobalDefaultsPath());
+  fs.mkdirSync(dir, { recursive: true });
+  atomicWriteSync(getGlobalDefaultsPath(), JSON.stringify(data, null, 2));
+}
+
+// ─── Core Operations ────────────────────────────────────────────────────────
+
+function validateConfig(key, value) {
+  const schemaKeys = Object.keys(SCHEMA);
+
+  if (!SCHEMA[key]) {
+    const suggestion = suggestKey(key, schemaKeys);
+    return {
+      valid: false,
+      error: `Unknown config key: "${key}"`,
+      suggestion: suggestion || undefined
+    };
+  }
+
+  const entry = SCHEMA[key];
+  const coerced = coerceValue(value, entry);
+
+  switch (entry.type) {
+    case 'boolean':
+      if (typeof coerced !== 'boolean') {
+        return { valid: false, error: `"${key}" expects boolean (true/false), got: ${typeof value}` };
+      }
+      break;
+    case 'enum':
+      if (!entry.values.includes(coerced)) {
+        return { valid: false, error: `"${key}" must be one of: ${entry.values.join(', ')}. Got: "${coerced}"` };
+      }
+      break;
+    case 'number':
+      if (typeof coerced !== 'number' || isNaN(coerced)) {
+        return { valid: false, error: `"${key}" expects a number, got: "${value}"` };
+      }
+      if (entry.min !== undefined && coerced < entry.min) {
+        return { valid: false, error: `"${key}" minimum is ${entry.min}, got: ${coerced}` };
+      }
+      if (entry.max !== undefined && coerced > entry.max) {
+        return { valid: false, error: `"${key}" maximum is ${entry.max}, got: ${coerced}` };
+      }
+      break;
+    case 'string':
+      // Strings are always valid
+      break;
+    case 'string[]':
+      if (!Array.isArray(coerced)) {
+        return { valid: false, error: `"${key}" expects an array of strings` };
+      }
+      break;
+  }
+
+  return { valid: true };
+}
+
+function getConfig(brainDir, key, opts = {}) {
+  if (opts.global) {
+    const defaults = readGlobalDefaults();
+    if (!key) return defaults;
+    return getNestedValue(defaults, key) ?? defaults[key];
+  }
+
+  const state = readState(brainDir);
+  if (!state) return undefined;
+
+  if (!key) return state;
+
+  // Try dot-path on the state object
+  return getNestedValue(state, key);
+}
+
+function setConfig(brainDir, key, value, opts = {}) {
+  // Check if key is 'mode' -- apply preset
+  if (key === 'mode' && MODE_PRESETS[value]) {
+    const state = readState(brainDir);
+    if (!state) throw new Error('No brain.json found');
+
+    let updated = state;
+    updated.mode = value;
+    for (const [presetKey, presetVal] of Object.entries(MODE_PRESETS[value])) {
+      updated = setNestedValue(updated, presetKey, presetVal);
+    }
+
+    if (opts.global) {
+      writeGlobalDefaults(updated);
+    } else {
+      writeState(brainDir, updated);
+    }
+    return;
+  }
+
+  // Validate key
+  const validation = validateConfig(key, value);
+  if (!validation.valid) {
+    let msg = validation.error;
+    if (validation.suggestion) {
+      msg += `. Did you mean: "${validation.suggestion}"?`;
+    }
+    throw new Error(msg);
+  }
+
+  const entry = SCHEMA[key];
+  const coerced = coerceValue(value, entry);
+
+  if (opts.global) {
+    const defaults = readGlobalDefaults();
+    const updated = { ...defaults, [key]: coerced };
+    writeGlobalDefaults(updated);
+    return;
+  }
+
+  const state = readState(brainDir);
+  if (!state) throw new Error('No brain.json found');
+
+  const updated = setNestedValue(state, key, coerced);
+  writeState(brainDir, updated);
+}
+
+function listConfig(brainDir, opts = {}) {
+  const state = readState(brainDir);
+  const result = {};
+
+  for (const [key, entry] of Object.entries(SCHEMA)) {
+    if (opts.category && entry.category !== opts.category) continue;
+
+    if (!result[entry.category]) result[entry.category] = [];
+
+    const value = state ? getNestedValue(state, key) : entry.default;
+
+    result[entry.category].push({
+      key,
+      value: value !== undefined ? value : entry.default,
+      default: entry.default,
+      description: entry.description
+    });
+  }
+
+  return result;
+}
+
+function resetConfig(brainDir, keyOrOpts) {
+  const state = readState(brainDir);
+  if (!state) throw new Error('No brain.json found');
+
+  let updated = state;
+
+  if (typeof keyOrOpts === 'string') {
+    // Reset single key
+    const entry = SCHEMA[keyOrOpts];
+    if (!entry) throw new Error(`Unknown config key: "${keyOrOpts}"`);
+    updated = setNestedValue(updated, keyOrOpts, entry.default);
+  } else if (keyOrOpts && keyOrOpts.category) {
+    // Reset all keys in category
+    for (const [key, entry] of Object.entries(SCHEMA)) {
+      if (entry.category === keyOrOpts.category) {
+        updated = setNestedValue(updated, key, entry.default);
+      }
+    }
+  } else {
+    // Reset all keys
+    for (const [key, entry] of Object.entries(SCHEMA)) {
+      updated = setNestedValue(updated, key, entry.default);
+    }
+  }
+
+  writeState(brainDir, updated);
+}
+
+function exportConfig(brainDir) {
+  const state = readState(brainDir);
+  if (!state) throw new Error('No brain.json found');
+
+  const exported = {};
+  for (const [key, entry] of Object.entries(SCHEMA)) {
+    if (LOCAL_FIELDS.includes(key)) continue;
+    const value = getNestedValue(state, key);
+    if (value !== undefined) {
+      exported[key] = value;
+    }
+  }
+
+  return JSON.stringify(exported, null, 2);
+}
+
+function importConfig(brainDir, jsonString) {
+  const data = JSON.parse(jsonString);
+  let imported = 0;
+  const skipped = [];
+
+  for (const [key, value] of Object.entries(data)) {
+    const validation = validateConfig(key, value);
+    if (!validation.valid) {
+      skipped.push({ key, reason: validation.error });
+      continue;
+    }
+
+    try {
+      setConfig(brainDir, key, value);
+      imported++;
+    } catch (err) {
+      skipped.push({ key, reason: err.message });
+    }
+  }
+
+  return { imported, skipped };
+}
+
+function mergeWithDefaults(brainDir) {
+  // Level 1: built-in defaults from SCHEMA
+  const builtIn = {};
+  for (const [key, entry] of Object.entries(SCHEMA)) {
+    builtIn[key] = entry.default;
+  }
+
+  // Level 2: global defaults from ~/.brain/defaults.json
+  const global = readGlobalDefaults();
+
+  // Level 3: project config from brain.json (flat keys extracted from nested state)
+  const state = readState(brainDir);
+  const project = {};
+  if (state) {
+    for (const key of Object.keys(SCHEMA)) {
+      const val = getNestedValue(state, key);
+      if (val !== undefined) {
+        project[key] = val;
+      }
+    }
+  }
+
+  // Merge: built-in -> global -> project
+  return deepMerge(deepMerge(builtIn, global), project);
+}
+
+function getEffectiveEnforcement(configLevel, phaseType) {
+  const table = ENFORCEMENT_GRADUATED[phaseType] || ENFORCEMENT_GRADUATED.standard;
+  return table[configLevel] || configLevel;
+}
+
+function getSchema() {
+  return SCHEMA;
+}
+
+// ─── Module Exports ─────────────────────────────────────────────────────────
+
+module.exports = {
+  CATEGORIES,
+  SCHEMA,
+  PROFILES,
+  MODE_PRESETS,
+  ENFORCEMENT_GRADUATED,
+  LOCAL_FIELDS,
+  getConfig,
+  setConfig,
+  listConfig,
+  resetConfig,
+  validateConfig,
+  exportConfig,
+  importConfig,
+  mergeWithDefaults,
+  deepMerge,
+  suggestKey,
+  getEffectiveEnforcement,
+  getSchema
+};

package/bin/lib/core.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+const { styleText } = require('node:util');
+
+const isTTY = !!process.stdout.isTTY;
+
+/**
+ * Output data in appropriate format for the current terminal.
+ * TTY: human-readable text. Pipe/non-TTY: JSON.
+ * @param {*} data - Structured data to output
+ * @param {string} [humanFormat] - Human-readable string for TTY output
+ */
+function output(data, humanFormat) {
+  if (isTTY) {
+    console.log(humanFormat || formatHuman(data));
+  } else {
+    console.log(JSON.stringify(data));
+  }
+}
+
+/**
+ * Default human formatting for data objects.
+ * @param {*} data
+ * @returns {string}
+ */
+function formatHuman(data) {
+  if (typeof data === 'string') return data;
+  return Object.entries(data)
+    .map(([k, v]) => `${k}: ${v}`)
+    .join('\n');
+}
+
+/**
+ * Prefix a message with the [brain] tag.
+ * Uses cyan coloring on TTY.
+ * @param {string} msg
+ * @returns {string}
+ */
+function prefix(msg) {
+  const tag = isTTY ? styleText('cyan', '[brain]') : '[brain]';
+  return `${tag} ${msg}`;
+}
+
+/**
+ * Write an error message to stderr with red [brain] prefix.
+ * @param {string} msg
+ */
+function error(msg) {
+  const tag = isTTY ? styleText('red', '[brain]') : '[brain]';
+  console.error(`${tag} ${msg}`);
+}
+
+/**
+ * Write a success message to stdout with green [brain] prefix.
+ * @param {string} msg
+ */
+function success(msg) {
+  const tag = isTTY ? styleText('green', '[brain]') : '[brain]';
+  console.log(`${tag} ${msg}`);
+}
+
+module.exports = { isTTY, output, prefix, error, success };