howamiprompting 0.0.0-stage → 0.1.0

package/src/clean.js

@@ -0,0 +1,75 @@
+// Turn raw records into clean, privacy-safe prompt objects.
+import { toISO } from './util.js';
+
+const NOISE = [/^<command-(name|message|args)>/, /^<local-command/, /^Caveat: The messages below/, /^This session is being continued/, /^<system-reminder>/, /^\s*<(environment_context|user_instructions)/];
+
+const SECRET_PATTERNS = [
+  [/\b(sk-(?:ant-|or-|proj-)?[A-Za-z0-9_\-]{16,})/g, '[REDACTED_KEY]'],
+  [/\b(gh[pousr]_[A-Za-z0-9]{20,})/g, '[REDACTED_TOKEN]'],
+  [/\b(xox[abpr]-[A-Za-z0-9-]{10,})/g, '[REDACTED_TOKEN]'],
+  [/\b(AKIA[0-9A-Z]{16})\b/g, '[REDACTED_AWS]'],
+  [/\b(AIza[0-9A-Za-z_\-]{30,})/g, '[REDACTED_KEY]'],
+  [/\beyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}/g, '[REDACTED_JWT]'],
+  [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, '[REDACTED_PRIVATE_KEY]'],
+  [/((?:password|passwd|pwd|secret|api[_-]?key|token)\s*[:=]\s*)(["']?)[^\s"']{4,}\2/gi, '$1[REDACTED]'],
+  [/\b(postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis):\/\/[^\s]+/gi, '$1://[REDACTED]'],
+];
+export function redact(s) { for (const [re, rep] of SECRET_PATTERNS) s = s.replace(re, rep); return s; }
+
+const LOG_LINE = /^\s*(at\s+\S+.*\(|at\s+\S+:\d+|File ".*", line \d+|Traceback|\w*(Error|Exception)\b[:\s]|\[\d{1,2}:\d{2}|\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}|(ERROR|WARN|INFO|DEBUG)\b|npm (ERR|error)|\s*\^+\s*$|\s+\d+\s*\|)/;
+const CODE_LINE = /[{};=<>]\s*$|^\s*(import|export|const|let|var|function|def|class|return|if|for|while|public|private|#include|SELECT|INSERT|UPDATE|<\/?\w+[^>]*>)\b/;
+
+/** Separate the human's prose from pasted code / logs. */
+export function split(text) {
+  let codeLines = 0, logLines = 0;
+  let t = text.replace(/```[\s\S]*?(```|$)/g, m => { const n = m.split('\n').length - 2; codeLines += Math.max(1, n); return `\n[pasted code: ${Math.max(1, n)} lines]\n`; });
+  const lines = t.split(/\r?\n/);
+  const keep = [];
+  let run = [], runKind = null;
+  const flushRun = () => {
+    if (!run.length) return;
+    if (run.length >= 3) { keep.push(`[pasted ${runKind}: ${run.length} lines]`); if (runKind === 'log') logLines += run.length; else codeLines += run.length; }
+    else keep.push(...run.map(r => r.l));
+    run = []; runKind = null;
+  };
+  for (const l of lines) {
+    const kind = LOG_LINE.test(l) ? 'log' : (CODE_LINE.test(l) && !/[.?!]$/.test(l.trim()) && l.split(' ').length < 14) ? 'code' : null;
+    if (kind) { if (runKind && runKind !== kind && run.length < 3) runKind = kind; runKind = runKind || kind; run.push({ l }); }
+    else { flushRun(); keep.push(l); }
+  }
+  flushRun();
+  t = keep.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+  const prose = t.replace(/\[pasted (code|log): \d+ lines\]/g, ' ').replace(/https?:\/\/\S+/g, ' ').replace(/(?:~|\.{1,2})?\/[\w./-]+/g, ' ').replace(/\s+/g, ' ').trim();
+  return { text: t, prose, codeLines, logLines };
+}
+
+export function clean(records, { since } = {}) {
+  const out = [];
+  const seen = new Set();
+  const sinceMs = since ? Date.now() - since * 86400000 : 0;
+  let interrupts = 0;
+  for (const r of records) {
+    if (r.kind === 'interrupt') { interrupts++; continue; }
+    let raw = String(r.text || '').replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').replace(/\[Image #?\d*\]|\[image\]/gi, '[image]').trim();
+    if (!raw || NOISE.some(re => re.test(raw))) continue;
+    const ts = toISO(r.ts);
+    if (sinceMs && ts && Date.parse(ts) < sinceMs) continue;
+    const key = (r.session || '') + '|' + raw.slice(0, 200);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    raw = redact(raw);
+    const s = split(raw);
+    if (!s.prose && !s.codeLines && !s.logLines) continue;
+    let text = s.text;
+    if (text.length > 2500) text = text.slice(0, 2000) + ` …[+${text.length - 2000} chars]`;
+    out.push({
+      id: out.length, tool: r.tool, project: r.project || null, session: String(r.session || ''), ts,
+      text, prose: s.prose.slice(0, 2000), words: (s.prose.match(/[A-Za-z0-9']+/g) || []).length,
+      codeLines: s.codeLines, logLines: s.logLines, images: (raw.match(/\[image\]/g) || []).length,
+      context: r.context ? redact(split(String(r.context)).prose).slice(-300) : '',
+    });
+  }
+  out.sort((a, b) => (a.ts || '').localeCompare(b.ts || ''));
+  out.forEach((p, i) => p.id = i);
+  return { prompts: out, interrupts };
+}

package/src/cli.js

@@ -0,0 +1,189 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { spawn } from 'node:child_process';
+import { collectAll } from './collect/index.js';
+import { clean } from './clean.js';
+import { computeStats } from './stats.js';
+import { detectAgents, AGENTS } from './agents.js';
+import { analyze, overallFrom } from './analyze.js';
+import { startServer } from './server.js';
+import { saveReport, lastReport } from './store.js';
+
+const VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+const tty = process.stdout.isTTY && !process.env.NO_COLOR;
+const c = (code) => s => tty ? `\x1b[${code}m${s}\x1b[0m` : String(s);
+const C = { b: c('1'), dim: c('2'), pink: c('38;5;205'), yellow: c('38;5;220'), mint: c('38;5;49'), blue: c('38;5;69'), red: c('31'), gray: c('90') };
+
+const HELP = `
+${C.b('howamiprompting')} — Spotify Wrapped for your AI coding prompts
+
+${C.b('Usage')}
+  npx howamiprompting [options]
+
+${C.b('Options')}
+  --agent <id>        AI to use for the deep analysis: claude | codex | gemini | anthropic | openrouter | openai | ollama
+  --model <name>      Model override for that agent (e.g. haiku, sonnet, gpt-5-mini)
+  --no-ai             Local stats only — nothing leaves your machine
+  --sample <n>        Prompts sent for deep analysis (default 180)
+  --since <days>      Only look at the last N days
+  --include <file>    Also import a chat export (repeatable)
+  --roots <dir>       Extra folder to search for Aider / SpecStory histories (repeatable)
+  --last              Re-open your last report without rescanning
+  --json <file>       Also write the report as JSON
+  --port <n>          Port for the local report (default: random)
+  --no-open           Don't open the browser
+  -y, --yes           Don't ask questions (use the first available agent)
+  -v, --version       Print version
+
+${C.b('Privacy')}
+  Everything is read locally. Only with an AI agent are ~180 sampled prompts (secrets redacted)
+  sent — through YOUR OWN Claude Code / Codex / Gemini / API key, never to us.
+`;
+
+function parseArgs(argv) {
+  const o = { include: [], roots: [], ai: true, open: true, sample: 180, yes: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i], next = () => argv[++i];
+    if (a === '--agent') o.agent = next();
+    else if (a === '--model') o.model = next();
+    else if (a === '--no-ai') o.ai = false;
+    else if (a === '--sample') o.sample = Math.max(20, Math.min(1000, +next() || 180));
+    else if (a === '--since') o.since = +next() || undefined;
+    else if (a === '--include') o.include.push(next());
+    else if (a === '--roots') o.roots.push(next());
+    else if (a === '--last') o.last = true;
+    else if (a === '--json') o.json = next();
+    else if (a === '--port') o.port = +next() || 0;
+    else if (a === '--no-open') o.open = false;
+    else if (a === '-y' || a === '--yes') o.yes = true;
+    else if (a === '-h' || a === '--help') o.help = true;
+    else if (a === '-v' || a === '--version') o.version = true;
+  }
+  return o;
+}
+
+function spinner(text) {
+  if (!tty) { process.stdout.write('  ' + text + '\n'); return { update() {}, stop(t) { if (t) console.log('  ' + t); } }; }
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0, cur = text;
+  const t0 = Date.now();
+  const id = setInterval(() => { process.stdout.write(`\r\x1b[K  ${C.pink(frames[i++ % frames.length])} ${cur} ${C.gray(Math.round((Date.now() - t0) / 1000) + 's')}`); }, 90);
+  return {
+    update(t) { cur = t; },
+    stop(final) { clearInterval(id); process.stdout.write('\r\x1b[K'); if (final) console.log('  ' + final); },
+  };
+}
+
+function ask(q) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(r => rl.question(q, a => { rl.close(); r(a.trim()); }));
+}
+
+export function openBrowser(url) {
+  const cmd = process.platform === 'darwin' ? ['open', [url]] : process.platform === 'win32' ? ['cmd', ['/c', 'start', '""', url.replace(/&/g, '^&')]] : ['xdg-open', [url]];
+  try { spawn(cmd[0], cmd[1], { stdio: 'ignore', detached: true }).unref(); } catch {}
+}
+
+const bar = (v, w = 20) => { const n = Math.round(v / 100 * w); return C.mint('█'.repeat(n)) + C.gray('░'.repeat(w - n)); };
+
+export async function main(argv) {
+  const o = parseArgs(argv);
+  if (o.help) return console.log(HELP);
+  if (o.version) return console.log(VERSION);
+
+  console.log(`\n  ${C.b(C.pink('how am i prompting?'))} ${C.gray('v' + VERSION)}\n  ${C.gray('Spotify Wrapped for your AI coding prompts')}\n`);
+
+  let bundle, prompts = [];
+  if (o.last) {
+    bundle = lastReport();
+    if (!bundle) { console.log(C.red('  No saved report yet — run without --last first.')); process.exit(1); }
+    console.log(C.gray(`  Re-opening your report from ${new Date(bundle.generatedAt).toLocaleString()}\n`));
+  } else {
+    // 1. Scan
+    console.log(C.b('  1. Finding your prompts') + C.gray('  (read-only, nothing leaves your machine)'));
+    const sp = spinner('Scanning…');
+    const found = [];
+    const raw = await collectAll({ include: o.include, roots: o.roots }, (name, n, err) => {
+      sp.update(`Scanning… ${name}`);
+      found.push({ name, n, err: err?.message });
+    });
+    sp.stop();
+    for (const f of found) console.log(`     ${f.n > 0 ? C.mint('✔') : C.gray('·')} ${f.name.padEnd(48)} ${f.n > 0 ? C.b(f.n.toLocaleString()) : C.gray(f.n < 0 ? 'error' : 'none')}`);
+    const cl = clean(raw, { since: o.since });
+    prompts = cl.prompts;
+    if (!prompts.length) {
+      console.log(C.yellow('\n  No prompts found. Supported: Claude Code, Codex, Gemini CLI, Cursor, VS Code Copilot, Windsurf, Cline, Roo, Kilo, Continue, OpenCode, Aider, SpecStory.'));
+      console.log(C.gray('  Have an export file? Run: npx howamiprompting --include path/to/chat.md\n'));
+      process.exit(1);
+    }
+    const stats = computeStats(prompts, { interrupts: cl.interrupts });
+    const t = stats.totals;
+    console.log(`\n     ${C.b(t.prompts.toLocaleString())} prompts · ${C.b(t.sessions.toLocaleString())} sessions · ${C.b(t.projects)} projects · ${C.b(t.tools)} tools`);
+    console.log(`     You are ${C.b(C.yellow(stats.persona.emoji + ' ' + stats.persona.name))}\n`);
+
+    // 2. Agent
+    let agent = null;
+    if (o.ai) {
+      console.log(C.b('  2. Deep analysis with your own AI'));
+      const agents = await detectAgents();
+      if (o.agent) {
+        agent = agents.find(a => a.id === o.agent) || (AGENTS[o.agent] ? { id: o.agent, label: AGENTS[o.agent].label, privacy: AGENTS[o.agent].privacy } : null);
+        if (!agent) console.log(C.yellow(`     Unknown agent "${o.agent}".`));
+      } else if (!agents.length) {
+        console.log(C.gray('     No AI agent found (Claude Code, Codex, Gemini CLI, an API key or Ollama).'));
+        console.log(C.gray('     Showing local stats only. Install one and re-run for scores, makeovers & coaching.\n'));
+      } else if (agents.length === 1 || o.yes || !process.stdin.isTTY) {
+        agent = agents[0];
+      } else {
+        agents.forEach((a, i) => console.log(`     ${C.b(i + 1)}. ${a.label} ${C.gray('— ' + a.detail)}`));
+        const ans = await ask(`     Which one? ${C.gray('[1]')} `);
+        agent = agents[(parseInt(ans, 10) || 1) - 1] || agents[0];
+      }
+      if (agent && !o.yes && process.stdin.isTTY) {
+        const n = Math.min(o.sample, prompts.filter(p => p.words >= 3).length);
+        console.log(`     ${C.gray('About')} ${C.b(n)} ${C.gray('sampled prompts (secrets redacted) will be sent to')} ${C.b(agent.privacy)}.`);
+        console.log(C.gray(`     It usually takes 1–4 minutes and uses a little of your ${agent.label} quota.`));
+        const ans = (await ask(`     Continue? ${C.gray('[Y/n]')} `)).toLowerCase();
+        if (ans === 'n' || ans === 'no') agent = null;
+      }
+    }
+
+    let ai = null, aiError = null;
+    if (agent) {
+      const sp2 = spinner(`Asking ${agent.label} to read your prompts…`);
+      try {
+        ai = await analyze(prompts, stats, {
+          agent: agent.id, model: o.model, sampleSize: o.sample, concurrency: AGENTS[agent.id].kind === 'cli' ? 2 : 3,
+          onStep: (label) => sp2.update(`${agent.label}: ${label}…`),
+        });
+        sp2.stop(`${C.mint('✔')} Analysed ${ai.sampled} prompts with ${agent.label}`);
+      } catch (e) {
+        aiError = e.message;
+        sp2.stop(`${C.yellow('!')} ${agent.label} analysis failed: ${C.gray(e.message.slice(0, 160))} — showing local stats.`);
+      }
+    }
+
+    const scores = ai ? ai.scores : { ...stats.heuristic, overall: overallFrom(stats.heuristic) };
+    bundle = {
+      version: VERSION, generatedAt: new Date().toISOString(),
+      agent: agent ? { id: agent.id, label: agent.label } : null, aiError,
+      sources: found.filter(f => f.n > 0).map(f => ({ name: f.name, count: f.n })),
+      scores, stats, ai,
+    };
+    saveReport(bundle);
+    if (o.json) { fs.writeFileSync(path.resolve(o.json), JSON.stringify(bundle, null, 2)); console.log(C.gray(`     Saved ${o.json}`)); }
+
+    console.log(`\n  ${C.b('Your prompting score:')} ${C.b(C.pink(scores.overall))}${C.gray('/100')}  ${ai?.level ? C.gray('(' + ai.level + ')') : ''}`);
+    for (const k of ['clarity', 'context', 'specificity', 'structure', 'efficiency', 'english']) console.log(`     ${k.padEnd(12)} ${bar(scores[k])} ${scores[k]}`);
+    if (ai?.headline) console.log(`\n     ${C.yellow('“' + ai.headline + '”')}`);
+  }
+
+  // 3. Report UI
+  const agentId = bundle.agent?.id || null;
+  const { url } = await startServer({ bundle, prompts, agent: agentId, model: o.model, port: o.port || 0 });
+  console.log(`\n  ${C.b('3. Your report is live:')} ${C.blue(url)}`);
+  console.log(C.gray('     Practice games, prompt makeovers and your share card are in there.'));
+  console.log(C.gray('     Press Ctrl+C to quit.  ⭐ Like it? github.com/theavijitsarkar/howamiprompting\n'));
+  if (o.open) openBrowser(url);
+}

package/src/collect/claude.js

@@ -0,0 +1,44 @@
+// Claude Code — ~/.claude/projects/<project>/<session>.jsonl
+import path from 'node:path';
+import { HOME, find, isDir, jsonl, projectName } from '../util.js';
+
+export const id = 'claude-code';
+export const name = 'Claude Code';
+
+function roots() {
+  return [process.env.CLAUDE_CONFIG_DIR, path.join(HOME, '.claude'), path.join(HOME, '.config', 'claude')]
+    .filter(Boolean).map(r => path.join(r, 'projects')).filter(isDir);
+}
+
+const textOf = c => typeof c === 'string' ? c
+  : Array.isArray(c) ? c.filter(p => p && p.type === 'text').map(p => p.text).join('\n') : '';
+
+export async function collect() {
+  const out = [];
+  const seen = new Set();
+  for (const root of roots()) {
+    const files = await find(root, p => p.endsWith('.jsonl'), { depth: 3 });
+    for (const f of files) {
+      let lastAssistant = '';
+      for await (const o of jsonl(f)) {
+        if (o.isSidechain) continue; // sub-agent traffic, not written by the human
+        const msg = o.message;
+        if (o.type === 'assistant' && msg) { const t = textOf(msg.content); if (t) lastAssistant = t; continue; }
+        if (o.type !== 'user' || !msg || msg.role !== 'user' || o.isMeta || o.isCompactSummary) continue;
+        if (Array.isArray(msg.content) && msg.content.every(p => p.type === 'tool_result')) continue;
+        const text = textOf(msg.content);
+        if (!text) continue;
+        const key = (o.sessionId || f) + '|' + (o.uuid || text.slice(0, 80));
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push({
+          tool: name, session: o.sessionId || path.basename(f, '.jsonl'),
+          project: projectName(o.cwd) || path.basename(path.dirname(f)).replace(/^-/, '').split('-').pop(),
+          ts: o.timestamp || null, text, context: lastAssistant.slice(-400),
+          kind: /^\[Request interrupted/.test(text) ? 'interrupt' : undefined,
+        });
+      }
+    }
+  }
+  return out;
+}

package/src/collect/codex.js

@@ -0,0 +1,36 @@
+// OpenAI Codex CLI — ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
+import path from 'node:path';
+import { HOME, find, isDir, jsonl, projectName } from '../util.js';
+
+export const id = 'codex';
+export const name = 'Codex';
+
+const textOf = c => typeof c === 'string' ? c
+  : Array.isArray(c) ? c.filter(p => p && /text/.test(p.type || 'text') && typeof p.text === 'string').map(p => p.text).join('\n') : '';
+
+export async function collect() {
+  const root = path.join(process.env.CODEX_HOME || path.join(HOME, '.codex'), 'sessions');
+  if (!isDir(root)) return [];
+  const out = [];
+  const files = await find(root, p => /\.jsonl$/.test(p), { depth: 5 });
+  for (const f of files) {
+    let session = path.basename(f, '.jsonl'), cwd = null, lastAssistant = '';
+    const seen = new Set();
+    for await (const o of jsonl(f)) {
+      const p = o.payload || o;
+      if (o.type === 'session_meta') { session = p.id || session; cwd = p.cwd || cwd; continue; }
+      if (p.type === 'turn_context' || o.type === 'turn_context') { cwd = p.cwd || cwd; continue; }
+      let text = null;
+      if (p.type === 'message' && p.role === 'assistant') { const t = textOf(p.content); if (t) lastAssistant = t; continue; }
+      if (p.type === 'message' && p.role === 'user') text = textOf(p.content);
+      else if (o.type === 'event_msg' && p.type === 'user_message') text = p.message;
+      if (!text) continue;
+      if (/^\s*<(environment_context|user_instructions|permissions|turn_aborted)/.test(text) || /^# AGENTS\.md/.test(text)) continue;
+      const key = text.trim();
+      if (seen.has(key)) continue; // response_item + event_msg duplicates
+      seen.add(key);
+      out.push({ tool: name, session, project: projectName(cwd), ts: o.timestamp || null, text, context: lastAssistant.slice(-400) });
+    }
+  }
+  return out;
+}

package/src/collect/gemini.js

@@ -0,0 +1,31 @@
+// Google Gemini CLI — ~/.gemini/tmp/<project-hash>/{logs.json, chats/*.json}
+import path from 'node:path';
+import { HOME, find, isDir, readJson } from '../util.js';
+
+export const id = 'gemini-cli';
+export const name = 'Gemini CLI';
+
+export async function collect() {
+  const root = path.join(HOME, '.gemini', 'tmp');
+  if (!isDir(root)) return [];
+  const out = [];
+  const seen = new Set();
+  const push = (r) => { const k = r.session + '|' + r.text.slice(0, 120); if (!seen.has(k)) { seen.add(k); out.push(r); } };
+  const files = await find(root, p => p.endsWith('.json'), { depth: 3 });
+  for (const f of files) {
+    const j = await readJson(f);
+    if (!j) continue;
+    const project = path.basename(path.dirname(f)) === 'chats' ? path.basename(path.dirname(path.dirname(f))).slice(0, 8) : path.basename(path.dirname(f)).slice(0, 8);
+    if (Array.isArray(j)) { // logs.json
+      for (const m of j) if (m && m.type === 'user' && typeof m.message === 'string') push({ tool: name, session: m.sessionId || f, project: 'gemini-' + project, ts: m.timestamp, text: m.message, context: '' });
+    } else if (Array.isArray(j.messages)) { // chats/session-*.json
+      let last = '';
+      for (const m of j.messages) {
+        const t = typeof m.content === 'string' ? m.content : Array.isArray(m.content) ? m.content.map(x => x.text || '').join('\n') : (m.parts || []).map(x => x.text || '').join('\n');
+        if (m.type === 'user' || m.role === 'user') { if (t) push({ tool: name, session: j.sessionId || f, project: 'gemini-' + project, ts: m.timestamp || j.startTime, text: t, context: last.slice(-400) }); }
+        else if (t) last = t;
+      }
+    }
+  }
+  return out;
+}

package/src/collect/generic.js

@@ -0,0 +1,42 @@
+// Generic importer for files passed with --include (exports from any chat tool, markdown, JSON, JSONL, plain text)
+const SKIP = ['<command-', '<local-command', '<environment_context', '<user_instructions', '<system-reminder', 'Caveat:', '[Request interrupted', '# AGENTS.md'];
+const keep = t => typeof t === 'string' && t.trim().length > 3 && !SKIP.some(p => t.trim().startsWith(p));
+const textOf = c => typeof c === 'string' ? c : Array.isArray(c) ? c.filter(x => x && (x.type === 'text' || x.type === 'input_text' || (!x.type && typeof x.text === 'string'))).map(x => x.text).join('\n') : (c && typeof c.text === 'string' ? c.text : '');
+
+function walk(node, out, d = 0) {
+  if (!node || d > 14 || typeof node !== 'object') return;
+  if (Array.isArray(node)) return node.forEach(n => walk(n, out, d + 1));
+  const role = String(node.role || node.author?.role || node.sender || '').toLowerCase();
+  if (['user', 'human'].includes(role) || ['user', 'human', 'user_message'].includes(String(node.type || '').toLowerCase())) {
+    const t = textOf(node.content ?? node.text ?? node.message ?? node.content?.parts?.join?.('\n'));
+    if (keep(t)) { out.push(t); return; }
+  }
+  for (const k in node) if (node[k] && typeof node[k] === 'object') walk(node[k], out, d + 1);
+}
+
+export function parseAny(raw, filename = '') {
+  raw = raw.replace(/^/, '').trim();
+  const out = [];
+  const first = raw.split(/\r?\n/, 1)[0];
+  if (/\.jsonl$/i.test(filename) || (first.startsWith('{') && raw.includes('\n{'))) {
+    for (const l of raw.split(/\r?\n/)) { try { walk(JSON.parse(l), out); } catch {} }
+    if (out.length) return out;
+  }
+  if (/\.json$/i.test(filename) || raw.startsWith('{') || raw.startsWith('[')) {
+    try { walk(JSON.parse(raw), out); if (out.length) return out; } catch {}
+  }
+  const USER = /^\s*(?:#{1,6}\s*)?(?:_?\*\*_?\s*)?(user|you|human|me|prompt)\b[^\n]{0,30}$/i;
+  const BOT = /^\s*(?:#{1,6}\s*)?(?:_?\*\*_?\s*)?(assistant|cursor|claude|ai|model|gemini|agent|codex|copilot|bot|chatgpt|cascade)\b[^\n]{0,30}$/i;
+  let mode = null, buf = [], saw = false;
+  const flush = () => { if (mode === 'user' && keep(buf.join('\n'))) out.push(buf.join('\n').trim()); buf = []; };
+  for (const line of raw.split(/\r?\n/)) {
+    const inl = line.match(/^\s*(user|you|human|me)\s*:\s*(.+)$/i);
+    if (inl) { flush(); saw = true; mode = 'user'; buf.push(inl[2]); continue; }
+    if (USER.test(line)) { flush(); saw = true; mode = 'user'; continue; }
+    if (BOT.test(line) || /^\s*(assistant|ai|claude)\s*:/i.test(line)) { flush(); saw = true; mode = 'bot'; continue; }
+    if (mode === 'user') buf.push(line);
+  }
+  flush();
+  if (!saw) (/\n\s*\n/.test(raw) ? raw.split(/\n\s*\n/) : raw.split(/\r?\n/)).forEach(p => keep(p) && out.push(p.trim()));
+  return out;
+}

package/src/collect/index.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import * as claude from './claude.js';
+import * as codex from './codex.js';
+import * as gemini from './gemini.js';
+import * as vscode from './vscode.js';
+import { continueDev, opencode, projectFiles } from './others.js';
+import { readText } from '../util.js';
+import { parseAny } from './generic.js';
+
+export const SOURCES = [
+  { name: 'Claude Code', run: () => claude.collect() },
+  { name: 'Codex', run: () => codex.collect() },
+  { name: 'Gemini CLI', run: () => gemini.collect() },
+  { name: 'Cursor · Copilot · Windsurf · Cline · Roo · Kilo', run: () => vscode.collect() },
+  { name: 'Continue', run: () => continueDev() },
+  { name: 'OpenCode', run: () => opencode() },
+  { name: 'Aider · SpecStory', run: o => projectFiles(o.roots || []) },
+];
+
+/** Collect raw prompt records from every source. onProgress(sourceName, count|error). */
+export async function collectAll(opts = {}, onProgress = () => {}) {
+  const all = [];
+  for (const s of SOURCES) {
+    try {
+      const recs = await s.run(opts);
+      all.push(...recs);
+      onProgress(s.name, recs.length);
+    } catch (e) {
+      onProgress(s.name, -1, e);
+    }
+  }
+  for (const f of opts.include || []) {
+    const t = await readText(path.resolve(f));
+    if (t == null) { onProgress('file ' + f, -1, new Error('unreadable')); continue; }
+    const recs = parseAny(t, f).map(text => ({ tool: 'Imported', session: path.basename(f), project: null, ts: null, text, context: '' }));
+    all.push(...recs);
+    onProgress(path.basename(f), recs.length);
+  }
+  return all;
+}

package/src/collect/others.js

@@ -0,0 +1,79 @@
+// Continue.dev, OpenCode, Aider and SpecStory (Cursor history saved inside projects)
+import fs from 'node:fs';
+import path from 'node:path';
+import { HOME, find, isDir, readJson, readText, projectName } from '../util.js';
+
+export async function continueDev() {
+  const dir = path.join(HOME, '.continue', 'sessions');
+  if (!isDir(dir)) return [];
+  const out = [];
+  for (const f of fs.readdirSync(dir).filter(f => f.endsWith('.json') && f !== 'sessions.json')) {
+    const j = await readJson(path.join(dir, f));
+    let last = '';
+    for (const h of j?.history || []) {
+      const m = h.message || h;
+      const t = typeof m.content === 'string' ? m.content : Array.isArray(m.content) ? m.content.map(p => p.text || '').join('\n') : '';
+      if (m.role === 'user' && t) out.push({ tool: 'Continue', session: j.sessionId || f, project: projectName(j.workspaceDirectory), ts: j.dateCreated || null, text: t, context: last.slice(-400) });
+      else if (t) last = t;
+    }
+  }
+  return out;
+}
+
+export async function opencode() {
+  const base = path.join(process.env.XDG_DATA_HOME || path.join(HOME, '.local', 'share'), 'opencode', 'storage');
+  const msgDir = path.join(base, 'message'), partDir = path.join(base, 'part');
+  if (!isDir(msgDir) || !isDir(partDir)) return [];
+  const out = [];
+  const files = await find(msgDir, p => p.endsWith('.json'), { depth: 2 });
+  const msgs = [];
+  for (const f of files) { const m = await readJson(f); if (m?.id) msgs.push(m); }
+  msgs.sort((a, b) => (a.time?.created || 0) - (b.time?.created || 0));
+  const last = new Map();
+  for (const m of msgs) {
+    const pd = path.join(partDir, m.id);
+    if (!isDir(pd)) continue;
+    let text = '';
+    for (const pf of fs.readdirSync(pd)) { const p = await readJson(path.join(pd, pf)); if (p?.type === 'text' && !p.synthetic) text += (text ? '\n' : '') + (p.text || ''); }
+    if (!text) continue;
+    if (m.role === 'user') out.push({ tool: 'OpenCode', session: m.sessionID, project: projectName(m.path?.cwd || m.path?.root), ts: m.time?.created, text, context: (last.get(m.sessionID) || '').slice(-400) });
+    else last.set(m.sessionID, text);
+  }
+  return out;
+}
+
+/** Aider + SpecStory files live inside projects, so we search likely code folders (bounded). */
+export async function projectFiles(extraRoots = []) {
+  const roots = [...new Set([...extraRoots, ...['code', 'Code', 'projects', 'Projects', 'dev', 'Developer', 'src', 'work', 'repos', 'git', 'GitHub', 'Sites', 'workspace', 'Documents', 'Desktop'].map(d => path.join(HOME, d)), HOME])].filter(isDir);
+  const out = [];
+  const seen = new Set();
+  for (const r of roots) {
+    const files = await find(r, (p, n) => n === '.aider.chat.history.md' || (/\.md$/.test(n) && p.includes(path.join('.specstory', 'history'))), { depth: r === HOME ? 3 : 5, limit: 3000, skipDirs: new Set([...SKIP_NO_DOT]) });
+    for (const f of files) {
+      if (seen.has(f)) continue; seen.add(f);
+      const t = await readText(f, 50 * 1024 * 1024);
+      if (!t) continue;
+      if (f.endsWith('.aider.chat.history.md')) {
+        const project = projectName(path.dirname(f));
+        let session = 0, cur = [];
+        const flush = () => { if (cur.length) out.push({ tool: 'Aider', session: project + '-' + session, project, ts: null, text: cur.join('\n'), context: '' }); cur = []; };
+        for (const line of t.split(/\r?\n/)) {
+          if (line.startsWith('# aider chat started at')) { flush(); session++; continue; }
+          if (line.startsWith('#### ')) cur.push(line.slice(5)); else flush();
+        }
+        flush();
+      } else {
+        const project = projectName(path.dirname(path.dirname(path.dirname(f))));
+        const parts = t.split(/^_\*\*(User|Assistant)\*\*_\s*$/m);
+        let last = '';
+        for (let i = 1; i < parts.length; i += 2) {
+          const body = (parts[i + 1] || '').replace(/^\s*---\s*$/gm, '').trim();
+          if (parts[i] === 'User' && body) out.push({ tool: 'Cursor (SpecStory)', session: path.basename(f), project, ts: null, text: body, context: last.slice(-400) });
+          else last = body;
+        }
+      }
+    }
+  }
+  return out;
+}
+const SKIP_NO_DOT = ['node_modules', '.git', 'Library', '.Trash', 'vendor', 'dist', 'build', '.next', '.venv', 'venv', '__pycache__', 'Pods', 'DerivedData', '.npm', '.cargo', '.rustup', 'go', '.gradle', '.m2', 'Applications', 'Music', 'Movies', 'Pictures', '.docker', 'AppData', 'snap', '.cache', '.local', '.vscode', '.cursor', 'Downloads'];