dual-brain 7.0.1 → 7.0.2

package/bin/dual-brain.mjs

@@ -5,12 +5,13 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execSync } from 'node:child_process';
+import { createInterface } from 'node:readline';
 
 import {
   ensureProfile, loadProfile, saveProfile, runOnboarding,
   rememberPreference, forgetPreference, getActivePreferences,
   getAvailableProviders, isSoloBrain, getHeadModel,
-  detectAuth, detectEnvironment,
+  detectAuth, detectEnvironment, setupAuth,
 } from '../src/profile.mjs';
 
 import { detectTask } from '../src/detect.mjs';
@@ -45,8 +46,9 @@ function printHelp() {
 dual-brain <command> [options]
 
 Commands:
-  init                      First-time setup (providers, plans, optimization)
+  init                      First-time setup → flows into interactive REPL
   auth                      Show authentication status for all providers
+  auth setup                Paste API keys directly (recommended for Replit)
   install                   Install Claude Code hooks into the current project
   go "task description"     Detect → decide → dispatch a task
     --dry-run               Show routing decision without executing
@@ -59,6 +61,14 @@ Commands:
   remember "preference"     Save a project-scoped preference
   forget "preference"       Remove a preference by fuzzy match
 
+Interactive REPL (entered after init or npx dual-brain with no args):
+  <task description>        Dispatch a task directly
+  go <task>                 Same as dual-brain go
+  status / auth / init      Run commands without exiting
+  auth setup                Re-run API key setup
+  help                      Show this help
+  exit / quit / q           Exit the REPL
+
 Options:
   --version                 Print version
   --help                    Show this help
@@ -85,14 +95,14 @@ function printAuthTable(auth) {
     : `  Claude:  ✗ not found`;
   const claudeLine2 = auth.claude.found
     ? `           ${auth.claude.masked}`
-    : `           run: claude auth login`;
+    : `           run: dual-brain auth setup`;
 
   const openaiLine1 = auth.openai.found
     ? `  OpenAI:  ✓ found via ${auth.openai.source}`
     : `  OpenAI:  ✗ not found`;
   const openaiLine2 = auth.openai.found
     ? `           ${auth.openai.masked}`
-    : `           run: codex auth  OR  export OPENAI_API_KEY=sk-...`;
+    : `           run: dual-brain auth setup`;
 
   console.log(`╔${bar}╗`);
   console.log(`║${pad('  Auth Status')}║`);
@@ -127,8 +137,8 @@ async function cmdCard() {
   // Auth status warnings (non-blocking)
   const auth = await detectAuth();
   const warnings = [];
-  if (!auth.claude.found) warnings.push('Claude auth not found — run: claude auth login');
-  if (!auth.openai.found) warnings.push('OpenAI auth not found — run: codex auth  OR  export OPENAI_API_KEY=sk-...');
+  if (!auth.claude.found) warnings.push('Claude auth not found — run: dual-brain auth setup');
+  if (!auth.openai.found) warnings.push('OpenAI auth not found — run: dual-brain auth setup');
   if (warnings.length > 0) {
     console.log('\nAuth warnings:');
     for (const w of warnings) console.log(`  ⚠  ${w}`);
@@ -144,7 +154,7 @@ async function cmdCard() {
 
 // ─── Commands ─────────────────────────────────────────────────────────────────
 
-async function cmdInit() {
+async function cmdInit(rl) {
   const cwd = process.cwd();
 
   // --- Step 1: Auth preflight ---
@@ -153,39 +163,61 @@ async function cmdInit() {
 
   const noneFound = !auth.claude.found && !auth.openai.found;
   if (noneFound) {
-    console.log('\nNo AI provider credentials found. Set up at least one before continuing:\n');
-    console.log('  Claude : claude auth login');
-    console.log('  OpenAI : codex auth   OR   export OPENAI_API_KEY=sk-...\n');
-    console.log('Re-run "dual-brain init" after authenticating.');
-    return;
+    console.log('\nNo AI provider credentials found. Let\'s set up at least one now.\n');
+    // Use the provided rl (REPL instance) or create a temporary one
+    const rlOwned = !rl;
+    if (!rl) rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      await setupAuth(rl);
+    } finally {
+      if (rlOwned) rl.close();
+    }
+    // Re-check after setup
+    const authAfter = await detectAuth();
+    if (!authAfter.claude.found && !authAfter.openai.found) {
+      console.log('\nNo credentials configured. You can run "auth setup" in the REPL anytime.');
+      // Still flow into REPL — don't exit
+      return;
+    }
   }
 
-  // --- Step 2: Run onboarding wizard, skipping tiers for auto-detected plans ---
-  const profile = await runOnboarding({ interactive: true, detectedAuth: auth });
+  // --- Step 2: Run onboarding wizard (pass shared rl so it isn't closed) ---
+  const profile = await runOnboarding({ interactive: true, detectedAuth: auth, rl });
   saveProfile(profile, { cwd });
 
-  // --- Step 3: Show dashboard + next step ---
+  // --- Step 3: Show dashboard ---
   console.log('');
   const repo    = loadRepoCache(cwd);
   const session = loadSession(cwd);
   const health  = getHealth(cwd);
   const card    = formatSessionCard(session, repo, health);
   console.log(card);
-  console.log('\nReady! Try: dual-brain go "your task here"\n');
+  console.log('\nReady! Type a task below, or "help" for commands.\n');
 }
 
-async function cmdAuth() {
+async function cmdAuth(subArgs = [], rl) {
+  const sub = subArgs[0];
+
+  if (sub === 'setup') {
+    return cmdAuthSetup(rl);
+  }
+
   const auth = await detectAuth();
   printAuthTable(auth);
 
-  // If anything is missing, print setup commands
-  if (!auth.claude.found) {
-    console.log('\nTo set up Claude:');
-    console.log('  claude auth login');
+  // If anything is missing, point to setup command
+  if (!auth.claude.found || !auth.openai.found) {
+    console.log('\nRun "dual-brain auth setup" (or "auth setup" in REPL) to paste API keys.');
   }
-  if (!auth.openai.found) {
-    console.log('\nTo set up OpenAI:');
-    console.log('  codex auth   OR   export OPENAI_API_KEY=sk-...');
+}
+
+async function cmdAuthSetup(rl) {
+  const rlOwned = !rl;
+  if (!rl) rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    await setupAuth(rl);
+  } finally {
+    if (rlOwned) rl.close();
   }
 }
 
@@ -489,6 +521,65 @@ function cmdForget(text) {
   console.log('Preference removed (if matched).');
 }
 
+// ─── Interactive REPL ────────────────────────────────────────────────────────
+
+async function startRepl(rl) {
+  // rl may have been created by cmdCard/cmdInit — reuse it.
+  // If not provided, create a fresh one.
+  const rlOwned = !rl;
+  if (!rl) rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  console.log('\nType a task or command. Type "help" for commands, "exit" to quit.\n');
+
+  const prompt = () => {
+    rl.question('dual-brain> ', async (input) => {
+      const line = input.trim();
+      if (!line) { prompt(); return; }
+
+      if (line === 'exit' || line === 'quit' || line === 'q') {
+        if (rlOwned) rl.close();
+        return;
+      }
+
+      try {
+        if (line === 'help') {
+          printHelp();
+        } else if (line === 'status') {
+          await cmdStatus([]);
+        } else if (line === 'auth setup' || line === 'auth-setup') {
+          await cmdAuthSetup(rl);
+        } else if (line === 'auth') {
+          await cmdAuth([], rl);
+        } else if (line.startsWith('go ')) {
+          await cmdGo(line.slice(3).trim().split(/\s+/));
+        } else if (line.startsWith('remember ')) {
+          cmdRemember(line.slice(9).trim());
+        } else if (line.startsWith('forget ')) {
+          cmdForget(line.slice(7).trim());
+        } else if (line.startsWith('hot ')) {
+          cmdHot(line.slice(4).trim());
+        } else if (line.startsWith('cool ')) {
+          cmdCool(line.slice(5).trim());
+        } else if (line === 'init') {
+          await cmdInit(rl);
+        } else {
+          // Treat as a task description → go
+          await cmdGo([line]);
+        }
+      } catch (e) {
+        process.stderr.write(`Error: ${e.message}\n`);
+      }
+
+      prompt(); // loop back
+    });
+  };
+
+  prompt();
+
+  // Return a promise that resolves when rl closes (exit/quit)
+  return new Promise(resolve => rl.on('close', resolve));
+}
+
 // ─── Entry point ─────────────────────────────────────────────────────────────
 
 async function main() {
@@ -496,12 +587,37 @@ async function main() {
   const cmd  = args[0];
 
   if (cmd === '--help' || cmd === '-h') { printHelp(); return; }
-  if (!cmd) { await cmdCard(); return; }
-  if (cmd === '--version' || cmd === '-v')      { console.log(readVersion()); return; }
+  if (cmd === '--version' || cmd === '-v') { console.log(readVersion()); return; }
+
+  // Interactive-only commands: enter REPL after completing (only when TTY)
+  const isInteractive = process.stdin.isTTY;
 
-  if (cmd === 'init')     { await cmdInit(); return; }
+  if (!cmd) {
+    await cmdCard();
+    if (isInteractive) await startRepl();
+    return;
+  }
+
+  if (cmd === 'init') {
+    if (isInteractive) {
+      // Create the shared rl upfront so init wizard and REPL share it
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      await cmdInit(rl);
+      await startRepl(rl);
+    } else {
+      await cmdInit();
+    }
+    return;
+  }
+
+  // One-shot commands — run and exit
   if (cmd === 'install')  { await cmdInstall(); return; }
-  if (cmd === 'auth')     { await cmdAuth(); return; }
+  if (cmd === 'auth') {
+    const sub = args[1];
+    if (sub === 'setup') { await cmdAuthSetup(); return; }
+    await cmdAuth(args.slice(1));
+    return;
+  }
   if (cmd === 'go')       { await cmdGo(args.slice(1)); return; }
   if (cmd === 'status')   { await cmdStatus(args.slice(1)); return; }
   if (cmd === 'hot')      { cmdHot(args[1]); return; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "7.0.1",
+  "version": "7.0.2",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {

package/src/profile.mjs

@@ -25,7 +25,7 @@
 import { createInterface } from 'readline';
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
-import { join } from 'path';
+import { dirname, join } from 'path';
 
 // ---------------------------------------------------------------------------
 // Claude Code memory integration
@@ -174,6 +174,20 @@ async function detectAuth() {
     } catch { continue; }
   }
 
+  // --- Claude: check .dualbrain/auth.json (before env var) ---
+  if (!results.claude.found) {
+    const storedAuth = loadAuthKeys();
+    if (storedAuth.claude?.key) {
+      const expired = storedAuth.claude.expiresAt && new Date(storedAuth.claude.expiresAt) <= new Date();
+      if (!expired) {
+        results.claude.found   = true;
+        results.claude.source  = '.dualbrain/auth.json';
+        results.claude.masked  = _maskCredential(storedAuth.claude.key);
+        process.env.ANTHROPIC_API_KEY = storedAuth.claude.key;
+      }
+    }
+  }
+
   // --- Claude: fallback to ANTHROPIC_API_KEY env var ---
   if (!results.claude.found && process.env.ANTHROPIC_API_KEY) {
     results.claude.found  = true;
@@ -208,6 +222,20 @@ async function detectAuth() {
     } catch { continue; }
   }
 
+  // --- OpenAI: check .dualbrain/auth.json (before env var) ---
+  if (!results.openai.found) {
+    const storedAuth = loadAuthKeys();
+    if (storedAuth.openai?.key) {
+      const expired = storedAuth.openai.expiresAt && new Date(storedAuth.openai.expiresAt) <= new Date();
+      if (!expired) {
+        results.openai.found   = true;
+        results.openai.source  = '.dualbrain/auth.json';
+        results.openai.masked  = _maskCredential(storedAuth.openai.key);
+        process.env.OPENAI_API_KEY = storedAuth.openai.key;
+      }
+    }
+  }
+
   // --- OpenAI: fallback to OPENAI_API_KEY env var ---
   if (!results.openai.found && process.env.OPENAI_API_KEY) {
     results.openai.found  = true;
@@ -218,6 +246,105 @@ async function detectAuth() {
   return results;
 }
 
+// ---------------------------------------------------------------------------
+// API key storage (.dualbrain/auth.json)
+// ---------------------------------------------------------------------------
+
+const AUTH_FILE = (cwd) => join(cwd || process.cwd(), '.dualbrain', 'auth.json');
+
+function loadAuthKeys(cwd) {
+  try {
+    return JSON.parse(readFileSync(AUTH_FILE(cwd), 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveAuthKey(provider, key, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const authFile = AUTH_FILE(cwd);
+  const dir = dirname(authFile);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const auth = loadAuthKeys(cwd);
+  auth[provider] = {
+    key,
+    savedAt: new Date().toISOString(),
+    expiresAt: opts.expiresAt || null,
+  };
+  writeFileSync(authFile, JSON.stringify(auth, null, 2));
+
+  // Inject into process.env for this session so dispatch can use it
+  if (provider === 'claude') process.env.ANTHROPIC_API_KEY = key;
+  if (provider === 'openai') process.env.OPENAI_API_KEY = key;
+}
+
+/**
+ * Interactive setup flow: walks user through entering API keys for missing providers.
+ * Accepts an existing readline Interface (rl) — does NOT close it.
+ * @param {import('readline').Interface} rl
+ */
+async function setupAuth(rl) {
+  const ask = (q) => new Promise(res => rl.question(q, res));
+  const auth = await detectAuth();
+
+  // Claude setup
+  if (!auth.claude.found) {
+    console.log('\n— Claude Setup —');
+    console.log('Options:');
+    console.log('  (1) Paste API key (recommended for Replit)');
+    console.log('  (2) Skip for now');
+    const choice = (await ask('> ')).trim();
+    if (choice === '1') {
+      const key = (await ask('Paste your Anthropic API key: ')).trim();
+      if (key && (key.startsWith('sk-ant-') || key.startsWith('sk-'))) {
+        const expiryStr = (await ask('Set key expiry? (enter days, or press Enter to skip)\n> ')).trim();
+        let expiresAt = null;
+        if (expiryStr && /^\d+$/.test(expiryStr)) {
+          const d = new Date();
+          d.setDate(d.getDate() + parseInt(expiryStr, 10));
+          expiresAt = d.toISOString();
+          console.log(`✓ Key expires in ${expiryStr} days (${d.toISOString().slice(0, 10)})`);
+        }
+        saveAuthKey('claude', key, { expiresAt });
+        console.log('✓ Claude API key saved');
+      } else {
+        console.log('Invalid key format. Expected sk-ant-... or sk-...');
+      }
+    }
+  } else {
+    console.log(`\n✓ Claude: already configured via ${auth.claude.source}`);
+  }
+
+  // OpenAI setup
+  if (!auth.openai.found) {
+    console.log('\n— OpenAI Setup —');
+    console.log('Options:');
+    console.log('  (1) Paste API key (recommended for Replit)');
+    console.log('  (2) Skip for now');
+    const choice = (await ask('> ')).trim();
+    if (choice === '1') {
+      const key = (await ask('Paste your OpenAI API key: ')).trim();
+      if (key && key.startsWith('sk-')) {
+        const expiryStr = (await ask('Set key expiry? (enter days, or press Enter to skip)\n> ')).trim();
+        let expiresAt = null;
+        if (expiryStr && /^\d+$/.test(expiryStr)) {
+          const d = new Date();
+          d.setDate(d.getDate() + parseInt(expiryStr, 10));
+          expiresAt = d.toISOString();
+          console.log(`✓ Key expires in ${expiryStr} days (${d.toISOString().slice(0, 10)})`);
+        }
+        saveAuthKey('openai', key, { expiresAt });
+        console.log('✓ OpenAI API key saved');
+      } else {
+        console.log('Invalid key format. Expected sk-...');
+      }
+    }
+  } else {
+    console.log(`\n✓ OpenAI: already configured via ${auth.openai.source}`);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Auto-detect subscription plans from provider config files
 // ---------------------------------------------------------------------------
@@ -414,7 +541,10 @@ function saveProfile(profile, opts = {}) {
 async function runOnboarding(opts = {}) {
   if (!opts.interactive) return defaultProfile();
 
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  // Accept an externally-provided readline instance (shared with REPL/auth setup)
+  // or create one internally if not provided. Only close if we created it.
+  const rlProvided = !!opts.rl;
+  const rl = opts.rl || createInterface({ input: process.stdin, output: process.stdout });
   const ask = (q) => new Promise(res => rl.question(q, res));
   const profile = defaultProfile();
 
@@ -440,7 +570,8 @@ async function runOnboarding(opts = {}) {
     profile.mode = n >= 2 ? 'dual' : profile.providers.claude.enabled ? 'solo-claude' : 'solo-openai';
     process.stdout.write('\nProfile saved.\n');
   } finally {
-    rl.close();
+    // Only close if we created the rl instance (not if it was passed in)
+    if (!rlProvided) rl.close();
   }
   return profile;
 }
@@ -582,4 +713,5 @@ export {
   getAvailableProviders, isSoloBrain, getHeadModel,
   detectPlans, syncPreferencesToMemory,
   detectAuth, detectEnvironment,
+  setupAuth, saveAuthKey, loadAuthKeys,
 };