ai-exodus 2.0.0

package/src/checkpoint.js

@@ -0,0 +1,109 @@
+/**
+ * Checkpoint system — saves progress after each chunk/pass
+ * Resumes from where it left off if the process crashes
+ */
+
+import { readFile, writeFile, unlink } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const CHECKPOINT_FILE = '.exodus-checkpoint.json';
+
+export class Checkpoint {
+  constructor(outputDir) {
+    this.path = join(outputDir, CHECKPOINT_FILE);
+    this.data = null;
+  }
+
+  /**
+   * Load existing checkpoint, returns null if none exists
+   */
+  async load() {
+    if (!existsSync(this.path)) return null;
+    try {
+      const raw = await readFile(this.path, 'utf-8');
+      this.data = JSON.parse(raw);
+      return this.data;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Save current state
+   */
+  async save(state) {
+    this.data = { ...state, savedAt: new Date().toISOString() };
+    await writeFile(this.path, JSON.stringify(this.data, null, 2), 'utf-8');
+  }
+
+  /**
+   * Remove checkpoint file (migration complete)
+   */
+  async clear() {
+    if (existsSync(this.path)) {
+      await unlink(this.path);
+    }
+  }
+
+  /**
+   * Get completed chunk indices for a specific pass
+   */
+  getCompletedChunks(passNum) {
+    if (!this.data?.passes?.[passNum]) return [];
+    return this.data.passes[passNum].completedChunks || [];
+  }
+
+  /**
+   * Get the results array for a specific pass
+   */
+  getPassResults(passNum) {
+    if (!this.data?.passes?.[passNum]) return null;
+    return this.data.passes[passNum].results || null;
+  }
+
+  /**
+   * Check if a pass is fully complete
+   */
+  isPassComplete(passNum) {
+    return this.data?.passes?.[passNum]?.complete === true;
+  }
+
+  /**
+   * Get merged/synthesized data for a pass
+   */
+  getMergedData(key) {
+    return this.data?.merged?.[key] || null;
+  }
+
+  /**
+   * Save chunk result for a pass
+   */
+  async saveChunkResult(passNum, chunkIndex, result, totalChunks) {
+    if (!this.data) this.data = { passes: {}, merged: {} };
+    if (!this.data.passes) this.data.passes = {};
+    if (!this.data.passes[passNum]) {
+      this.data.passes[passNum] = { completedChunks: [], results: [], complete: false };
+    }
+
+    const pass = this.data.passes[passNum];
+    pass.completedChunks.push(chunkIndex);
+    pass.results[chunkIndex] = result;
+
+    if (pass.completedChunks.length >= totalChunks) {
+      pass.complete = true;
+    }
+
+    await this.save(this.data);
+  }
+
+  /**
+   * Save merged/synthesized data
+   */
+  async saveMerged(key, data) {
+    if (!this.data) this.data = { passes: {}, merged: {} };
+    if (!this.data.merged) this.data.merged = {};
+    this.data.merged[key] = data;
+    await this.save(this.data);
+  }
+}

package/src/claude.js

@@ -0,0 +1,147 @@
+/**
+ * Claude CLI wrapper
+ * Uses `claude --print` — runs on Max subscription, zero extra cost
+ * System prompts via temp files (avoids Windows arg length limits)
+ * Conversation chunks via stdin
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { writeFile, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+
+/**
+ * Find the claude CLI path
+ */
+async function findClaude() {
+  const home = process.env.USERPROFILE || process.env.HOME || '';
+  const knownPaths = [
+    join(home, 'AppData', 'Local', 'Microsoft', 'WinGet', 'Links', 'claude.exe'),
+    join(home, '.npm-global', 'bin', 'claude'),
+    join(home, '.npm-global', 'bin', 'claude.cmd'),
+    '/usr/local/bin/claude',
+  ];
+
+  for (const p of knownPaths) {
+    if (existsSync(p)) return p;
+  }
+
+  // Fallback
+  const { exec } = await import('node:child_process');
+  return new Promise((resolve) => {
+    const cmd = process.platform === 'win32' ? 'where claude.exe' : 'which claude';
+    exec(cmd, (err, stdout) => {
+      resolve(!err && stdout.trim() ? stdout.trim().split('\n')[0].trim() : 'claude');
+    });
+  });
+}
+
+let claudePath = null;
+async function getClaude() {
+  if (!claudePath) claudePath = await findClaude();
+  return claudePath;
+}
+
+/**
+ * Write string to a temp file, return path
+ */
+async function writeTempFile(content) {
+  const name = `exodus-${randomBytes(6).toString('hex')}.txt`;
+  const path = join(tmpdir(), name);
+  await writeFile(path, content, 'utf-8');
+  return path;
+}
+
+/**
+ * Call Claude via CLI
+ * System prompt → temp file (--system-prompt-file)
+ * Prompt → stdin pipe
+ */
+export async function callClaude({ system, prompt, model }) {
+  const claude = await getClaude();
+  const args = ['--print'];
+
+  let sysFile = null;
+
+  if (system) {
+    sysFile = await writeTempFile(system);
+    args.push('--system-prompt-file', sysFile);
+  }
+
+  if (model) {
+    args.push('--model', model);
+  }
+
+  try {
+    const result = await new Promise((resolve, reject) => {
+      const proc = spawn(claude, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: tmpdir(), // avoid picking up CLAUDE.md from home/project dirs
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout.on('data', (data) => { stdout += data.toString(); });
+      proc.stderr.on('data', (data) => { stderr += data.toString(); });
+
+      proc.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+          reject(new Error(
+            'Claude Code CLI not found. Install it first:\n' +
+            '  npm install -g @anthropic-ai/claude-code\n' +
+            'Then log in: claude login'
+          ));
+        } else {
+          reject(err);
+        }
+      });
+
+      proc.on('close', (code) => {
+        if (code !== 0) {
+          const errMsg = stderr.trim() || stdout.trim() || '(no output)';
+          reject(new Error(`Claude CLI exited with code ${code}: ${errMsg}`));
+        } else {
+          resolve(stdout.trim());
+        }
+      });
+
+      // Pipe prompt via stdin
+      proc.stdin.write(prompt);
+      proc.stdin.end();
+    });
+
+    return result;
+
+  } finally {
+    // Clean up temp file
+    if (sysFile) {
+      await unlink(sysFile).catch(() => {});
+    }
+  }
+}
+
+/**
+ * Check that Claude CLI is available and logged in
+ */
+export async function checkCLI() {
+  try {
+    const claude = await getClaude();
+    return await new Promise((resolve) => {
+      const proc = spawn(claude, ['--version'], { stdio: ['pipe', 'pipe', 'pipe'] });
+      let stdout = '';
+      proc.stdout.on('data', (d) => { stdout += d.toString(); });
+      proc.on('error', () => resolve({ ok: false, error: 'Claude Code CLI not found' }));
+      proc.on('close', (code) => {
+        resolve(code === 0
+          ? { ok: true, version: stdout.trim() }
+          : { ok: false, error: 'Claude Code CLI not responding' }
+        );
+      });
+    });
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}

package/src/config.js

@@ -0,0 +1,40 @@
+/**
+ * Config management for AI Exodus
+ * Stores portal URL, credentials, and settings in ~/.exodus/config.json
+ */
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const HOME = process.env.USERPROFILE || process.env.HOME || '';
+const CONFIG_DIR = join(HOME, '.exodus');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+export async function loadConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) return {};
+    const raw = await readFile(CONFIG_FILE, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export async function saveConfig(config) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+export async function getConfig(key) {
+  const config = await loadConfig();
+  return config[key];
+}
+
+export async function setConfig(key, value) {
+  const config = await loadConfig();
+  config[key] = value;
+  await saveConfig(config);
+}
+
+export { CONFIG_DIR, CONFIG_FILE };

package/src/deploy.js

@@ -0,0 +1,193 @@
+/**
+ * Deploy command — creates Cloudflare Worker + D1 for the user's portal
+ * Same pattern as Hearthline CLI deploy
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir, copyFile } from 'node:fs/promises';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { randomBytes } from 'node:crypto';
+import { loadConfig, saveConfig } from './config.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PORTAL_DIR = resolve(__dirname, '..', 'portal');
+
+export async function deploy(options) {
+  const { verbose } = options;
+
+  console.log('');
+  console.log('  ╔══════════════════════════════════════╗');
+  console.log('  ║       AI EXODUS — Portal Deploy      ║');
+  console.log('  ╚══════════════════════════════════════╝');
+  console.log('');
+
+  // Check wrangler is available
+  const wranglerOk = await checkCommand('npx', ['wrangler', '--version']);
+  if (!wranglerOk) {
+    console.error('  Error: Wrangler not found. Install it: npm install -g wrangler');
+    console.error('  Then log in: npx wrangler login');
+    process.exit(1);
+  }
+
+  // Check if portal source exists
+  if (!existsSync(join(PORTAL_DIR, 'worker.js'))) {
+    console.error('  Error: Portal source not found at ' + PORTAL_DIR);
+    console.error('  Make sure ai-exodus-portal/ is alongside ai-exodus/');
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+  const isRedeployMode = !!config.portalUrl;
+
+  if (isRedeployMode) {
+    console.log('  Existing deployment detected: ' + config.portalUrl);
+    console.log('  Redeploying with latest code...');
+    console.log('');
+  }
+
+  // Generate deployment name or reuse existing
+  const deployName = config.deployName || 'exodus-' + randomBytes(3).toString('hex');
+  const mcpSecret = config.mcpSecret || 'exodus-' + randomBytes(8).toString('hex');
+  const dbName = config.dbName || deployName + '-db';
+
+  // Step 1: Create D1 database (skip if exists)
+  if (!config.dbId) {
+    console.log('  [1/4] Creating database...');
+    const dbOutput = await runCommand('npx', ['wrangler', 'd1', 'create', dbName], { verbose });
+    // Try both TOML format (old) and JSON format (new wrangler)
+    const dbIdMatch = dbOutput.match(/database_id\s*=\s*"([^"]+)"/) ||
+                      dbOutput.match(/"database_id"\s*:\s*"([^"]+)"/);
+    if (!dbIdMatch) {
+      console.error('  Error: Could not parse database ID from wrangler output');
+      console.error(dbOutput);
+      process.exit(1);
+    }
+    config.dbId = dbIdMatch[1];
+    config.dbName = dbName;
+    console.log('    Database created: ' + dbName + ' (' + config.dbId + ')');
+  } else {
+    console.log('  [1/4] Database exists: ' + config.dbName);
+  }
+
+  // Step 2: Set up deploy directory
+  console.log('  [2/4] Preparing deployment...');
+  const deployDir = resolve(join(PORTAL_DIR, '.deploy-' + deployName));
+  await mkdir(deployDir, { recursive: true });
+
+  // Copy worker.js and schema.sql
+  await copyFile(join(PORTAL_DIR, 'worker.js'), join(deployDir, 'worker.js'));
+  await copyFile(join(PORTAL_DIR, 'schema.sql'), join(deployDir, 'schema.sql'));
+
+  // Write wrangler.toml with actual values
+  const wranglerToml = `name = "${deployName}"
+main = "worker.js"
+compatibility_date = "2024-12-01"
+
+[[d1_databases]]
+binding = "DB"
+database_name = "${dbName}"
+database_id = "${config.dbId}"
+
+[vars]
+MCP_SECRET = "${mcpSecret}"
+`;
+  await writeFile(join(deployDir, 'wrangler.toml'), wranglerToml, 'utf-8');
+
+  // Step 3: Initialize database schema
+  console.log('  [3/4] Initializing database schema...');
+  try {
+    const schemaContent = await readFile(join(PORTAL_DIR, 'schema.sql'), 'utf-8');
+    // Split by semicolons and run each statement (wrangler --file can be finicky)
+    const statements = schemaContent.split(';').map(s => s.trim()).filter(s => s.length > 5);
+    for (const stmt of statements) {
+      try {
+        await runCommand('npx', ['wrangler', 'd1', 'execute', dbName, '--remote', '--command', stmt + ';'], { verbose, cwd: deployDir });
+      } catch (err) {
+        const msg = err.message || '';
+        // Tolerate "already exists" and argument parsing issues with CREATE INDEX
+        if (msg.includes('already exists') || msg.includes('Unknown arguments') || msg.includes('must provide')) {
+          if (verbose) console.log('      (skipped: ' + msg.slice(0, 80) + ')');
+        } else {
+          console.error('    Schema error: ' + msg.slice(0, 200));
+          console.error('    Deploy may fail — check your database manually.');
+        }
+      }
+    }
+    console.log('    Schema applied.');
+  } catch (err) {
+    console.error('    Schema initialization failed: ' + err.message);
+    console.error('    Try applying manually: npx wrangler d1 execute ' + dbName + ' --remote --file schema.sql');
+  }
+
+  // Step 4: Deploy worker
+  console.log('  [4/4] Deploying portal...');
+  const deployOutput = await runCommand('npx', ['wrangler', 'deploy'], { verbose, cwd: deployDir });
+
+  // Extract URL from deploy output
+  const urlMatch = deployOutput.match(/(https:\/\/[^\s]+\.workers\.dev)/);
+  const portalUrl = urlMatch ? urlMatch[1] : `https://${deployName}.workers.dev`;
+
+  // Save config
+  config.deployName = deployName;
+  config.mcpSecret = mcpSecret;
+  config.portalUrl = portalUrl;
+  await saveConfig(config);
+
+  // Clean up deploy dir
+  // Leave it for now — useful for redeployments
+
+  console.log('');
+  console.log('  ╔══════════════════════════════════════╗');
+  console.log('  ║          Portal deployed!             ║');
+  console.log('  ╚══════════════════════════════════════╝');
+  console.log('');
+  console.log('  Portal URL:  ' + portalUrl);
+  console.log('  MCP Secret:  ' + mcpSecret);
+  console.log('');
+  console.log('  Next steps:');
+  console.log('    1. Open ' + portalUrl + ' and set your password');
+  console.log('    2. Import your chat history:');
+  console.log('       ai-exodus import conversations.json');
+  console.log('    3. Run analysis:');
+  console.log('       ai-exodus analyze --passes all');
+  console.log('');
+  console.log('  MCP connector URL (for Claude):');
+  console.log('  ' + portalUrl + '/mcp/' + mcpSecret + '/search?q=your+query');
+  console.log('');
+  console.log('  Config saved to ~/.exodus/config.json');
+  console.log('');
+}
+
+
+// ── Helpers ──
+
+function checkCommand(cmd, args) {
+  return new Promise((resolve) => {
+    const proc = spawn(cmd, args, { stdio: 'pipe', shell: true });
+    proc.on('error', () => resolve(false));
+    proc.on('close', (code) => resolve(code === 0));
+  });
+}
+
+function runCommand(cmd, args, { verbose = false, cwd = undefined } = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, { stdio: ['pipe', 'pipe', 'pipe'], shell: true, cwd });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => {
+      stdout += d.toString();
+      if (verbose) process.stdout.write(d);
+    });
+    proc.stderr.on('data', (d) => {
+      stderr += d.toString();
+      if (verbose) process.stderr.write(d);
+    });
+    proc.on('error', reject);
+    proc.on('close', (code) => {
+      if (code !== 0) reject(new Error(stderr.trim() || stdout.trim() || `Command failed with code ${code}`));
+      else resolve(stdout);
+    });
+  });
+}