warp-os 1.1.2 → 1.2.1

package/bin/migrate-sessions.js

@@ -1,41 +1,84 @@
 #!/usr/bin/env node
 // migrate-sessions.js — Import old .warp/sessions/*.md into claude-mem
-// Run once during upgrade. Reads markdown session handoffs, posts them
-// to claude-mem's worker API as observations, then archives originals.
+//
+// Uses bun + direct SQLite inserts (not HTTP API — claude-mem has no public write API).
+// The HTTP API only queues raw tool data through LLM reprocessing, which is wrong for
+// pre-formed historical knowledge. Direct DB insert is the proven approach.
+//
+// Requires: bun (auto-installed by claude-mem)
+// Database: ~/.claude-mem/claude-mem.db
+//
+// Usage:
+//   node bin/migrate-sessions.js [project-dir]     Run migration
+//   node bin/migrate-sessions.js --clean [dir]      Remove all warp-import-* data
+//   node bin/migrate-sessions.js --dry-run [dir]    Preview without touching DB
+//
+// Idempotent: uses content hashes to avoid duplicates. Safe to re-run.
+// All imported sessions use content_session_id = "warp-import-{id}" for identification.
 
 const fs = require('fs');
 const path = require('path');
-const http = require('http');
+const os = require('os');
+const crypto = require('crypto');
+const { execSync } = require('child_process');
 
 const GREEN = '\x1b[32m';
 const YELLOW = '\x1b[33m';
 const CYAN = '\x1b[36m';
+const RED = '\x1b[31m';
 const NC = '\x1b[0m';
 
 function ok(msg) { console.log(`  ${GREEN}OK${NC}    ${msg}`); }
 function warn(msg) { console.log(`  ${YELLOW}WARN${NC}  ${msg}`); }
 function info(msg) { console.log(`  ${CYAN}INFO${NC}  ${msg}`); }
+function fail(msg) { console.log(`  ${RED}FAIL${NC}  ${msg}`); }
 
-// ── Find session files ───────────────────────────────────────────────────────
+// ── Args ─────────────────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+const cleanMode = args.includes('--clean');
+const dryRun = args.includes('--dry-run');
+const cwd = args.find(a => !a.startsWith('--')) || process.cwd();
+const DB_PATH = path.join(os.homedir(), '.claude-mem', 'claude-mem.db');
+
+// ── Check prerequisites ─────────────────────────────────────────────────────
+
+if (!fs.existsSync(DB_PATH)) {
+  warn('claude-mem database not found at ~/.claude-mem/claude-mem.db');
+  info('Install claude-mem first: npx claude-mem install');
+  process.exit(0);
+}
+
+let bunPath;
+try {
+  bunPath = execSync('which bun 2>/dev/null || where bun 2>nul', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim().split('\n')[0];
+} catch {
+  warn('bun not found. Required for SQLite access.');
+  info('Install bun: curl -fsSL https://bun.sh/install | bash');
+  process.exit(0);
+}
+
+// ── Generate the bun script and execute it ──────────────────────────────────
+// We write a temporary .ts file and run it with bun because bun:sqlite
+// is only available in the bun runtime, not Node.js.
 
-const cwd = process.argv[2] || process.cwd();
 const sessionsDir = path.join(cwd, '.warp', 'sessions');
 const archiveDir = path.join(sessionsDir, 'archive');
 
-if (!fs.existsSync(sessionsDir)) {
+if (!cleanMode && !fs.existsSync(sessionsDir)) {
   console.log('No .warp/sessions/ directory found. Nothing to migrate.');
   process.exit(0);
 }
 
 // Gather all session files (active + archived)
 const sessionFiles = [];
-
-for (const file of fs.readdirSync(sessionsDir)) {
-  if (file.endsWith('.md') && file.startsWith('SESSION_')) {
-    sessionFiles.push(path.join(sessionsDir, file));
+if (fs.existsSync(sessionsDir)) {
+  for (const file of fs.readdirSync(sessionsDir)) {
+    if (file.endsWith('.md') && file.startsWith('SESSION_')) {
+      sessionFiles.push(path.join(sessionsDir, file));
+    }
   }
 }
-
 if (fs.existsSync(archiveDir)) {
   for (const file of fs.readdirSync(archiveDir)) {
     if (file.endsWith('.md') && file.startsWith('SESSION_')) {
@@ -44,75 +87,30 @@ if (fs.existsSync(archiveDir)) {
   }
 }
 
-if (sessionFiles.length === 0) {
+if (!cleanMode && sessionFiles.length === 0) {
   console.log('No session files found to migrate.');
   process.exit(0);
 }
 
-console.log(`Found ${sessionFiles.length} session file(s) to migrate.`);
-
-// ── Check if claude-mem worker is running ────────────────────────────────────
-
-function httpPost(urlPath, data) {
-  return new Promise((resolve, reject) => {
-    const body = JSON.stringify(data);
-    const req = http.request({
-      hostname: '127.0.0.1',
-      port: 37777,
-      path: urlPath,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(body)
-      },
-      timeout: 10000
-    }, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => resolve({ status: res.statusCode, body: data }));
-    });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
-    req.write(body);
-    req.end();
-  });
-}
-
-function httpGet(urlPath) {
-  return new Promise((resolve, reject) => {
-    const req = http.request({
-      hostname: '127.0.0.1',
-      port: 37777,
-      path: urlPath,
-      method: 'GET',
-      timeout: 5000
-    }, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => resolve({ status: res.statusCode, body: data }));
-    });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
-    req.end();
-  });
-}
-
-// ── Parse session file ───────────────────────────────────────────────────────
-
+// Parse session files in Node, pass structured data to bun
 function parseSessionFile(filePath) {
   const content = fs.readFileSync(filePath, 'utf8');
   const filename = path.basename(filePath, '.md');
 
-  // Extract session metadata from filename: SESSION_CC7_20260404
   const match = filename.match(/SESSION_CC(\d+)_(\d{8})/);
-  const sessionNum = match ? `CC${match[1]}` : filename;
-  const dateStr = match ? `${match[2].slice(0,4)}-${match[2].slice(4,6)}-${match[2].slice(6,8)}` : 'unknown';
+  const sessionNum = match ? parseInt(match[1]) : 0;
+  const sessionId = match ? `CC${match[1]}` : filename;
+  const dateStr = match
+    ? `${match[2].slice(0,4)}-${match[2].slice(4,6)}-${match[2].slice(6,8)}`
+    : new Date().toISOString().slice(0,10);
+
+  // Parse epoch from date string
+  const epoch = new Date(dateStr + 'T12:00:00Z').getTime();
 
   // Extract sections
   const sections = {};
   let currentSection = 'header';
   sections[currentSection] = [];
-
   for (const line of content.split('\n')) {
     if (line.startsWith('## ')) {
       currentSection = line.replace('## ', '').trim();
@@ -123,132 +121,245 @@ function parseSessionFile(filePath) {
     }
   }
 
-  // Extract goal from header
   const goalLine = content.match(/Goal:\s+(.+)/);
-  const goal = goalLine ? goalLine[1].trim() : `Session ${sessionNum}`;
+  const goal = goalLine ? goalLine[1].trim() : `Session ${sessionId}`;
+
+  const extractBullets = (key) =>
+    (sections[key] || []).filter(l => l.trim().startsWith('-')).map(l => l.trim().replace(/^- /, ''));
+
+  const keyDecisions = extractBullets('Key Decisions');
+  const itemsAchieved = extractBullets('Items Achieved');
+  const itemsNotDone = extractBullets('Items Not Done');
+  const nextPickup = (sections['Next Pickup Point'] || []).join('\n').trim();
+  const filesProduced = extractBullets('Files Produced');
+  const filesAmended = extractBullets('Files Amended');
+
+  // Content hash for idempotency
+  const contentHash = crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
 
   return {
-    filename,
-    sessionNum,
-    dateStr,
-    goal,
-    content,
-    sections,
-    keyDecisions: (sections['Key Decisions'] || []).filter(l => l.trim().startsWith('-')).map(l => l.trim().replace(/^- /, '')),
-    itemsAchieved: (sections['Items Achieved'] || []).filter(l => l.trim().startsWith('-')).map(l => l.trim().replace(/^- /, '')),
-    itemsNotDone: (sections['Items Not Done'] || []).filter(l => l.trim().startsWith('-')).map(l => l.trim().replace(/^- /, '')),
-    nextPickup: (sections['Next Pickup Point'] || []).join('\n').trim(),
-    filesProduced: (sections['Files Produced'] || []).filter(l => l.trim().startsWith('-')).map(l => l.trim().replace(/^- /, '')),
-    filesAmended: (sections['Files Amended'] || []).filter(l => l.trim().startsWith('-')).map(l => l.trim().replace(/^- /, '')),
+    filename, sessionId, sessionNum, dateStr, epoch, goal, contentHash,
+    keyDecisions, itemsAchieved, itemsNotDone, nextPickup, filesProduced, filesAmended
   };
 }
 
-// ── Main ─────────────────────────────────────────────────────────────────────
+const projectName = path.basename(cwd);
+const sessions = sessionFiles.map(f => parseSessionFile(f));
+
+if (!cleanMode) {
+  console.log(`Found ${sessions.length} session file(s) to migrate.`);
+}
+
+// Write the bun migration script to a temp file
+const bunScript = `
+import { Database } from "bun:sqlite";
+
+const DB_PATH = ${JSON.stringify(DB_PATH)};
+const projectName = ${JSON.stringify(projectName)};
+const cleanMode = ${cleanMode};
+const dryRun = ${dryRun};
+const sessions = ${JSON.stringify(sessions)};
+
+const db = new Database(DB_PATH);
+db.exec("PRAGMA journal_mode=WAL");
+
+// Bun-compatible crypto helpers
+function bunHash(input: string): string {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(input);
+  return hasher.digest("hex").slice(0, 16);
+}
+function bunUUID(): string {
+  return crypto.randomUUID();
+}
+
+if (cleanMode) {
+  if (dryRun) {
+    const count = db.prepare("SELECT COUNT(*) as c FROM sdk_sessions WHERE content_session_id LIKE 'warp-import-%'").get();
+    const obsCount = db.prepare(\`
+      SELECT COUNT(*) as c FROM observations o
+      JOIN sdk_sessions s ON o.memory_session_id = s.memory_session_id
+      WHERE s.content_session_id LIKE 'warp-import-%'
+    \`).get();
+    console.log(\`  DRY RUN: Would remove \${count.c} sessions, \${obsCount.c} observations\`);
+  } else {
+    // Delete observations first (FK constraint)
+    const deleted = db.prepare(\`
+      DELETE FROM observations WHERE memory_session_id IN (
+        SELECT memory_session_id FROM sdk_sessions WHERE content_session_id LIKE 'warp-import-%'
+      )
+    \`).run();
+    // Delete summaries
+    db.prepare(\`
+      DELETE FROM session_summaries WHERE memory_session_id IN (
+        SELECT memory_session_id FROM sdk_sessions WHERE content_session_id LIKE 'warp-import-%'
+      )
+    \`).run();
+    // Delete sessions
+    const sessDeleted = db.prepare("DELETE FROM sdk_sessions WHERE content_session_id LIKE 'warp-import-%'").run();
+    console.log(\`  Cleaned: \${sessDeleted.changes} sessions, \${deleted.changes} observations\`);
+  }
+  db.close();
+  process.exit(0);
+}
+
+// Check for existing imports (idempotency)
+const existingImports = db.prepare(
+  "SELECT content_session_id FROM sdk_sessions WHERE content_session_id LIKE 'warp-import-%'"
+).all().map(r => r.content_session_id);
+
+let migrated = 0;
+let skipped = 0;
+let failed = 0;
+
+for (const session of sessions) {
+  const contentSessionId = \`warp-import-\${session.sessionId}\`;
+
+  // Skip if already imported
+  if (existingImports.includes(contentSessionId)) {
+    console.log(\`  SKIP  \${session.filename} (already imported)\`);
+    skipped++;
+    continue;
+  }
+
+  if (dryRun) {
+    const obsCount = session.keyDecisions.length + (session.itemsAchieved.length > 0 ? 1 : 0) +
+      (session.itemsNotDone.length > 0 ? 1 : 0) + (session.nextPickup ? 1 : 0);
+    console.log(\`  DRY   \${session.filename} → \${obsCount} observations\`);
+    migrated++;
+    continue;
+  }
 
-async function main() {
-  // Check worker health
   try {
-    const health = await httpGet('/health');
-    if (health.status !== 200) {
-      warn('claude-mem worker not healthy. Start it with: npx claude-mem start');
-      process.exit(1);
+    // Create session
+    const memorySessionId = bunUUID();
+    const dateIso = new Date(session.epoch).toISOString();
+    db.prepare(\`
+      INSERT INTO sdk_sessions (content_session_id, memory_session_id, project, status, started_at, started_at_epoch, completed_at, completed_at_epoch)
+      VALUES (?, ?, ?, 'completed', ?, ?, ?, ?)
+    \`).run(contentSessionId, memorySessionId, projectName, dateIso, session.epoch, dateIso, session.epoch);
+
+    let obsCount = 0;
+
+    // Import key decisions as individual "decision" observations
+    for (const decision of session.keyDecisions) {
+      const hash = bunHash(memorySessionId + decision);
+      db.prepare(\`
+        INSERT INTO observations (memory_session_id, project, type, title, narrative, content_hash, created_at, created_at_epoch)
+        VALUES (?, ?, 'decision', ?, ?, ?, ?, ?)
+      \`).run(memorySessionId, projectName,
+        decision.length > 80 ? decision.slice(0, 77) + '...' : decision,
+        decision,
+        hash, dateIso, session.epoch);
+      obsCount++;
     }
-  } catch {
-    warn('claude-mem worker not running. Start it with: npx claude-mem start');
-    info('Migration will run on next upgrade after worker is available.');
-    process.exit(0);
-  }
 
-  const projectName = path.basename(cwd);
-  let migrated = 0;
-  let failed = 0;
+    // Import items achieved as a "change" observation (grouped)
+    if (session.itemsAchieved.length > 0) {
+      const narrative = session.itemsAchieved.map(i => \`- \${i}\`).join('\\n');
+      const hash = bunHash(memorySessionId + 'achieved' + narrative);
+      db.prepare(\`
+        INSERT INTO observations (memory_session_id, project, type, title, narrative, content_hash, created_at, created_at_epoch)
+        VALUES (?, ?, 'change', ?, ?, ?, ?, ?)
+      \`).run(memorySessionId, projectName,
+        \`\${session.sessionId}: \${session.itemsAchieved.length} items completed\`,
+        \`Session \${session.sessionId} (\${session.dateStr}): \${session.goal}\\n\\nCompleted:\\n\${narrative}\`,
+        hash, dateIso, session.epoch);
+      obsCount++;
+    }
 
-  for (const file of sessionFiles) {
-    const session = parseSessionFile(file);
-
-    // Build a narrative for claude-mem from the session handoff
-    const narrative = [
-      `Session ${session.sessionNum} (${session.dateStr}): ${session.goal}`,
-      '',
-      session.keyDecisions.length > 0 ? `Key Decisions:\n${session.keyDecisions.map(d => `  - ${d}`).join('\n')}` : '',
-      session.itemsAchieved.length > 0 ? `Completed:\n${session.itemsAchieved.map(d => `  - ${d}`).join('\n')}` : '',
-      session.itemsNotDone.length > 0 ? `Not Done:\n${session.itemsNotDone.map(d => `  - ${d}`).join('\n')}` : '',
-      session.nextPickup ? `Next Pickup: ${session.nextPickup}` : '',
-      session.filesProduced.length > 0 ? `Files Produced:\n${session.filesProduced.map(d => `  - ${d}`).join('\n')}` : '',
-      session.filesAmended.length > 0 ? `Files Amended:\n${session.filesAmended.map(d => `  - ${d}`).join('\n')}` : '',
-    ].filter(Boolean).join('\n\n');
+    // Import items not done as a "discovery" observation
+    if (session.itemsNotDone.length > 0) {
+      const narrative = session.itemsNotDone.map(i => \`- \${i}\`).join('\\n');
+      const hash = bunHash(memorySessionId + 'notdone' + narrative);
+      db.prepare(\`
+        INSERT INTO observations (memory_session_id, project, type, title, narrative, content_hash, created_at, created_at_epoch)
+        VALUES (?, ?, 'discovery', ?, ?, ?, ?, ?)
+      \`).run(memorySessionId, projectName,
+        \`\${session.sessionId}: \${session.itemsNotDone.length} items deferred\`,
+        \`Not completed in \${session.sessionId}:\\n\${narrative}\`,
+        hash, dateIso, session.epoch);
+      obsCount++;
+    }
 
-    try {
-      // Post as an observation to claude-mem
-      const result = await httpPost('/api/sessions/observations', {
-        contentSessionId: `warp-migration-${session.sessionNum}`,
-        project: projectName,
-        tool_name: 'warp-session-migration',
-        tool_input: {
-          session: session.sessionNum,
-          date: session.dateStr,
-          goal: session.goal
-        },
-        tool_output: {
-          narrative: narrative,
-          keyDecisions: session.keyDecisions,
-          itemsAchieved: session.itemsAchieved,
-          filesAmended: session.filesAmended,
-          nextPickup: session.nextPickup
-        }
-      });
-
-      if (result.status >= 200 && result.status < 300) {
-        ok(`${session.filename} → claude-mem (${session.keyDecisions.length} decisions, ${session.itemsAchieved.length} items)`);
-        migrated++;
-      } else {
-        // If the observation API doesn't accept this format, try the raw session init
-        const initResult = await httpPost('/api/sessions/init', {
-          contentSessionId: `warp-migration-${session.sessionNum}`,
-          project: projectName,
-          userPrompt: `[Migrated from ${session.filename}] ${session.goal}\n\n${narrative}`
-        });
-
-        if (initResult.status >= 200 && initResult.status < 300) {
-          ok(`${session.filename} → claude-mem (via session init)`);
-          migrated++;
-        } else {
-          warn(`${session.filename} — API returned ${result.status}`);
-          failed++;
-        }
-      }
-    } catch (err) {
-      warn(`${session.filename} — ${err.message}`);
-      failed++;
+    // Import next pickup as a "discovery" observation
+    if (session.nextPickup) {
+      const hash = bunHash(memorySessionId + 'pickup' + session.nextPickup);
+      db.prepare(\`
+        INSERT INTO observations (memory_session_id, project, type, title, narrative, content_hash, created_at, created_at_epoch)
+        VALUES (?, ?, 'discovery', ?, ?, ?, ?, ?)
+      \`).run(memorySessionId, projectName,
+        \`\${session.sessionId}: Next pickup point\`,
+        session.nextPickup,
+        hash, dateIso, session.epoch);
+      obsCount++;
     }
+
+    // Create session summary
+    const summaryRequest = session.goal;
+    const summaryLearned = session.keyDecisions.join('; ') || 'No key decisions recorded';
+    const summaryCompleted = session.itemsAchieved.join('; ') || 'No items recorded';
+    const summaryNextSteps = session.nextPickup || 'No next steps recorded';
+    const filesRead = session.filesProduced.join(', ');
+    const filesModified = session.filesAmended.join(', ');
+
+    const summaryDateIso = new Date(session.epoch).toISOString();
+    db.prepare(\`
+      INSERT INTO session_summaries (memory_session_id, project, request, learned, completed, next_steps, files_read, files_edited, created_at, created_at_epoch)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    \`).run(memorySessionId, projectName, summaryRequest, summaryLearned, summaryCompleted, summaryNextSteps, filesRead, filesModified, summaryDateIso, session.epoch);
+
+    console.log(\`  OK    \${session.filename} → \${obsCount} observations, 1 summary\`);
+    migrated++;
+  } catch (err) {
+    console.log(\`  FAIL  \${session.filename} — \${err.message}\`);
+    failed++;
   }
+}
+
+db.close();
+
+console.log('');
+console.log(\`Migration: \${migrated} imported, \${skipped} skipped, \${failed} failed\`);
+`;
+
+// Write temp script and execute with bun
+const tmpScript = path.join(os.tmpdir(), `warp-migrate-${Date.now()}.ts`);
+fs.writeFileSync(tmpScript, bunScript);
+
+try {
+  execSync(`"${bunPath}" run "${tmpScript}"`, {
+    stdio: 'inherit',
+    timeout: 120000,
+    env: { ...process.env }
+  });
+} catch (err) {
+  fail(`Migration script failed: ${err.message}`);
+  process.exit(1);
+} finally {
+  try { fs.unlinkSync(tmpScript); } catch {}
+}
 
-  // Archive migrated files
-  if (migrated > 0) {
-    const migratedDir = path.join(sessionsDir, 'migrated-to-claude-mem');
-    fs.mkdirSync(migratedDir, { recursive: true });
+// Archive migrated files (only if not dry-run and not clean mode)
+if (!dryRun && !cleanMode && sessions.length > 0) {
+  const migratedDir = path.join(sessionsDir, 'migrated-to-claude-mem');
+  fs.mkdirSync(migratedDir, { recursive: true });
 
-    for (const file of sessionFiles) {
-      const basename = path.basename(file);
-      const dest = path.join(migratedDir, basename);
-      try {
+  let archived = 0;
+  for (const file of sessionFiles) {
+    const basename = path.basename(file);
+    const dest = path.join(migratedDir, basename);
+    try {
+      if (!fs.existsSync(dest)) {
         fs.copyFileSync(file, dest);
-        fs.unlinkSync(file);
-      } catch {
-        // File might already be in archive subdir, just leave it
       }
+      fs.unlinkSync(file);
+      archived++;
+    } catch {
+      // File might already be archived or in a subdir
     }
-    ok(`Archived ${migrated} session file(s) → .warp/sessions/migrated-to-claude-mem/`);
   }
-
-  console.log('');
-  console.log(`Migration: ${GREEN}${migrated}${NC} imported, ${YELLOW}${failed}${NC} failed`);
-  if (failed > 0) {
-    info('Failed files left in place. Re-run migration after fixing claude-mem worker.');
+  if (archived > 0) {
+    ok(`Archived ${archived} session file(s) → .warp/sessions/migrated-to-claude-mem/`);
   }
 }
-
-main().catch(err => {
-  warn(`Migration error: ${err.message}`);
-  process.exit(1);
-});