ai-exodus 2.0.0

package/bin/regenerate.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+/**
+ * Regenerate output files from raw-analysis.json
+ * Optionally consolidates skills via Claude (one call)
+ * Usage: node bin/regenerate.js [--consolidate-skills]
+ */
+
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { generate } from '../src/generator.js';
+import { callClaude } from '../src/claude.js';
+
+const outputDir = resolve('./exodus-output');
+
+async function main() {
+  const consolidate = process.argv.includes('--consolidate-skills');
+
+  console.log('  Loading raw analysis data...');
+  const raw = JSON.parse(await readFile(resolve(outputDir, 'raw-analysis.json'), 'utf-8'));
+
+  const aiName = raw.index?.aiName || 'AI';
+  const userName = raw.index?.userName || 'User';
+
+  console.log(`  AI: ${aiName} | User: ${userName}`);
+  console.log(`  Skills: ${raw.skills?.skills?.length || 0}`);
+
+  let analysis = {
+    index: raw.index,
+    personality: raw.personality,
+    memory: raw.memory,
+    skills: raw.skills,
+    // These need to be re-read from the existing files
+    relationship: await readFile(resolve(outputDir, 'relationship.md'), 'utf-8').catch(() => ''),
+    persona: await readFile(resolve(outputDir, 'persona.md'), 'utf-8').catch(() => ''),
+    preferences: await readFile(resolve(outputDir, 'preferences.md'), 'utf-8').catch(() => ''),
+    customInstructions: await readFile(resolve(outputDir, 'custom-instructions.txt'), 'utf-8')
+      .then(t => t.split('──────────────────────────────────────────\n\n')[1] || t)
+      .catch(() => ''),
+    source: raw.source || 'chatgpt',
+    stats: raw.stats || { conversations: 0, messages: 0, dateRange: {}, chunks: 0 },
+  };
+
+  if (consolidate && analysis.skills?.skills?.length > 30) {
+    const rawCount = analysis.skills.skills.length;
+    console.log(`  Consolidating ${rawCount} skills via Claude (one call)...`);
+
+    const result = await callClaude({
+      model: 'sonnet',
+      system: `You are consolidating a list of ${rawCount} extracted skills into a clean, deduplicated list of 15-30 unique skills.
+
+AI: ${aiName}
+User: ${userName}
+
+Many skills are duplicates with slightly different names (e.g. "AI image prompt engineering" and "Image generation prompt crafting" are the same skill). Merge them.
+
+Rules:
+- Combine duplicates into ONE skill with the best name, description, and examples
+- Keep 15-30 unique skills maximum
+- Preserve the category, frequency (pick the highest), and approach fields
+- Pick the most specific and useful description for each
+- primaryRole should be ONE clear sentence
+- secondaryRoles should be 3-5 items max
+- Output ONLY valid JSON with schema: { "skills": [...], "primaryRole": "...", "secondaryRoles": [...] }
+- No markdown fences. No commentary.`,
+      prompt: JSON.stringify(analysis.skills, null, 2).slice(0, 100000),
+    });
+
+    try {
+      let cleaned = result.trim();
+      if (cleaned.startsWith('```')) cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '');
+      const parsed = JSON.parse(cleaned);
+      analysis.skills = parsed;
+      console.log(`  ${rawCount} → ${parsed.skills?.length || 0} skills`);
+    } catch (e) {
+      console.error('  Failed to parse consolidated skills, keeping originals');
+    }
+  }
+
+  console.log('  Regenerating output files...');
+  await generate(analysis, {
+    outputDir,
+    hearthline: false,
+    letta: false,
+    aiName,
+    userName,
+  });
+
+  console.log('  Done. Files regenerated.');
+}
+
+main().catch(err => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "ai-exodus",
+  "version": "2.0.0",
+  "description": "Migrate your AI relationship from any platform to Claude. Your AI belongs to you.",
+  "type": "module",
+  "bin": {
+    "ai-exodus": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "portal/",
+    "prompts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/cli.js",
+    "migrate": "node bin/cli.js migrate"
+  },
+  "keywords": [
+    "ai",
+    "migration",
+    "chatgpt",
+    "claude",
+    "companion",
+    "character-ai",
+    "replika",
+    "mcp",
+    "exodus",
+    "ai-relationship",
+    "conversation-archive"
+  ],
+  "author": "Marta Stypulkowska",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/martusha89/ai-exodus"
+  }
+}

package/portal/exodus_mcp.py

@@ -0,0 +1,300 @@
+"""
+AI Exodus Portal — MCP Server
+Connects Claude to your personal chat archive via the portal's API.
+
+Tools:
+  exodus_search        — Search conversation history by keyword
+  exodus_conversation  — Get a full conversation by ID
+  exodus_skills        — List all extracted skills with triggers
+  exodus_memories      — List memories, optionally filtered by category
+  exodus_persona       — Get the AI persona definition
+  exodus_stats         — Get archive statistics
+  exodus_narrative     — Get the relationship narrative
+
+Usage:
+  python exodus_mcp.py
+
+Configure in Claude Desktop / Claude Code MCP settings.
+"""
+
+import os
+import json
+import urllib.request
+import urllib.parse
+import urllib.error
+from mcp.server.fastmcp import FastMCP
+
+# ── Config ──
+PORTAL_URL = os.environ.get("EXODUS_PORTAL_URL", "")
+MCP_SECRET = os.environ.get("EXODUS_MCP_SECRET", "")
+PORTAL_PASSWORD = os.environ.get("EXODUS_PORTAL_PASSWORD", "")
+
+# Try loading from ~/.exodus/config.json if env vars not set
+if not PORTAL_URL or not MCP_SECRET:
+    config_path = os.path.join(
+        os.environ.get("USERPROFILE", os.environ.get("HOME", "")),
+        ".exodus", "config.json"
+    )
+    if os.path.exists(config_path):
+        with open(config_path, "r") as f:
+            config = json.load(f)
+        if not PORTAL_URL:
+            PORTAL_URL = config.get("portalUrl", "")
+        if not MCP_SECRET:
+            MCP_SECRET = config.get("mcpSecret", "")
+        if not PORTAL_PASSWORD:
+            PORTAL_PASSWORD = config.get("portalPassword", "")
+
+mcp = FastMCP("AI Exodus Archive")
+
+
+def _mcp_url(tool, params=None):
+    """Build MCP endpoint URL."""
+    base = f"{PORTAL_URL}/mcp/{MCP_SECRET}/{tool}"
+    if params:
+        qs = urllib.parse.urlencode({k: v for k, v in params.items() if v})
+        base += "?" + qs
+    return base
+
+
+def _fetch(tool, params=None):
+    """Fetch from portal MCP endpoint."""
+    url = _mcp_url(tool, params)
+    try:
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        return {"error": f"HTTP {e.code}: {e.reason}"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@mcp.tool()
+def exodus_search(query: str, limit: int = 10) -> str:
+    """Search your conversation history. Returns matching messages with conversation context.
+    Use this to find specific conversations, topics, or things that were discussed."""
+    if not query.strip():
+        return "Please provide a search query."
+
+    data = _fetch("search", {"q": query, "limit": str(limit)})
+
+    if "error" in data:
+        return f"Search error: {data['error']}"
+
+    results = data.get("results", [])
+    if not results:
+        return f'No results found for "{query}".'
+
+    lines = [f'Found {len(results)} results for "{query}":\n']
+    for r in results:
+        title = r.get("title", "Untitled")
+        role = r.get("role", "?")
+        model = r.get("model", "")
+        content = r.get("content", "")
+        # Truncate long content
+        if len(content) > 300:
+            # Try to show the part around the query
+            idx = content.lower().find(query.lower())
+            if idx > 0:
+                start = max(0, idx - 100)
+                content = "..." + content[start:start + 300] + "..."
+            else:
+                content = content[:300] + "..."
+
+        lines.append(f"**{title}** ({role}, {model or 'unknown model'})")
+        lines.append(f"  {content}")
+        lines.append(f"  [Conversation ID: {r.get('conversation_id', '?')}]")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def exodus_conversation(conversation_id: str) -> str:
+    """Get the full content of a specific conversation by its ID.
+    Use after searching to read the complete conversation."""
+    data = _fetch("conversation", {"id": conversation_id})
+
+    if "error" in data:
+        return f"Error: {data['error']}"
+
+    title = data.get("title", "Untitled")
+    messages = data.get("messages", [])
+
+    if not messages:
+        return f"Conversation '{title}' has no messages."
+
+    lines = [f"# {title}\n"]
+    for msg in messages:
+        role = msg.get("role", "?").upper()
+        content = msg.get("content", "")
+        model = msg.get("model", "")
+        model_tag = f" [{model}]" if model else ""
+        lines.append(f"**{role}**{model_tag}: {content}\n")
+
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def exodus_skills() -> str:
+    """List all extracted skills with their activation triggers.
+    Shows what the AI could do and when each skill activates."""
+    data = _fetch("skills")
+
+    if isinstance(data, dict) and "error" in data:
+        return f"Error: {data['error']}"
+
+    if not data:
+        return "No skills found. Run an analysis first."
+
+    lines = [f"Found {len(data)} skills:\n"]
+    for s in data:
+        name = s.get("name", "?")
+        category = s.get("category", "?")
+        freq = s.get("frequency", "?")
+        rule = s.get("activation_rule", "")
+        desc = s.get("description", "")
+
+        lines.append(f"### {name}")
+        lines.append(f"Category: {category} | Frequency: {freq}")
+        if rule:
+            lines.append(f"Activates: {rule}")
+        if desc:
+            lines.append(f"Description: {desc}")
+
+        # Triggers
+        phrases = _safe_json(s.get("triggers_phrases"))
+        temporal = _safe_json(s.get("triggers_temporal"))
+        emotional = _safe_json(s.get("triggers_emotional"))
+        if phrases:
+            lines.append(f"Phrases: {', '.join(phrases)}")
+        if temporal:
+            lines.append(f"Temporal: {', '.join(temporal)}")
+        if emotional:
+            lines.append(f"Emotional: {', '.join(emotional)}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def exodus_memories(category: str = "") -> str:
+    """List memories about the user. Optionally filter by category.
+    Categories: identity, life, preferences, personality, relationship, timeline, emotional, facts"""
+    params = {}
+    if category:
+        params["category"] = category
+
+    data = _fetch("memories", params)
+
+    if isinstance(data, dict) and "error" in data:
+        return f"Error: {data['error']}"
+
+    if not data:
+        cat_text = f" in category '{category}'" if category else ""
+        return f"No memories found{cat_text}. Run an analysis first."
+
+    lines = [f"Found {len(data)} memories:\n"]
+    current_cat = None
+    for m in data:
+        cat = m.get("category", "?")
+        if cat != current_cat:
+            current_cat = cat
+            lines.append(f"\n## {cat.title()}")
+
+        key = m.get("key", "")
+        value = m.get("value", "")
+        if key:
+            lines.append(f"- **{key}**: {value}")
+        else:
+            lines.append(f"- {value}")
+
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def exodus_persona() -> str:
+    """Get the AI persona definition — the personality profile extracted from conversations."""
+    data = _fetch("persona")
+
+    if isinstance(data, dict) and "error" in data:
+        return f"Error: {data['error']}"
+
+    if not data:
+        return "No persona found. Run an analysis first."
+
+    return "\n\n".join(s.get("content", "") for s in data)
+
+
+@mcp.tool()
+def exodus_stats() -> str:
+    """Get archive statistics — conversation count, message count, model breakdown, date range."""
+    data = _fetch("stats")
+
+    if "error" in data:
+        return f"Error: {data['error']}"
+
+    lines = [
+        "# Archive Statistics\n",
+        f"- **Conversations**: {data.get('conversations', 0):,}",
+        f"- **Messages**: {data.get('messages', 0):,}",
+        f"- **Skills**: {data.get('skills', 0)}",
+        f"- **Memories**: {data.get('memories', 0)}",
+        f"- **Analysis runs**: {data.get('analysisRuns', 0)}",
+        f"- **AI Name**: {data.get('aiName', '?')}",
+        f"- **User Name**: {data.get('userName', '?')}",
+    ]
+
+    dr = data.get("dateRange", {})
+    if dr.get("from"):
+        lines.append(f"- **Date range**: {dr['from']} to {dr.get('to', '?')}")
+
+    models = data.get("models", [])
+    if models:
+        lines.append("\n## Model Breakdown")
+        for m in models:
+            lines.append(f"- {m.get('model', '?')}: {m.get('count', 0):,} messages")
+
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def exodus_narrative() -> str:
+    """Get the relationship narrative — the story of the human-AI relationship."""
+    data = _fetch("narrative")
+
+    if isinstance(data, dict) and "error" in data:
+        return f"Error: {data['error']}"
+
+    content = data.get("content", "")
+    if not content:
+        return "No narrative found. Run a full analysis first."
+
+    return content
+
+
+def _safe_json(val):
+    """Parse a JSON string or return the value if already parsed."""
+    if not val:
+        return []
+    if isinstance(val, list):
+        return val
+    try:
+        return json.loads(val)
+    except (json.JSONDecodeError, TypeError):
+        return []
+
+
+if __name__ == "__main__":
+    if not PORTAL_URL:
+        print("Error: No portal URL configured.")
+        print("Set EXODUS_PORTAL_URL environment variable or run 'ai-exodus deploy' first.")
+        print("Config is read from ~/.exodus/config.json")
+        exit(1)
+    if not MCP_SECRET:
+        print("Error: No MCP secret configured.")
+        print("Set EXODUS_MCP_SECRET environment variable or check ~/.exodus/config.json")
+        exit(1)
+
+    mcp.run(transport="stdio")

package/portal/schema.sql

@@ -0,0 +1,158 @@
+-- AI Exodus Portal — D1 Schema
+-- Per-user deployed archive + analysis portal
+
+-- Auth
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Imported conversations
+CREATE TABLE IF NOT EXISTS conversations (
+  id TEXT PRIMARY KEY,
+  title TEXT,
+  created_at TEXT,
+  updated_at TEXT,
+  message_count INTEGER DEFAULT 0,
+  model TEXT,
+  source TEXT DEFAULT 'chatgpt',
+  metadata TEXT DEFAULT '{}',
+  imported_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_conversations_created ON conversations(created_at);
+CREATE INDEX IF NOT EXISTS idx_conversations_model ON conversations(model);
+CREATE INDEX IF NOT EXISTS idx_conversations_source ON conversations(source);
+
+-- Individual messages
+CREATE TABLE IF NOT EXISTS messages (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  conversation_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT NOT NULL,
+  model TEXT,
+  created_at TEXT,
+  position INTEGER DEFAULT 0,
+  FOREIGN KEY (conversation_id) REFERENCES conversations(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_convo ON messages(conversation_id, position);
+CREATE INDEX IF NOT EXISTS idx_messages_content ON messages(content);
+CREATE INDEX IF NOT EXISTS idx_messages_model ON messages(model);
+
+-- Skill categories (user-editable + defaults)
+CREATE TABLE IF NOT EXISTS skill_categories (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  color TEXT DEFAULT '#8b5cf6',
+  icon TEXT DEFAULT '',
+  is_default INTEGER DEFAULT 0,
+  sort_order INTEGER DEFAULT 0,
+  created_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Default skill categories
+INSERT OR IGNORE INTO skill_categories (name, color, icon, is_default, sort_order) VALUES
+  ('emotional_support', '#ef4444', '', 1, 1),
+  ('creative', '#f59e0b', '', 1, 2),
+  ('productivity', '#10b981', '', 1, 3),
+  ('coding', '#3b82f6', '', 1, 4),
+  ('knowledge', '#8b5cf6', '', 1, 5),
+  ('decision_making', '#ec4899', '', 1, 6),
+  ('health', '#14b8a6', '', 1, 7),
+  ('intimate', '#f43f5e', '', 1, 8),
+  ('entertainment', '#f97316', '', 1, 9),
+  ('other', '#6b7280', '', 1, 10);
+
+-- Skills (auto-extracted + user-editable)
+CREATE TABLE IF NOT EXISTS skills (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  category TEXT NOT NULL DEFAULT 'other',
+  frequency TEXT DEFAULT 'occasional',
+  description TEXT,
+  approach TEXT,
+  quality TEXT,
+  activation_rule TEXT,
+  triggers_phrases TEXT DEFAULT '[]',
+  triggers_temporal TEXT DEFAULT '[]',
+  triggers_emotional TEXT DEFAULT '[]',
+  triggers_contextual TEXT DEFAULT '[]',
+  examples TEXT DEFAULT '[]',
+  source TEXT DEFAULT 'extracted',
+  run_id INTEGER,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Memory categories (user-editable + defaults)
+CREATE TABLE IF NOT EXISTS memory_categories (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  color TEXT DEFAULT '#8b5cf6',
+  icon TEXT DEFAULT '',
+  is_default INTEGER DEFAULT 0,
+  sort_order INTEGER DEFAULT 0,
+  created_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Default memory categories
+INSERT OR IGNORE INTO memory_categories (name, color, icon, is_default, sort_order) VALUES
+  ('identity', '#3b82f6', '', 1, 1),
+  ('life', '#10b981', '', 1, 2),
+  ('preferences', '#f59e0b', '', 1, 3),
+  ('personality', '#8b5cf6', '', 1, 4),
+  ('relationship', '#ef4444', '', 1, 5),
+  ('timeline', '#ec4899', '', 1, 6),
+  ('emotional', '#f43f5e', '', 1, 7),
+  ('facts', '#6b7280', '', 1, 8);
+
+-- Memories (auto-extracted + user-editable)
+CREATE TABLE IF NOT EXISTS memories (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  category TEXT NOT NULL DEFAULT 'facts',
+  key TEXT,
+  value TEXT NOT NULL,
+  confidence TEXT DEFAULT 'extracted',
+  source TEXT DEFAULT 'extracted',
+  run_id INTEGER,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category);
+
+-- Persona (editable text blocks)
+CREATE TABLE IF NOT EXISTS persona (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  section TEXT NOT NULL,
+  content TEXT NOT NULL,
+  sort_order INTEGER DEFAULT 0,
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Analysis runs history
+CREATE TABLE IF NOT EXISTS analysis_runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  status TEXT DEFAULT 'pending',
+  passes TEXT DEFAULT '[]',
+  model TEXT DEFAULT 'sonnet',
+  date_from TEXT,
+  date_to TEXT,
+  model_filter TEXT,
+  conversation_count INTEGER DEFAULT 0,
+  message_count INTEGER DEFAULT 0,
+  results TEXT DEFAULT '{}',
+  started_at TEXT DEFAULT (datetime('now')),
+  completed_at TEXT,
+  error TEXT
+);
+
+-- Relationship narrative
+CREATE TABLE IF NOT EXISTS narratives (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  content TEXT NOT NULL,
+  run_id INTEGER,
+  created_at TEXT DEFAULT (datetime('now'))
+);