opencode-semantic-memory 0.1.0__py3-none-any.whl

opencode_memory/cli.py

@@ -0,0 +1,794 @@
+"""CLI entry point for opencode-memory."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from opencode_memory.server import main as server_main
+
+
+def main() -> None:
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="OpenCode Memory - Persistent semantic memory for OpenCode sessions"
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="opencode-memory 0.1.0",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    serve_parser = subparsers.add_parser("serve", help="Start the MCP server")
+    serve_parser.add_argument(
+        "--no-daemon",
+        action="store_true",
+        help="Disable background ingestion daemon",
+    )
+
+    ingest_parser = subparsers.add_parser("ingest", help="Ingest files into memory")
+    ingest_parser.add_argument("path", help="Path to file or directory to ingest")
+    ingest_parser.add_argument(
+        "--recursive", "-r", action="store_true", help="Recursively ingest directories"
+    )
+
+    subparsers.add_parser("stats", help="Show memory statistics")
+
+    migrate_parser = subparsers.add_parser(
+        "migrate", help="Migrate existing .opencode/ notes into memory"
+    )
+    migrate_parser.add_argument(
+        "--path",
+        type=str,
+        default="~/gitlab_projects/.opencode",
+        help="Path to .opencode directory (default: ~/gitlab_projects/.opencode)",
+    )
+    migrate_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be migrated without actually migrating",
+    )
+
+    enrich_parser = subparsers.add_parser("enrich", help="Enrich entities with GitLab metadata")
+    enrich_parser.add_argument(
+        "--limit", "-l", type=int, default=50, help="Maximum entities to enrich"
+    )
+    enrich_parser.add_argument(
+        "--stale-hours", type=int, default=24, help="Consider entities stale after this many hours"
+    )
+
+    cleanup_parser = subparsers.add_parser(
+        "cleanup", help="Archive old/expired memories (conservative, preserves searchability)"
+    )
+    cleanup_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be archived without actually archiving",
+    )
+    cleanup_parser.add_argument(
+        "--resolved-blockers-days",
+        type=int,
+        default=90,
+        help="Archive resolved blockers older than N days (default: 90)",
+    )
+    cleanup_parser.add_argument(
+        "--conversations-days",
+        type=int,
+        default=180,
+        help="Archive conversation summaries older than N days (default: 180)",
+    )
+
+    backfill_parser = subparsers.add_parser(
+        "backfill-projects", help="Backfill project field for existing memories and re-embed"
+    )
+    backfill_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be updated without actually updating",
+    )
+    backfill_parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=100,
+        help="Process memories in batches of this size (default: 100)",
+    )
+
+    extract_parser = subparsers.add_parser(
+        "extract-knowledge",
+        help="Use LLM to extract procedures, directives, and tips from conversations",
+    )
+    extract_parser.add_argument(
+        "--limit",
+        "-l",
+        type=int,
+        default=10,
+        help="Maximum conversations to process (default: 10)",
+    )
+    extract_parser.add_argument(
+        "--since-days",
+        type=int,
+        default=None,
+        help="Only process conversations from last N days (default: all)",
+    )
+    extract_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be extracted without storing",
+    )
+    extract_parser.add_argument(
+        "--project",
+        type=str,
+        help="Filter to specific project (e.g., 'gitlab-org/gitlab')",
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "serve" or args.command is None:
+        enable_daemon = not getattr(args, "no_daemon", False)
+        server_main(enable_daemon=enable_daemon)
+    elif args.command == "ingest":
+        from pathlib import Path
+
+        from opencode_memory.config import Config
+        from opencode_memory.ingestion.embeddings import EmbeddingEngine
+        from opencode_memory.ingestion.parser import MarkdownParser
+        from opencode_memory.storage.sqlite import SQLiteStorage
+        from opencode_memory.storage.vectors import VectorStorage
+
+        config = Config.load()
+        sqlite = SQLiteStorage(config.db_path)
+        embeddings = EmbeddingEngine()
+        vectors = VectorStorage(config.vectors_path, embeddings.dimension)
+        parser_instance = MarkdownParser()
+
+        path = Path(args.path).expanduser()
+        if path.is_file():
+            files = [path]
+        elif path.is_dir():
+            if args.recursive:
+                files = list(path.rglob("*.md"))
+            else:
+                files = list(path.glob("*.md"))
+        else:
+            print(f"Path not found: {path}", file=sys.stderr)
+            sys.exit(1)
+
+        from opencode_memory.models import Entity
+
+        for file_path in files:
+            if "node_modules" in file_path.parts:
+                continue
+            print(f"Ingesting: {file_path}")
+            doc = parser_instance.parse_file(file_path)
+
+            entity_ids = []
+            for entity_type, ref in doc.entities:
+                entity = Entity(type=entity_type, ref=ref)
+                entity_id = sqlite.upsert_entity(entity)
+                entity_ids.append(entity_id)
+
+            for memory in doc.memories:
+                memory_id = sqlite.insert_memory(memory, entity_ids)
+                embedding = embeddings.embed(memory.embedding_content())
+                vectors.add(f"mem_{memory_id}", memory_id, memory.embedding_content(), embedding)
+            print(f"  - {len(doc.entities)} entities, {len(doc.memories)} memories")
+
+        print("Done!")
+    elif args.command == "migrate":
+        _migrate_opencode_notes(args.path, args.dry_run)
+    elif args.command == "stats":
+        _show_stats()
+    elif args.command == "enrich":
+        _enrich_entities(args.limit, args.stale_hours)
+    elif args.command == "cleanup":
+        _cleanup_memories(
+            dry_run=args.dry_run,
+            resolved_blockers_days=args.resolved_blockers_days,
+            conversations_days=args.conversations_days,
+        )
+    elif args.command == "backfill-projects":
+        _backfill_projects(dry_run=args.dry_run, batch_size=args.batch_size)
+    elif args.command == "extract-knowledge":
+        _extract_knowledge(
+            limit=args.limit,
+            since_days=args.since_days,
+            dry_run=args.dry_run,
+            project=args.project,
+        )
+    else:
+        parser.print_help()
+
+
+def _show_stats() -> None:
+    """Show memory statistics."""
+    import json
+    import sqlite3
+    import urllib.request
+
+    from opencode_memory.config import Config
+
+    config = Config.load()
+    db_path = config.db_path
+    vectors_path = config.vectors_path
+
+    if not db_path.exists():
+        print("No memory database found.")
+        return
+
+    # Try to get live stats from HTTP server (may be slow if MCP sessions are active)
+    server_stats = None
+    try:
+        with urllib.request.urlopen("http://127.0.0.1:9824/stats", timeout=15) as resp:
+            server_stats = json.loads(resp.read().decode())
+    except Exception:
+        pass  # Server not running or busy, fall back to direct DB access
+
+    with sqlite3.connect(db_path) as conn:
+        conn.row_factory = sqlite3.Row
+
+        cursor = conn.execute("SELECT COUNT(*) as count FROM memories WHERE resolved_at IS NULL")
+        total_memories = cursor.fetchone()["count"]
+
+        cursor = conn.execute(
+            "SELECT category, COUNT(*) as count FROM memories WHERE resolved_at IS NULL GROUP BY category ORDER BY count DESC"
+        )
+        categories = cursor.fetchall()
+
+        cursor = conn.execute("SELECT COUNT(*) as count FROM entities")
+        total_entities = cursor.fetchone()["count"]
+
+        cursor = conn.execute(
+            "SELECT type, COUNT(*) as count FROM entities GROUP BY type ORDER BY count DESC"
+        )
+        entity_types = cursor.fetchall()
+
+        cursor = conn.execute(
+            "SELECT COUNT(DISTINCT source_file) as count FROM memories WHERE source_file LIKE 'opencode:session:%'"
+        )
+        sessions_ingested = cursor.fetchone()["count"]
+
+        cursor = conn.execute(
+            "SELECT COUNT(*) as count FROM memories WHERE resolved_at IS NOT NULL"
+        )
+        resolved_count = cursor.fetchone()["count"]
+
+        # Get link stats
+        link_count = 0
+        link_types = []
+        try:
+            cursor = conn.execute("SELECT COUNT(*) as count FROM memory_links")
+            link_count = cursor.fetchone()["count"]
+            cursor = conn.execute(
+                "SELECT link_type, COUNT(*) as count FROM memory_links GROUP BY link_type"
+            )
+            link_types = cursor.fetchall()
+        except Exception:
+            pass  # Table may not exist in older databases
+
+    opencode_db = Path("~/.local/share/opencode/opencode.db").expanduser()
+    total_sessions = 0
+    if opencode_db.exists():
+        with sqlite3.connect(f"file:{opencode_db}?mode=ro", uri=True) as conn:
+            cursor = conn.execute("SELECT COUNT(*) FROM session")
+            total_sessions = cursor.fetchone()[0]
+
+    db_size = db_path.stat().st_size / (1024 * 1024)
+    vectors_size = (
+        sum(f.stat().st_size for f in vectors_path.rglob("*") if f.is_file()) / (1024 * 1024)
+        if vectors_path.exists()
+        else 0
+    )
+
+    print("=" * 60)
+    print("OpenCode Memory Statistics")
+    print("=" * 60)
+    print()
+
+    # Server status
+    if server_stats:
+        daemon = server_stats.get("daemon", {})
+        print(f"Server: running (daemon: {'active' if daemon.get('running') else 'stopped'})")
+    else:
+        print("Server: not running (showing database stats only)")
+    print()
+
+    print(f"Total memories: {total_memories}")
+    print(f"Total entities: {total_entities}")
+    print(f"Resolved blockers: {resolved_count}")
+    print(f"Memory links: {link_count}")
+    print()
+
+    print("Memories by category:")
+    for row in categories:
+        print(f"  {row['category']:15} {row['count']:>6}")
+    print()
+
+    print("Entities by type:")
+    for row in entity_types:
+        print(f"  {row['type']:15} {row['count']:>6}")
+    print()
+
+    if link_types:
+        print("Links by type:")
+        for row in link_types:
+            print(f"  {row['link_type']:15} {row['count']:>6}")
+        print()
+
+    print(f"Sessions ingested: {sessions_ingested} / {total_sessions}")
+    if total_sessions > 0:
+        pct = (sessions_ingested / total_sessions) * 100
+        print(f"Ingestion progress: {pct:.1f}%")
+    print()
+
+    # Storage
+    print("Storage:")
+    print(f"  Database:     {db_size:>8.2f} MB")
+    print(f"  Vector store: {vectors_size:>8.2f} MB")
+    print(f"  Total:        {db_size + vectors_size:>8.2f} MB")
+
+    # Cache stats from server
+    if server_stats:
+        print()
+        cache = server_stats.get("cache", {})
+        if cache:
+            print("Cache:")
+            print(f"  Size:     {cache.get('size', 0)} / {cache.get('max_size', 0)}")
+            print(f"  Hit rate: {cache.get('hit_rate', 0) * 100:.1f}%")
+            print(f"  Hits:     {cache.get('hits', 0)}")
+            print(f"  Misses:   {cache.get('misses', 0)}")
+
+        eq = server_stats.get("embedding_queue", {})
+        if eq:
+            print()
+            print("Embedding queue:")
+            print(f"  Status:  {eq.get('status', 'unknown')}")
+            print(f"  Pending: {eq.get('pending', 0)}")
+
+
+def _enrich_entities(limit: int, stale_hours: int) -> None:
+    """Enrich stale entities with GitLab metadata."""
+    import asyncio
+    import os
+
+    from opencode_memory.config import Config
+    from opencode_memory.enrichment.gitlab import GitLabEnricher
+    from opencode_memory.storage.sqlite import SQLiteStorage
+
+    if not os.environ.get("GITLAB_TOKEN"):
+        print("Error: GITLAB_TOKEN environment variable not set", file=sys.stderr)
+        sys.exit(1)
+
+    config = Config.load()
+    sqlite = SQLiteStorage(config.db_path)
+    enricher = GitLabEnricher()
+
+    stale_entities = sqlite.get_stale_entities(max_age_hours=stale_hours, limit=limit)
+
+    if not stale_entities:
+        print("No stale entities to enrich.")
+        return
+
+    print(f"Found {len(stale_entities)} stale entities to enrich...")
+
+    async def do_enrich():
+        enriched_count = 0
+        for entity in stale_entities:
+            try:
+                enriched = await enricher.enrich_entity(entity)
+                if enriched.title or enriched.metadata:
+                    sqlite.upsert_entity(enriched)
+                    enriched_count += 1
+                    print(
+                        f"  {entity.type.value:6} {entity.ref:12} -> {enriched.title or '(no title)'}"
+                    )
+            except Exception as e:
+                print(f"  {entity.type.value:6} {entity.ref:12} -> Error: {e}")
+
+        await enricher.close()
+        return enriched_count
+
+    enriched = asyncio.run(do_enrich())
+    print(f"\nEnriched {enriched} of {len(stale_entities)} entities.")
+
+
+def _cleanup_memories(dry_run: bool, resolved_blockers_days: int, conversations_days: int) -> None:
+    """Archive old/expired memories.
+
+    This is a conservative cleanup that:
+    - Archives (not deletes) memories for audit/search purposes
+    - Only targets: expired memories, old resolved blockers, very old conversations
+    - Does NOT touch: decisions, facts, procedures, active blockers
+    """
+    from opencode_memory.config import Config
+    from opencode_memory.storage.sqlite import SQLiteStorage
+
+    config = Config.load()
+    sqlite = SQLiteStorage(config.db_path)
+
+    stats = sqlite.get_cleanup_stats()
+
+    print("=" * 50)
+    print("Memory Cleanup" + (" (DRY RUN)" if dry_run else ""))
+    print("=" * 50)
+    print()
+    print("Cleanup candidates:")
+    print(f"  Expired memories:        {stats['expired']}")
+    print(f"  Resolved blockers:       {stats['resolved_blockers']}")
+    print(f"  Old conversations (90d+): {stats['old_conversations']}")
+    print(f"  Already archived:        {stats['archived_total']}")
+    print()
+
+    if dry_run:
+        print("Would archive:")
+        print(f"  - All {stats['expired']} expired memories")
+        print(f"  - Resolved blockers older than {resolved_blockers_days} days")
+        print(f"  - Conversation summaries older than {conversations_days} days")
+        print()
+        print("Run without --dry-run to proceed.")
+        return
+
+    archived_expired = sqlite.archive_expired_memories()
+    print(f"Archived {archived_expired} expired memories")
+
+    archived_blockers = sqlite.archive_old_resolved_blockers(days_old=resolved_blockers_days)
+    print(f"Archived {archived_blockers} old resolved blockers")
+
+    archived_conversations = sqlite.archive_old_conversations(days_old=conversations_days)
+    print(f"Archived {archived_conversations} old conversations")
+
+    total = archived_expired + archived_blockers + archived_conversations
+    print()
+    print(f"Total archived: {total}")
+    print()
+    print("Note: Archived memories remain searchable via memory_search with include_archived=true")
+
+
+def _migrate_opencode_notes(opencode_path: str, dry_run: bool) -> None:
+    """Migrate existing .opencode/ notes into memory.
+
+    Scans for markdown files in the .opencode directory structure and ingests
+    them into the memory system with progress reporting.
+    """
+    from pathlib import Path
+
+    from opencode_memory.config import Config
+    from opencode_memory.ingestion.embeddings import EmbeddingEngine
+    from opencode_memory.ingestion.parser import MarkdownParser
+    from opencode_memory.models import Entity
+    from opencode_memory.storage.sqlite import SQLiteStorage
+    from opencode_memory.storage.vectors import VectorStorage
+
+    path = Path(opencode_path).expanduser()
+    if not path.exists():
+        print(f"Error: Directory not found: {path}", file=sys.stderr)
+        sys.exit(1)
+
+    md_files = [
+        f for f in path.rglob("*.md") if "node_modules" not in f.parts and "archive" not in f.parts
+    ]
+
+    if not md_files:
+        print(f"No markdown files found in {path}")
+        return
+
+    print("=" * 50)
+    print("OpenCode Notes Migration" + (" (DRY RUN)" if dry_run else ""))
+    print("=" * 50)
+    print()
+    print(f"Source: {path}")
+    print(f"Files found: {len(md_files)}")
+    print()
+
+    if dry_run:
+        print("Files to migrate:")
+        for f in sorted(md_files):
+            rel = f.relative_to(path)
+            print(f"  {rel}")
+        print()
+        print("Run without --dry-run to proceed.")
+        return
+
+    config = Config.load()
+    sqlite = SQLiteStorage(config.db_path)
+    embeddings = EmbeddingEngine()
+    vectors = VectorStorage(config.vectors_path, embeddings.dimension)
+    parser_instance = MarkdownParser()
+
+    total_entities = 0
+    total_memories = 0
+
+    for i, file_path in enumerate(sorted(md_files), 1):
+        rel = file_path.relative_to(path)
+        print(f"[{i}/{len(md_files)}] {rel}")
+
+        try:
+            doc = parser_instance.parse_file(file_path)
+
+            entity_ids = []
+            for entity_type, ref in doc.entities:
+                entity = Entity(type=entity_type, ref=ref)
+                entity_id = sqlite.upsert_entity(entity)
+                entity_ids.append(entity_id)
+            total_entities += len(doc.entities)
+
+            for memory in doc.memories:
+                memory_id = sqlite.insert_memory(memory, entity_ids)
+                embedding = embeddings.embed(memory.embedding_content())
+                vectors.add(f"mem_{memory_id}", memory_id, memory.embedding_content(), embedding)
+            total_memories += len(doc.memories)
+
+            print(f"         {len(doc.entities)} entities, {len(doc.memories)} memories")
+        except Exception as e:
+            print(f"         Error: {e}")
+
+    print()
+    print("=" * 50)
+    print("Migration complete!")
+    print(f"  Files processed: {len(md_files)}")
+    print(f"  Entities found: {total_entities}")
+    print(f"  Memories created: {total_memories}")
+    print()
+    print("Tip: Run 'opencode-memory stats' to see updated statistics")
+
+
+def _backfill_projects(dry_run: bool = False, batch_size: int = 100) -> None:
+    """Backfill project field for existing memories and re-embed with project prefix."""
+    import sqlite3
+
+    from opencode_memory.config import Config
+    from opencode_memory.ingestion.embeddings import EmbeddingEngine
+    from opencode_memory.project import detect_project_from_path, detect_project_from_git
+    from opencode_memory.storage.sqlite import SQLiteStorage
+    from opencode_memory.storage.vectors import VectorStorage
+
+    config = Config.load()
+    sqlite = SQLiteStorage(config.db_path)
+
+    if dry_run:
+        print("DRY RUN - no changes will be made")
+        print()
+
+    conn = sqlite3.connect(config.db_path)
+    conn.row_factory = sqlite3.Row
+
+    cursor = conn.execute(
+        "SELECT id, source_file, project, content FROM memories WHERE project IS NULL"
+    )
+    memories_to_update = cursor.fetchall()
+
+    print(f"Found {len(memories_to_update)} memories without project")
+
+    if not memories_to_update:
+        print("Nothing to backfill!")
+        return
+
+    project_counts: dict[str | None, int] = {}
+    updates: list[tuple[str | None, int]] = []
+
+    for row in memories_to_update:
+        source_file = row["source_file"]
+        memory_id = row["id"]
+
+        project = None
+        if source_file:
+            if source_file.startswith("opencode:session:"):
+                session_id = source_file.replace("opencode:session:", "")
+                opencode_db = Path.home() / ".local/share/opencode/opencode.db"
+                if opencode_db.exists():
+                    try:
+                        oc_conn = sqlite3.connect(f"file:{opencode_db}?mode=ro", uri=True)
+                        oc_cursor = oc_conn.execute(
+                            "SELECT directory FROM session WHERE id = ?", (session_id,)
+                        )
+                        oc_row = oc_cursor.fetchone()
+                        if oc_row and oc_row[0]:
+                            project = detect_project_from_path(
+                                oc_row[0]
+                            ) or detect_project_from_git(oc_row[0])
+                        oc_conn.close()
+                    except Exception:
+                        pass
+            else:
+                project = detect_project_from_path(source_file)
+
+        updates.append((project, memory_id))
+        project_counts[project] = project_counts.get(project, 0) + 1
+
+    print()
+    print("Project distribution:")
+    for project, count in sorted(project_counts.items(), key=lambda x: -x[1]):
+        print(f"  {project or '(unknown)'}: {count}")
+
+    if dry_run:
+        print()
+        print("DRY RUN complete - no changes made")
+        return
+
+    print()
+    print("Updating database...")
+
+    updated = 0
+    for project, memory_id in updates:
+        if project:
+            conn.execute(
+                "UPDATE memories SET project = ? WHERE id = ?",
+                (project, memory_id),
+            )
+            updated += 1
+    conn.commit()
+
+    print(f"Updated {updated} memories with project")
+
+    print()
+    print("Re-embedding memories with project prefix...")
+
+    embeddings = EmbeddingEngine()
+    vectors = VectorStorage(config.vectors_path, embeddings.dimension)
+
+    cursor = conn.execute("SELECT id, content, project FROM memories WHERE project IS NOT NULL")
+    all_with_project = cursor.fetchall()
+
+    reembedded = 0
+    for i in range(0, len(all_with_project), batch_size):
+        batch = all_with_project[i : i + batch_size]
+        for row in batch:
+            memory_id = row["id"]
+            content = row["content"]
+            project = row["project"]
+
+            prefixed_content = f"[{project}] {content}"
+            embedding = embeddings.embed(prefixed_content)
+            vectors.add(f"mem_{memory_id}", memory_id, prefixed_content, embedding)
+            reembedded += 1
+
+        print(f"  Re-embedded {min(i + batch_size, len(all_with_project))}/{len(all_with_project)}")
+
+    print()
+    print(f"Backfill complete! Re-embedded {reembedded} memories with project prefix")
+
+
+def _extract_knowledge(
+    limit: int,
+    since_days: int,
+    dry_run: bool,
+    project: str | None,
+) -> None:
+    """Extract procedures, directives, and tips from conversations using LLM."""
+    import asyncio
+
+    from opencode_memory.config import Config
+    from opencode_memory.extraction import (
+        EXTRACTION_PROMPT,
+        _find_opencode,
+        call_opencode,
+        get_unprocessed_conversations,
+    )
+    from opencode_memory.ingestion.embeddings import EmbeddingEngine
+    from opencode_memory.models import LinkType, Memory, MemoryCategory, MemoryLink
+    from opencode_memory.storage.sqlite import SQLiteStorage
+    from opencode_memory.storage.vectors import VectorStorage
+
+    if not _find_opencode():
+        print("Error: opencode not found in PATH or ~/.opencode/bin/")
+        print("Install from https://opencode.ai")
+        sys.exit(1)
+
+    config = Config.load()
+    sqlite = SQLiteStorage(config.db_path)
+    embeddings = EmbeddingEngine()
+    vectors = VectorStorage(config.vectors_path, embeddings.dimension)
+
+    conversations = get_unprocessed_conversations(sqlite, since_days=since_days, limit=limit)
+
+    if project:
+        conversations = [c for c in conversations if c.get("project") == project]
+
+    if not conversations:
+        print("No unprocessed conversations found matching criteria.")
+        return
+
+    print(f"Found {len(conversations)} conversations to process\n")
+
+    total_extracted = 0
+
+    async def process_one(conv: dict) -> int:
+        import json
+
+        conv_id = conv["id"]
+        content = conv["content"]
+        conv_project = conv.get("project")
+
+        if len(content) > 15000:
+            content = content[:15000] + "\n\n[... truncated ...]"
+
+        full_prompt = EXTRACTION_PROMPT + content
+
+        try:
+            response = await call_opencode(full_prompt)
+        except Exception as e:
+            print(f"  Error calling opencode: {e}")
+            return 0
+
+        extracted = []
+        for line in response.split("\n"):
+            line = line.strip()
+            if not line or not line.startswith("{"):
+                continue
+            try:
+                item = json.loads(line)
+                if "category" in item and "content" in item:
+                    extracted.append(item)
+            except json.JSONDecodeError:
+                continue
+
+        if not extracted:
+            return 0
+
+        count = 0
+        category_map = {
+            "procedure": MemoryCategory.PROCEDURE,
+            "directive": MemoryCategory.DIRECTIVE,
+            "decision": MemoryCategory.DECISION,
+            "fact": MemoryCategory.FACT,
+        }
+
+        for item in extracted:
+            category_str = item.get("category", "fact")
+            category = category_map.get(category_str, MemoryCategory.FACT)
+
+            print(f"    [{category_str}] {item.get('what', 'No summary')[:50]}")
+
+            if dry_run:
+                count += 1
+                continue
+
+            memory = Memory(
+                category=category,
+                content=item.get("content", ""),
+                what=item.get("what"),
+                why=item.get("why"),
+                learned=item.get("learned"),
+                project=conv_project,
+                source_file=conv.get("source_file"),
+            )
+
+            memory_id = sqlite.insert_memory(memory)
+
+            embedding = embeddings.embed(memory.embedding_content())
+            vectors.add(f"mem_{memory_id}", memory_id, memory.embedding_content(), embedding)
+
+            link = MemoryLink(
+                source_memory_id=conv_id,
+                target_memory_id=memory_id,
+                link_type=LinkType.EXTENDS,
+                strength=0.9,
+                reason="Knowledge extracted from conversation via LLM",
+            )
+            sqlite.insert_link(link)
+
+            count += 1
+
+        return count
+
+    for conv in conversations:
+        title = conv.get("what") or "Untitled"
+        print(f"Processing: {title[:60]}...")
+
+        extracted_count = asyncio.run(process_one(conv))
+        if extracted_count > 0:
+            print(f"  Extracted {extracted_count} items")
+            total_extracted += extracted_count
+        else:
+            print("  No knowledge extracted")
+        print()
+
+    print()
+    if dry_run:
+        print(f"DRY RUN complete - would have extracted ~{total_extracted} items")
+    else:
+        print(f"Extraction complete! Stored {total_extracted} new memories")
+
+
+if __name__ == "__main__":
+    main()