truememory-mirror 1.0.0

package/bin/mirror.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+
+import { scan } from '../src/scanner.js';
+import { parseClaudeCodeSession } from '../src/parsers/claude-code.js';
+import { parseCodexSession } from '../src/parsers/codex.js';
+import { sanitizeMessages } from '../src/sanitizer.js';
+import { unifyMessages } from '../src/unified.js';
+import { submitForExtraction, pollStatus } from '../src/api-client.js';
+import { exec } from 'child_process';
+
+const VERSION = '1.0.0';
+const DEFAULT_API_URL = 'https://truememory-mirror.vercel.app';
+
+function parseArgs(argv) {
+  const args = {
+    limit: 500,
+    source: 'all',
+    json: false,
+    noOpen: false,
+    delete: null,
+    apiUrl: DEFAULT_API_URL,
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    switch (argv[i]) {
+      case '--limit':
+        args.limit = parseInt(argv[++i], 10) || 500;
+        break;
+      case '--source':
+        args.source = argv[++i] || 'all';
+        break;
+      case '--json':
+        args.json = true;
+        break;
+      case '--no-open':
+        args.noOpen = true;
+        break;
+      case '--delete':
+        args.delete = argv[++i];
+        break;
+      case '--api-url':
+        args.apiUrl = argv[++i] || DEFAULT_API_URL;
+        break;
+      case '--help':
+      case '-h':
+        printHelp();
+        process.exit(0);
+    }
+  }
+  return args;
+}
+
+function printHelp() {
+  write(`
+  TrueMemory Mirror v${VERSION}
+
+  Usage: npx truememory-mirror [options]
+
+  Options:
+    --limit <n>        Max sessions to analyze (default: 500)
+    --source <type>    claude, codex, or all (default: all)
+    --json             Output raw profile JSON instead of opening browser
+    --no-open          Don't open browser automatically
+    --delete <id>      Delete a profile by ID
+    --api-url <url>    API endpoint (default: ${DEFAULT_API_URL})
+    -h, --help         Show this help
+`);
+}
+
+let _jsonMode = false;
+
+function write(text) {
+  if (!_jsonMode) process.stderr.write(text);
+}
+
+function clearLine() {
+  if (!_jsonMode) process.stderr.write('\r\x1b[K');
+}
+
+function progressBar(pct, width = 25) {
+  const filled = Math.round(pct * width);
+  const empty = width - filled;
+  return '█'.repeat(filled) + '░'.repeat(empty);
+}
+
+function openBrowser(url) {
+  const cmd = process.platform === 'darwin' ? 'open'
+    : process.platform === 'win32' ? 'start ""'
+    : 'xdg-open';
+  exec(`${cmd} "${url}"`, () => {});
+}
+
+async function handleDelete(id, apiUrl) {
+  const resp = await fetch(`${apiUrl}/api/profile/${id}`, { method: 'DELETE' });
+  if (resp.ok) {
+    write(`  ✓ Profile ${id} deleted.\n`);
+  } else {
+    write(`  ✗ Failed to delete profile ${id} (${resp.status})\n`);
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+
+  _jsonMode = args.json;
+
+  write(`\n  TrueMemory Mirror v${VERSION}\n\n`);
+
+  if (args.delete) {
+    await handleDelete(args.delete, args.apiUrl);
+    return;
+  }
+
+  // Step 1: Scan
+  write('  Scanning for AI conversations...\n');
+  const sources = await scan(args.source);
+
+  let claudeSessions = [];
+  let codexSessions = [];
+
+  // Step 2: Parse Claude Code
+  if (sources.claude_code) {
+    const files = sources.claude_code.sessions;
+    write(`  Parsing Claude Code sessions (${files.length} found)...\n`);
+    const parseLimit = Math.min(files.length, args.limit);
+    for (let i = 0; i < parseLimit; i++) {
+      try {
+        const session = await parseClaudeCodeSession(files[i].path);
+        if (session.messages.length > 0) {
+          claudeSessions.push(session);
+        }
+      } catch {
+        // skip unparseable sessions
+      }
+    }
+    write(`  ✓ Claude Code — ${claudeSessions.length} conversations (~/.claude/)\n`);
+  } else {
+    write('  – Claude Code — not found\n');
+  }
+
+  // Step 3: Parse Codex
+  if (sources.codex) {
+    const files = sources.codex.sessions;
+    write(`  Parsing Codex CLI sessions (${files.length} found)...\n`);
+    const parseLimit = Math.min(files.length, args.limit);
+    for (let i = 0; i < parseLimit; i++) {
+      try {
+        const session = await parseCodexSession(files[i].path);
+        if (session.messages.length > 0) {
+          codexSessions.push(session);
+        }
+      } catch {
+        // skip unparseable sessions
+      }
+    }
+    write(`  ✓ Codex CLI — ${codexSessions.length} conversations (~/.codex/)\n`);
+  } else {
+    write('  – Codex CLI — not found\n');
+  }
+
+  const totalSessions = claudeSessions.length + codexSessions.length;
+  if (totalSessions === 0) {
+    write('\n  No AI conversations found. Make sure you have Claude Code or Codex CLI installed.\n\n');
+    process.exit(1);
+  }
+
+  // Warn if too few messages
+  const totalMessages = claudeSessions.reduce((s, c) => s + c.messages.length, 0)
+    + codexSessions.reduce((s, c) => s + c.messages.length, 0);
+
+  if (totalMessages < 50) {
+    write(`\n  ⚠ Found only ${totalMessages} messages. For a meaningful profile,\n`);
+    write('    we recommend 100+ conversations. Results may be sparse.\n');
+  }
+
+  write(`  ${'─'.repeat(40)}\n`);
+  write(`  Total: ${totalSessions} conversations`);
+  if (totalSessions > args.limit) {
+    write(` (using most recent ${args.limit})`);
+  }
+  write('\n\n');
+
+  // Step 4: Sanitize & unify
+  for (const session of claudeSessions) {
+    session.messages = sanitizeMessages(session.messages);
+  }
+  for (const session of codexSessions) {
+    session.messages = sanitizeMessages(session.messages);
+  }
+
+  const payload = unifyMessages(claudeSessions, codexSessions, args.limit);
+
+  if (args.json) {
+    process.stdout.write(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  // Step 5: Submit
+  write('  Uploading & extracting identity traits...\n');
+
+  let result;
+  try {
+    result = await submitForExtraction(payload, args.apiUrl);
+  } catch (err) {
+    write(`\n  ✗ Upload failed: ${err.message}\n\n`);
+    process.exit(1);
+  }
+
+  // Step 6: Poll for status
+  try {
+    await pollStatus(result.profile_id, args.apiUrl, (status) => {
+      const pct = status.progress || 0;
+      const bar = progressBar(pct);
+      let statusText = '';
+
+      if (status.status === 'queued') {
+        statusText = `Position ${status.queue_position || '?'} in queue`;
+      } else if (status.status === 'extracting') {
+        statusText = `Extracting traits`;
+        if (status.claims_found) {
+          statusText += ` (${status.claims_found} claims found)`;
+        }
+      } else if (status.status === 'consolidating') {
+        statusText = 'Building profile';
+      } else if (status.status === 'predicting') {
+        statusText = 'Running scenario predictions';
+      }
+
+      clearLine();
+      write(`  ${bar} ${Math.round(pct * 100)}%  ${statusText}`);
+    });
+  } catch (err) {
+    write(`\n\n  ✗ Extraction failed: ${err.message}\n\n`);
+    process.exit(1);
+  }
+
+  clearLine();
+  write(`  ${progressBar(1.0)} 100%\n\n`);
+  write(`  ✓ Your identity mirror is ready.\n`);
+  write(`  → ${result.url}\n\n`);
+
+  if (!args.noOpen) {
+    openBrowser(result.url);
+  }
+}
+
+main().catch(err => {
+  process.stderr.write(`\n  Error: ${err.message}\n\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "truememory-mirror",
+  "version": "1.0.0",
+  "description": "See yourself through your AI conversations",
+  "bin": {
+    "truememory-mirror": "./bin/mirror.js"
+  },
+  "files": ["bin/", "src/"],
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": ["ai", "identity", "personality", "claude", "codex", "truememory"],
+  "author": "Josh Adler <buildingjoshbetter@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/buildingjoshbetter/truememory-mirror"
+  }
+}

package/src/api-client.js

@@ -0,0 +1,36 @@
+const POLL_INTERVAL_MS = 3000;
+
+export async function submitForExtraction(payload, apiUrl) {
+  const body = JSON.stringify(payload);
+  const response = await fetch(`${apiUrl}/api/extract`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body,
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`API error (${response.status}): ${error}`);
+  }
+
+  return response.json();
+}
+
+export async function pollStatus(profileId, apiUrl, onUpdate) {
+  while (true) {
+    const response = await fetch(`${apiUrl}/api/profile/${profileId}/status`);
+    if (!response.ok) {
+      throw new Error(`Status check failed (${response.status})`);
+    }
+
+    const status = await response.json();
+    if (onUpdate) onUpdate(status);
+
+    if (status.status === 'ready') return status;
+    if (status.status === 'failed') {
+      throw new Error(`Extraction failed: ${status.error || 'unknown error'}`);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+}

package/src/parsers/claude-code.js

@@ -0,0 +1,59 @@
+import { readFile } from 'fs/promises';
+import { basename, dirname } from 'path';
+
+function deriveProject(dirPath) {
+  const dirName = basename(dirPath);
+  if (!dirName.startsWith('-')) return dirName;
+  return '/' + dirName.slice(1).replace(/-/g, '/');
+}
+
+function extractContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter(item => item.type === 'text')
+      .map(item => item.text)
+      .join('\n');
+  }
+  return '';
+}
+
+export async function parseClaudeCodeSession(filePath) {
+  const raw = await readFile(filePath, 'utf-8');
+  const lines = raw.split('\n').filter(l => l.trim());
+  const project = deriveProject(dirname(filePath));
+  const sessionId = basename(filePath, '.jsonl');
+  const messages = [];
+
+  for (const line of lines) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    if (obj.type !== 'user' && obj.type !== 'assistant') continue;
+    if (obj.isSidechain === true) continue;
+
+    const msg = obj.message;
+    if (!msg) continue;
+
+    const content = extractContent(msg.content);
+    if (!content) continue;
+    if (content.includes('[[TRUEMEMORY_INTERNAL_EXTRACTION]]')) continue;
+
+    messages.push({
+      role: msg.role || obj.type,
+      content,
+      timestamp: obj.timestamp || '',
+    });
+  }
+
+  return {
+    session_id: sessionId,
+    source: 'claude_code',
+    project,
+    messages,
+  };
+}

package/src/parsers/codex.js

@@ -0,0 +1,70 @@
+import { readFile } from 'fs/promises';
+import { basename } from 'path';
+
+function extractOutputText(content) {
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter(item => item.type === 'output_text')
+    .map(item => item.text)
+    .join('\n');
+}
+
+export async function parseCodexSession(filePath) {
+  const raw = await readFile(filePath, 'utf-8');
+  const lines = raw.split('\n').filter(l => l.trim());
+  let sessionId = basename(filePath, '.jsonl');
+  let project = '';
+  const messages = [];
+
+  for (const line of lines) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    if (obj.type === 'session_meta' && obj.payload) {
+      if (obj.payload.id) sessionId = obj.payload.id;
+      if (obj.payload.cwd) project = obj.payload.cwd;
+      continue;
+    }
+
+    if (obj.type === 'event_msg' && obj.payload?.type === 'user_message') {
+      const content = obj.payload.message;
+      if (typeof content === 'string' && content.length > 0) {
+        messages.push({
+          role: 'user',
+          content,
+          timestamp: obj.timestamp || '',
+        });
+      }
+      continue;
+    }
+
+    if (obj.type === 'response_item' && obj.payload) {
+      if (obj.payload.role === 'developer') continue;
+      if (obj.payload.role === 'user') {
+        const text = extractOutputText(obj.payload.content || []);
+        if (text.startsWith('<environment_context>')) continue;
+      }
+      if (obj.payload.role === 'assistant') {
+        const text = extractOutputText(obj.payload.content || []);
+        if (text) {
+          messages.push({
+            role: 'assistant',
+            content: text,
+            timestamp: obj.timestamp || '',
+          });
+        }
+      }
+    }
+  }
+
+  return {
+    session_id: sessionId,
+    source: 'codex',
+    project,
+    messages,
+  };
+}

package/src/sanitizer.js

@@ -0,0 +1,64 @@
+export function sanitize(text) {
+  // --- Paths ---
+  text = text.replace(/\/Users\/[^\s"']+/g, (match) => {
+    const parts = match.split('/');
+    return parts.length > 3 ? '[PATH]/' + parts.slice(-2).join('/') : '[PATH]';
+  });
+  text = text.replace(/[A-Z]:\\Users\\[^\s"']+/gi, '[PATH]');
+  text = text.replace(/\/home\/[^\s"']+/g, '[PATH]');
+  text = text.replace(/~\/[^\s"']+/g, '[PATH]');
+  text = text.replace(/\/Volumes\/[^\s"']+/g, '[PATH]');
+
+  // --- Emails ---
+  text = text.replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL]');
+
+  // --- IPs ---
+  text = text.replace(/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(:\d+)?\b/g, (match) => {
+    if (match.startsWith('127.0.0.1') || match.startsWith('0.0.0.0') || match.startsWith('localhost')) return match;
+    return '[IP]';
+  });
+  text = text.replace(/\b[0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4}){7}\b/g, '[IPv6]');
+  text = text.replace(/\b[0-9a-fA-F]{1,4}(:[0-9a-fA-F]{1,4})*::[0-9a-fA-F:]*\b/g, '[IPv6]');
+
+  // --- Connection strings (before generic token patterns) ---
+  text = text.replace(/\b(postgres|postgresql|mysql|mongodb|redis|amqp|mssql):\/\/[^\s"']+/gi, '[DB_URL]');
+
+  // --- PEM keys ---
+  text = text.replace(/-----BEGIN [A-Z ]*(?:PRIVATE )?KEY-----[\s\S]*?-----END [A-Z ]*(?:PRIVATE )?KEY-----/g, '[PRIVATE_KEY]');
+
+  // --- Long hex tokens ---
+  text = text.replace(/\b[a-fA-F0-9]{40,}\b/g, '[TOKEN]');
+
+  // --- API keys with known prefixes ---
+  text = text.replace(/\b(sk-ant-api03-|sk-ant-|sk-proj-|sk-or-v1-|ghp_|gho_|github_pat_|ghu_|ghs_|pk_live_|sk_live_|pk_test_|sk_test_|xoxb-|xoxp-|xapp-|AKIA[A-Z0-9]|AGE-SECRET-KEY-|glpat-|pypi-|npm_)[a-zA-Z0-9_/+=.-]{10,}/g, '[API_KEY]');
+  text = text.replace(/\bAIza[a-zA-Z0-9_-]{30,}\b/g, '[API_KEY]');
+  text = text.replace(/\b(sk-|pk-)[a-zA-Z0-9_-]{20,}\b/g, '[API_KEY]');
+
+  // --- JWTs (any alg, not just HS256) ---
+  text = text.replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, '[JWT]');
+
+  // --- UUIDs ---
+  text = text.replace(/\b[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\b/g, '[UUID]');
+
+  // --- Key=value secrets (word-bounded to avoid donkey/turkey/monkey) ---
+  text = text.replace(/\b(password|passwd|secret|token|credential|bearer|authorization|api_key|apikey|access_key|secret_key)\s*[:=]\s*\S+/gi, '$1=[REDACTED]');
+
+  // --- SSN ---
+  text = text.replace(/\b\d{3}[-.]?\d{2}[-.]?\d{4}\b/g, '[SSN]');
+
+  // --- Credit card numbers ---
+  text = text.replace(/\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/g, '[CARD]');
+
+  // --- Phone numbers ---
+  text = text.replace(/\(\d{3}\)\s?\d{3}[-.]?\d{4}/g, '[PHONE]');
+  text = text.replace(/\+?1?[-.\s]?\d{3}[-.\s]\d{3}[-.\s]\d{4}\b/g, '[PHONE]');
+
+  return text;
+}
+
+export function sanitizeMessages(messages) {
+  return messages.map(msg => ({
+    ...msg,
+    content: sanitize(msg.content),
+  }));
+}

package/src/scanner.js

@@ -0,0 +1,62 @@
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+
+async function findJsonlFiles(dir) {
+  const results = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const nested = await findJsonlFiles(fullPath);
+        results.push(...nested);
+      } else if (entry.name.endsWith('.jsonl')) {
+        const info = await stat(fullPath);
+        results.push({ path: fullPath, mtime: info.mtimeMs, size: info.size });
+      }
+    }
+  } catch {
+    // directory not readable or doesn't exist
+  }
+  return results;
+}
+
+export async function scan(sourceFilter = 'all') {
+  const home = homedir();
+  const result = { claude_code: null, codex: null };
+
+  if (sourceFilter === 'all' || sourceFilter === 'claude') {
+    const claudeProjectsDir = join(home, '.claude', 'projects');
+    try {
+      await stat(claudeProjectsDir);
+      const files = await findJsonlFiles(claudeProjectsDir);
+      const sessions = files
+        .filter(f => f.size > 100)
+        .sort((a, b) => b.mtime - a.mtime);
+      if (sessions.length > 0) {
+        result.claude_code = { path: claudeProjectsDir, sessions };
+      }
+    } catch {
+      // ~/.claude/projects doesn't exist
+    }
+  }
+
+  if (sourceFilter === 'all' || sourceFilter === 'codex') {
+    const codexSessionsDir = join(home, '.codex', 'sessions');
+    try {
+      await stat(codexSessionsDir);
+      const files = await findJsonlFiles(codexSessionsDir);
+      const sessions = files
+        .filter(f => f.size > 100)
+        .sort((a, b) => b.mtime - a.mtime);
+      if (sessions.length > 0) {
+        result.codex = { path: codexSessionsDir, sessions };
+      }
+    } catch {
+      // ~/.codex/sessions doesn't exist
+    }
+  }
+
+  return result;
+}

package/src/unified.js

@@ -0,0 +1,52 @@
+const MAX_PAYLOAD_BYTES = 5 * 1024 * 1024; // 5MB
+
+export function unifyMessages(claudeSessions, codexSessions, limit = 500) {
+  const allSessions = [...claudeSessions, ...codexSessions];
+
+  allSessions.sort((a, b) => {
+    const aTime = a.messages[a.messages.length - 1]?.timestamp || '';
+    const bTime = b.messages[b.messages.length - 1]?.timestamp || '';
+    return bTime.localeCompare(aTime);
+  });
+
+  let selected = allSessions.slice(0, limit);
+
+  // Size guard: trim oldest sessions until payload fits
+  let payload = buildPayload(selected);
+  while (JSON.stringify(payload).length > MAX_PAYLOAD_BYTES && selected.length > 10) {
+    selected = selected.slice(0, Math.floor(selected.length * 0.8));
+    payload = buildPayload(selected);
+    process.stderr.write(`  Payload too large, trimmed to ${selected.length} sessions\n`);
+  }
+
+  return payload;
+}
+
+function buildPayload(sessions) {
+  const messages = [];
+  for (const session of sessions) {
+    for (const msg of session.messages) {
+      messages.push({
+        role: msg.role,
+        content: msg.content,
+        timestamp: msg.timestamp,
+        source: session.source,
+        session_id: session.session_id,
+        project_context: session.project || '',
+      });
+    }
+  }
+
+  const metadata = {
+    total_sessions: sessions.length,
+    claude_code_sessions: sessions.filter(s => s.source === 'claude_code').length,
+    codex_sessions: sessions.filter(s => s.source === 'codex').length,
+    total_messages: messages.length,
+    date_range: {
+      earliest: messages.reduce((min, m) => m.timestamp && m.timestamp < min ? m.timestamp : min, messages[0]?.timestamp || ''),
+      latest: messages.reduce((max, m) => m.timestamp && m.timestamp > max ? m.timestamp : max, messages[0]?.timestamp || ''),
+    },
+  };
+
+  return { messages, metadata };
+}