dual-brain 0.2.30 → 0.3.0

package/src/inbox.mjs

@@ -1,195 +0,0 @@
-/**
- * inbox.mjs — Cross-session signal system for dual-brain orchestrator
- *
- * Agents write messages to .dualbrain/inbox/. HEAD and the cognitive loop
- * check the inbox at entry points. Messages have TTL and recipient types.
- */
-
-import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { randomUUID } from 'node:crypto';
-
-const INBOX_DIR = join(process.cwd(), '.dualbrain', 'inbox');
-const INDEX_PATH = join(INBOX_DIR, '_index.json');
-const DEFAULT_TTL = 24 * 60 * 60 * 1000; // 24h
-const MAX_ACTIVE = 50;
-const PRIORITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
-
-function ensureDir() {
-  if (!existsSync(INBOX_DIR)) mkdirSync(INBOX_DIR, { recursive: true });
-}
-
-function readIndex() {
-  try {
-    if (existsSync(INDEX_PATH)) return JSON.parse(readFileSync(INDEX_PATH, 'utf8'));
-  } catch { /* rebuild */ }
-  return rebuildIndex();
-}
-
-function rebuildIndex() {
-  ensureDir();
-  const entries = [];
-  for (const f of readdirSync(INBOX_DIR)) {
-    if (f === '_index.json' || !f.endsWith('.json')) continue;
-    try {
-      const msg = JSON.parse(readFileSync(join(INBOX_DIR, f), 'utf8'));
-      entries.push({ id: msg.id, to: msg.to, type: msg.type, priority: msg.priority, createdAt: msg.createdAt, expired: Date.now() > msg.createdAt + msg.ttl });
-    } catch { /* skip corrupt */ }
-  }
-  writeFileSync(INDEX_PATH, JSON.stringify(entries, null, 2));
-  return entries;
-}
-
-function writeIndex(entries) {
-  ensureDir();
-  writeFileSync(INDEX_PATH, JSON.stringify(entries, null, 2));
-}
-
-function readMessage(id) {
-  try {
-    return JSON.parse(readFileSync(join(INBOX_DIR, `${id}.json`), 'utf8'));
-  } catch { return null; }
-}
-
-function matchesRecipient(msgTo, recipient) {
-  if (msgTo === 'all' || msgTo === recipient) return true;
-  if (msgTo === 'worker:*' && recipient.startsWith('worker:')) return true;
-  return false;
-}
-
-/** Write a message to the inbox. */
-export function send(partial) {
-  if (!partial.to || !partial.type || !partial.subject || !partial.body) {
-    throw new Error('inbox.send requires: to, type, subject, body');
-  }
-  ensureDir();
-  const msg = {
-    id: randomUUID(),
-    from: partial.from || 'system',
-    to: partial.to,
-    type: partial.type,
-    priority: partial.priority || 'medium',
-    subject: partial.subject,
-    body: partial.body,
-    ttl: partial.ttl ?? DEFAULT_TTL,
-    createdAt: Date.now(),
-    readBy: partial.readBy || [],
-    relatedFiles: partial.relatedFiles || [],
-    tags: partial.tags || [],
-  };
-  // Enforce cap — purge oldest if over limit
-  const index = readIndex();
-  const active = index.filter(e => !e.expired);
-  if (active.length >= MAX_ACTIVE) {
-    const sorted = [...active].sort((a, b) => a.createdAt - b.createdAt);
-    const toRemove = sorted.slice(0, active.length - MAX_ACTIVE + 1);
-    for (const e of toRemove) {
-      try { unlinkSync(join(INBOX_DIR, `${e.id}.json`)); } catch { /* ok */ }
-    }
-    const removeIds = new Set(toRemove.map(e => e.id));
-    const trimmed = index.filter(e => !removeIds.has(e.id));
-    trimmed.push({ id: msg.id, to: msg.to, type: msg.type, priority: msg.priority, createdAt: msg.createdAt, expired: false });
-    writeIndex(trimmed);
-  } else {
-    index.push({ id: msg.id, to: msg.to, type: msg.type, priority: msg.priority, createdAt: msg.createdAt, expired: false });
-    writeIndex(index);
-  }
-  writeFileSync(join(INBOX_DIR, `${msg.id}.json`), JSON.stringify(msg, null, 2));
-  return msg;
-}
-
-/** Read messages for a recipient. */
-export function check(recipient, options = {}) {
-  const { unreadOnly = false, types, minPriority, limit } = options;
-  const index = readIndex();
-  const now = Date.now();
-  const minP = minPriority ? PRIORITY_ORDER[minPriority] ?? 3 : 3;
-  let results = [];
-  for (const entry of index) {
-    if (now > entry.createdAt + DEFAULT_TTL) continue; // rough TTL check
-    if (!matchesRecipient(entry.to, recipient)) continue;
-    if (types && !types.includes(entry.type)) continue;
-    if ((PRIORITY_ORDER[entry.priority] ?? 3) > minP) continue;
-    const msg = readMessage(entry.id);
-    if (!msg) continue;
-    if (now > msg.createdAt + msg.ttl) continue; // precise TTL
-    if (unreadOnly && msg.readBy.includes(recipient)) continue;
-    results.push(msg);
-  }
-  results.sort((a, b) => (PRIORITY_ORDER[a.priority] ?? 3) - (PRIORITY_ORDER[b.priority] ?? 3) || b.createdAt - a.createdAt);
-  if (limit) results = results.slice(0, limit);
-  return results;
-}
-
-/** Mark a message as read by a specific reader. */
-export function markRead(messageId, reader) {
-  const path = join(INBOX_DIR, `${messageId}.json`);
-  const msg = readMessage(messageId);
-  if (!msg) return;
-  if (!msg.readBy.includes(reader)) {
-    msg.readBy.push(reader);
-    writeFileSync(path, JSON.stringify(msg, null, 2));
-  }
-}
-
-/** Clean up expired and fully-read messages. */
-export function purge(options = {}) {
-  const { purgeRead = false } = options;
-  const index = readIndex();
-  const now = Date.now();
-  let expired = 0, read = 0;
-  const keep = [];
-  for (const entry of index) {
-    const msg = readMessage(entry.id);
-    if (!msg) continue;
-    if (now > msg.createdAt + msg.ttl) {
-      try { unlinkSync(join(INBOX_DIR, `${entry.id}.json`)); } catch { /* ok */ }
-      expired++;
-      continue;
-    }
-    if (purgeRead && msg.readBy.length > 0 && msg.to !== 'all') {
-      try { unlinkSync(join(INBOX_DIR, `${entry.id}.json`)); } catch { /* ok */ }
-      read++;
-      continue;
-    }
-    keep.push(entry);
-  }
-  writeIndex(keep);
-  return { expired, read };
-}
-
-/** Produce a concise text summary for prompt injection. */
-export function generateInboxBrief(recipient) {
-  const msgs = check(recipient, { unreadOnly: true, limit: 5 });
-  if (!msgs.length) return '';
-  const lines = [`\u{1F4EC} Inbox (${msgs.length} unread):`];
-  let len = lines[0].length;
-  for (const m of msgs) {
-    const line = `• [${m.priority}] ${m.from !== 'system' ? `From ${m.from}: ` : ''}${m.subject}`;
-    if (len + line.length > 480) { lines.push('• ...'); break; }
-    lines.push(line);
-    len += line.length;
-  }
-  return lines.join('\n');
-}
-
-/** Convenience: send a continuation message when session ends. */
-export function sendContinuation(context) {
-  return send({
-    from: context.from || 'head',
-    to: 'session:next',
-    type: 'continuation',
-    priority: 'high',
-    subject: context.subject || 'Session continuation state',
-    body: typeof context.body === 'string' ? context.body : JSON.stringify(context.state || context, null, 2),
-    relatedFiles: context.relatedFiles || [],
-    tags: ['continuation', ...(context.tags || [])],
-    ttl: context.ttl ?? DEFAULT_TTL * 3, // 72h for continuations
-  });
-}
-
-/** Convenience: check for the most recent unread continuation. */
-export function checkContinuation(reader = 'head') {
-  const msgs = check('session:next', { unreadOnly: true, types: ['continuation'], limit: 1 });
-  return msgs.length ? msgs[0] : null;
-}

package/src/index.mjs

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-/**
- * index.mjs — Main entry point for the dual-brain package.
- *
- * Re-exports all public APIs from the four core modules, plus a top-level
- * orchestrate() convenience function for programmatic use.
- */
-
-export { loadProfile, saveProfile, ensureProfile, runOnboarding, rememberPreference, forgetPreference, getActivePreferences, getAvailableProviders, isSoloBrain, getHeadModel, detectAuth, detectEnvironment, saveSubscription, listSubscriptions, autoRefreshToken } from './profile.mjs';
-export { detectTask, classifyIntent, classifyRisk, estimateComplexity, inferTier, extractPaths } from './detect.mjs';
-export { decideRoute, getModelCapabilities, getAvailableModels, shouldDualBrain, explainDecision } from './decide.mjs';
-export { dispatch, buildCommand, detectRuntime, compressResult, dispatchDualBrain } from './dispatch.mjs';
-export { loadPlaybook, listPlaybooks, executePlaybook, createRunArtifact } from './playbook.mjs';
-export { getHealth, markHot, markDegraded, markHealthy, checkCooldown, getProviderScore, recordDispatch, getSessionStats, resetHealth, remainingCooldownMinutes } from './health.mjs';
-export { detectRepo, loadRepoCache, getTestCommand, getLintCommand } from './repo.mjs';
-export { loadSession, saveSession, updateSession, clearSession, formatSessionCard, importReplitSessions, renameSession, pinSession, unpinSession, categorizeSession, getSessionMeta, autoLabel, enrichSessions, ensurePersistence, syncSessionMirror, buildSessionIndex, searchSessions, getSessionContext, extractSessionMeta, getRoutingContext } from './session.mjs';
-export { decompose, isSimpleTask, taskGraphToWaves } from './decompose.mjs';
-export { generateBrief, compressPriorResults, listRoles } from './brief.mjs';
-export { redact, redactFiles, isSecretFile } from './redact.mjs';
-export { isInsideClaude, buildNativeDispatch, normalizeResult } from './dispatch.mjs';
-export { box, bar, badge, menu, separator } from './tui.mjs';
-
-// Top-level convenience function
-export async function orchestrate({ prompt, files, cwd, dryRun }) {
-  // Import dynamically to avoid circular issues
-  const { ensureProfile } = await import('./profile.mjs');
-  const { detectTask } = await import('./detect.mjs');
-  const { decideRoute } = await import('./decide.mjs');
-  const { dispatch: run, dispatchDualBrain } = await import('./dispatch.mjs');
-
-  const profile = await ensureProfile(cwd || process.cwd(), { interactive: false });
-  const detection = detectTask({ prompt, files });
-  const decision = decideRoute({ profile, detection, cwd: cwd || process.cwd() });
-
-  if (dryRun) {
-    return { profile, detection, decision, result: null };
-  }
-
-  const result = decision.dualBrain
-    ? await dispatchDualBrain({ decision, prompt, files, cwd: cwd || process.cwd() })
-    : await run({ decision, prompt, files, cwd: cwd || process.cwd() });
-
-  return { profile, detection, decision, result };
-}

package/src/install-hooks.mjs

@@ -1,100 +0,0 @@
-/**
- * install-hooks.mjs — Merge dual-brain PreToolUse hooks into .claude/settings.json.
- *
- * Exported function: installHooks(cwd)
- * Returns: { installed: string[], skipped: string[] }
- */
-
-import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname  = dirname(__filename);
-const PKG_ROOT   = join(__dirname, '..');
-
-// The hook commands we want present in .claude/settings.json PreToolUse
-const HEAD_GUARD_CMD   = 'node .claude/hooks/head-guard.mjs';
-const ENFORCE_TIER_CMD = 'node .claude/hooks/enforce-tier.mjs';
-
-const DESIRED_HOOKS = [
-  { matcher: 'Edit',         command: HEAD_GUARD_CMD },
-  { matcher: 'Write',        command: HEAD_GUARD_CMD },
-  { matcher: 'NotebookEdit', command: HEAD_GUARD_CMD },
-  { matcher: 'Bash',         command: HEAD_GUARD_CMD },
-  { matcher: 'Agent',        command: ENFORCE_TIER_CMD },
-];
-
-/**
- * Install dual-brain enforcement hooks into a project's .claude/settings.json.
- *
- * @param {string} cwd - Project root directory (where .claude/ should live)
- * @returns {{ installed: string[], skipped: string[] }}
- */
-export function installHooks(cwd) {
-  const claudeDir    = join(cwd, '.claude');
-  const hooksDir     = join(claudeDir, 'hooks');
-  const settingsPath = join(claudeDir, 'settings.json');
-
-  const installed = [];
-  const skipped   = [];
-
-  // Ensure directories exist
-  mkdirSync(hooksDir, { recursive: true });
-
-  // Copy hook files from package into project's .claude/hooks/
-  const filesToCopy = [
-    { name: 'head-guard.mjs',   exec: true },
-    { name: 'enforce-tier.mjs', exec: false },
-  ];
-
-  for (const { name, exec } of filesToCopy) {
-    const src = join(PKG_ROOT, 'hooks', name);
-    const dst = join(hooksDir, name);
-    if (existsSync(src)) {
-      cpSync(src, dst);
-      if (exec) {
-        try { chmodSync(dst, 0o755); } catch {}
-      }
-      installed.push(`hooks/${name}`);
-    }
-  }
-
-  // Read existing settings (or start fresh)
-  let settings = {};
-  try {
-    settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
-  } catch {
-    // File doesn't exist or is malformed — start empty
-  }
-
-  // Ensure hooks.PreToolUse array exists
-  if (!settings.hooks) settings.hooks = {};
-  if (!Array.isArray(settings.hooks.PreToolUse)) settings.hooks.PreToolUse = [];
-
-  const preToolUse = settings.hooks.PreToolUse;
-
-  // Merge: for each desired hook, add only if command is not already registered for that matcher
-  for (const { matcher, command } of DESIRED_HOOKS) {
-    const alreadyPresent = preToolUse.some(entry =>
-      entry.matcher === matcher &&
-      Array.isArray(entry.hooks) &&
-      entry.hooks.some(h => h.command === command)
-    );
-
-    if (alreadyPresent) {
-      skipped.push(`PreToolUse[${matcher}]`);
-    } else {
-      preToolUse.push({
-        matcher,
-        hooks: [{ type: 'command', command }],
-      });
-      installed.push(`PreToolUse[${matcher}]`);
-    }
-  }
-
-  // Write back merged settings
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-
-  return { installed, skipped };
-}

package/src/integrity.mjs

@@ -1,245 +0,0 @@
-/**
- * integrity.mjs — State integrity primitives for dual-brain
- *
- * Provides:
- *   - atomicWriteJson / readJsonSafe   — safe JSON file I/O with schema versioning
- *   - acquireLock / releaseLock / withLock — advisory file locks
- *   - lockedUpdate                      — locked atomic read-modify-write
- *   - atomicAppend                      — append-only ledger with lock
- */
-
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-
-// ---------------------------------------------------------------------------
-// 1. Atomic JSON writes
-// ---------------------------------------------------------------------------
-
-/**
- * Write JSON to filePath atomically via a temp file + rename.
- * Adds _schemaVersion and _writtenAt to plain objects.
- *
- * @param {string} filePath  - Destination file path
- * @param {*}      data      - Value to serialize
- * @param {object} opts
- * @param {number} [opts.schemaVersion=1] - Schema version stamped into data
- * @param {boolean}[opts.backup=false]    - Keep a .bak copy of the previous file
- */
-export function atomicWriteJson(filePath, data, opts = {}) {
-  const { schemaVersion = 1, backup = false } = opts;
-
-  // Stamp schema version onto plain objects
-  if (data && typeof data === 'object' && !Array.isArray(data)) {
-    data._schemaVersion = schemaVersion;
-    data._writtenAt = new Date().toISOString();
-  }
-
-  const dir = dirname(filePath);
-  mkdirSync(dir, { recursive: true });
-
-  const tmpPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
-  const json = JSON.stringify(data, null, 2) + '\n';
-
-  // Write to temp file
-  writeFileSync(tmpPath, json);
-
-  // Validate the temp file is parseable before committing
-  try {
-    JSON.parse(readFileSync(tmpPath, 'utf8'));
-  } catch (err) {
-    unlinkSync(tmpPath);
-    throw new Error(`atomicWrite: validation failed for ${filePath}: ${err.message}`);
-  }
-
-  // Optionally back up the existing file
-  if (backup && existsSync(filePath)) {
-    const backupPath = filePath + '.bak';
-    try { renameSync(filePath, backupPath); } catch {}
-  }
-
-  // Atomic rename — either fully succeeds or the original is untouched
-  renameSync(tmpPath, filePath);
-}
-
-/**
- * Read and parse a JSON file safely, with optional schema migration.
- * Falls back to a .bak copy on parse failure.
- * Returns null when the file is absent or unrecoverable.
- *
- * @param {string}   filePath
- * @param {object}   opts
- * @param {number}  [opts.expectedVersion]  - Schema version to verify
- * @param {Function}[opts.migrate]           - (data, fromVersion, toVersion) => data
- * @returns {*|null}
- */
-export function readJsonSafe(filePath, opts = {}) {
-  const { expectedVersion, migrate } = opts;
-
-  if (!existsSync(filePath)) return null;
-
-  let data;
-  try {
-    data = JSON.parse(readFileSync(filePath, 'utf8'));
-  } catch {
-    // Primary file corrupt — try backup
-    const bakPath = filePath + '.bak';
-    if (existsSync(bakPath)) {
-      try {
-        data = JSON.parse(readFileSync(bakPath, 'utf8'));
-      } catch { return null; }
-    } else {
-      return null;
-    }
-  }
-
-  // Schema version check with optional migration
-  if (expectedVersion !== undefined && data?._schemaVersion !== expectedVersion) {
-    if (migrate && typeof migrate === 'function') {
-      data = migrate(data, data?._schemaVersion, expectedVersion);
-    }
-    // Tolerant read: return data even without a migrator
-  }
-
-  return data;
-}
-
-// ---------------------------------------------------------------------------
-// 2. Advisory file locks
-// ---------------------------------------------------------------------------
-
-const LOCK_TIMEOUT_MS = 10_000; // stale lock threshold
-const LOCK_RETRY_MS   = 50;     // busy-wait interval
-const LOCK_MAX_RETRIES = 100;   // max retries (~5 s)
-
-/**
- * Acquire an advisory lock for filePath by creating filePath.lock.
- * Stale locks (> LOCK_TIMEOUT_MS old) are cleared automatically.
- *
- * @param {string} filePath
- * @returns {{ acquired: boolean, lockPath: string, reason?: string }}
- */
-export function acquireLock(filePath) {
-  const lockPath = filePath + '.lock';
-
-  // Clear stale or corrupt lock
-  if (existsSync(lockPath)) {
-    try {
-      const lockData = JSON.parse(readFileSync(lockPath, 'utf8'));
-      const age = Date.now() - (lockData.createdAt || 0);
-      if (age > LOCK_TIMEOUT_MS) {
-        unlinkSync(lockPath);
-      }
-    } catch {
-      try { unlinkSync(lockPath); } catch {}
-    }
-  }
-
-  // Spin-try to create the lock exclusively
-  let retries = 0;
-  while (retries < LOCK_MAX_RETRIES) {
-    try {
-      writeFileSync(lockPath, JSON.stringify({
-        pid: process.pid,
-        createdAt: Date.now(),
-        holder: process.argv[1] || 'unknown',
-      }), { flag: 'wx' }); // 'wx' = exclusive create, EEXIST if present
-      return { acquired: true, lockPath };
-    } catch (err) {
-      if (err.code === 'EEXIST') {
-        retries++;
-        // Synchronous busy-wait — intentional; only triggered under contention
-        const start = Date.now();
-        while (Date.now() - start < LOCK_RETRY_MS) {}
-        continue;
-      }
-      throw err; // Unexpected error — propagate
-    }
-  }
-
-  return { acquired: false, lockPath, reason: 'timeout' };
-}
-
-/**
- * Release a previously acquired lock.
- *
- * @param {{ lockPath?: string }} lockResult - Return value of acquireLock
- */
-export function releaseLock(lockResult) {
-  if (lockResult?.lockPath) {
-    try { unlinkSync(lockResult.lockPath); } catch {}
-  }
-}
-
-/**
- * Run fn while holding an advisory lock on filePath.
- * Throws if the lock cannot be acquired within the retry window.
- *
- * @param {string}   filePath
- * @param {Function} fn
- * @returns {*} Return value of fn
- */
-export function withLock(filePath, fn) {
-  const lock = acquireLock(filePath);
-  if (!lock.acquired) {
-    throw new Error(`Could not acquire lock for ${filePath}: ${lock.reason}`);
-  }
-  try {
-    return fn();
-  } finally {
-    releaseLock(lock);
-  }
-}
-
-/**
- * Locked atomic read-modify-write.
- * Reads the current JSON, passes it to updateFn, then writes the result.
- * If updateFn returns undefined the file is left unchanged.
- *
- * @param {string}   filePath
- * @param {Function} updateFn   - (currentData: *|null) => updatedData | undefined
- * @param {object}   opts       - Forwarded to readJsonSafe and atomicWriteJson
- * @returns {*} Return value of updateFn
- */
-export function lockedUpdate(filePath, updateFn, opts = {}) {
-  return withLock(filePath, () => {
-    const current = readJsonSafe(filePath, opts);
-    const updated = updateFn(current);
-    if (updated !== undefined) {
-      atomicWriteJson(filePath, updated, opts);
-    }
-    return updated;
-  });
-}
-
-// ---------------------------------------------------------------------------
-// 3. Append-only ledger with lock
-// ---------------------------------------------------------------------------
-
-/**
- * Append a NDJSON record to filePath under an advisory lock.
- * On lock failure the write is attempted without a lock (best-effort).
- *
- * @param {string} filePath
- * @param {*}      record   - Value to serialize as one JSON line
- */
-export async function atomicAppend(filePath, record) {
-  const { appendFileSync } = await import('node:fs');
-  const line = JSON.stringify(record) + '\n';
-
-  const lock = acquireLock(filePath);
-  if (!lock.acquired) {
-    // Non-fatal: best-effort append without lock
-    try {
-      mkdirSync(dirname(filePath), { recursive: true });
-      appendFileSync(filePath, line);
-    } catch {}
-    return;
-  }
-
-  try {
-    mkdirSync(dirname(filePath), { recursive: true });
-    appendFileSync(filePath, line);
-  } finally {
-    releaseLock(lock);
-  }
-}