@mc1global/opencode-jarvis 0.12.0 → 0.13.1

package/scripts/context_memory_cli.py

@@ -0,0 +1,1093 @@
+#!/usr/bin/env python3
+"""
+Context Memory CLI - Unified interface for context management
+
+Replaces todo_manager.py and agent_messenger.py with single interface.
+
+Features:
+- TODO management (add, list, complete, search)
+- Agent messaging (send, inbox, read)
+- Session management (start, finish, list, status)
+- Full-text search across all context
+- Session summaries (Llama-powered if available)
+- Database management (stats, archive, clean, vacuum)
+- Workspace metadata in all TOON outputs
+
+Usage:
+    context-memory todo add "Task X" --priority=3
+    context-memory message send --from=A --to=B --subject="Task"
+    context-memory session start --workspace=prod --purpose="Feature X"
+    context-memory search "schema extraction"
+    context-memory summary --workspace=prod
+
+Requirements:
+    - click>=8.1.0
+    - src.context_memory module
+    - src.domain.context_memory (Session entities)
+"""
+
+import click
+import json
+import os
+import sys
+import sqlite3
+from pathlib import Path
+from datetime import datetime, timedelta
+
+# Add project root to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.context_memory import ContextMemoryManager, LlamaSummarizer
+from src.domain.context_memory.entities import Session
+from src.domain.context_memory.value_objects import SessionState
+from src.domain.context_memory.services import SessionCoordinator
+from src.infrastructure.context_memory.sqlite_session_repository import (
+    SQLiteSessionRepository,
+)
+
+
+def get_active_workspace() -> str:
+    """
+    Get active workspace from environment or default.
+
+    Priority:
+    1. JARVIS_ACTIVE_WORKSPACE env var
+    2. Default to 'default'
+
+    Returns:
+        str: Workspace name
+    """
+    return os.getenv("JARVIS_ACTIVE_WORKSPACE", "default")
+
+
+def toon_format(data: dict, workspace: str = None) -> str:
+    """
+    Format data in TOON notation for compact output.
+
+    Includes workspace metadata if provided.
+
+    Args:
+        data: Dictionary to format
+        workspace: Optional workspace name to include
+
+    Returns:
+        str: Formatted TOON string
+
+    Example:
+        toon_format({'count': 5, 'ids': [1,2,3,4,5]}, workspace='default')
+        # Returns: 'count:5,workspace:default,ids:[1,2,3,4,5]'
+    """
+    parts = []
+
+    for key, value in data.items():
+        if isinstance(value, list):
+            if len(value) == 0:
+                parts.append(f"{key}:[]")
+            elif len(value) <= 10:
+                parts.append(f"{key}:[{','.join(map(str, value))}]")
+            else:
+                parts.append(
+                    f"{key}:[{','.join(map(str, value[:5]))}...+{len(value) - 5}]"
+                )
+        elif isinstance(value, dict):
+            parts.append(f"{key}:{{{len(value)}items}}")
+        else:
+            parts.append(f"{key}:{value}")
+
+    # Add workspace if provided
+    if workspace:
+        parts.insert(1, f"workspace:{workspace}")
+
+    return ",".join(parts)
+
+
+# Initialize manager with Llama
+try:
+    llm = LlamaSummarizer()
+    manager = ContextMemoryManager()
+    LLAMA_AVAILABLE = llm.is_available()
+except Exception:
+    manager = ContextMemoryManager()
+    LLAMA_AVAILABLE = False
+
+# Initialize session repository
+session_repo = SQLiteSessionRepository(db_path=manager.db_path)
+
+
+@click.group()
+@click.version_option(version="1.0.0")
+def cli():
+    """Context Memory CLI - Unified context management."""
+    pass
+
+
+# =============================================================================
+# TODO Commands
+# =============================================================================
+
+
+@cli.group()
+def todo():
+    """Manage TODO tasks."""
+    pass
+
+
+@todo.command("add")
+@click.argument("task")
+@click.option("--workspace", "-w", help="Workspace name")
+@click.option("--priority", "-p", default=3, type=int, help="Priority 1-5")
+@click.option("--tags", "-t", help="Comma-separated tags")
+@click.option("--session", "-s", help="Session ID (auto-detects active if omitted)")
+@click.option("--verbose", is_flag=True, help="Full formatted output")
+def todo_add(task, workspace, priority, tags, session, verbose):
+    """Add new TODO task."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        # Auto-detect active session if not provided
+        if not session:
+            active = session_repo.find_active_by_workspace(workspace)
+            if active:
+                session = active.id
+                if verbose:
+                    click.echo(
+                        f"ℹ️  Auto-linked to active session: {session[:8]}...", err=True
+                    )
+
+        tags_list = [t.strip() for t in tags.split(",")] if tags else []
+
+        entry_id = manager.store_todo(
+            content=task,
+            workspace=workspace,
+            priority=priority,
+            tags=tags_list,
+            session_id=session,
+        )
+
+        if verbose:
+            # Full formatted output
+            priority_icon = "🔴" if priority <= 2 else "🟡" if priority == 3 else "🟢"
+            click.echo(f"{priority_icon} TODO created: #{entry_id}")
+            click.echo(f"   {task}")
+        else:
+            # TOON compact (default)
+            click.echo(f"ok:id:{entry_id},workspace:{workspace}")
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@todo.command("list")
+@click.option("--workspace", "-w", help="Filter by workspace")
+@click.option("--priority-min", "-p", default=0, type=int, help="Min priority")
+@click.option("--limit", "-l", default=50, type=int, help="Max results")
+@click.option("--verbose", "-v", is_flag=True, help="Full formatted output")
+def todo_list(workspace, priority_min, limit, verbose):
+    """List TODO tasks."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        todos = manager.get_active_todos(workspace=workspace, limit=limit)
+
+        # Filter by priority if needed
+        if priority_min > 0:
+            todos = [t for t in todos if t.priority <= priority_min]
+
+        if not todos:
+            click.echo(f"ok:count:0,workspace:{workspace}")
+            return
+
+        if verbose:
+            # Full formatted output (only if --verbose)
+            click.echo(f"\n{'=' * 70}")
+            click.echo(f"📋 Active TODOs ({len(todos)})")
+            if workspace:
+                click.echo(f"   Workspace: {workspace}")
+            click.echo(f"{'=' * 70}\n")
+
+            for todo in todos:
+                priority = todo.priority
+                priority_icon = (
+                    "🔴" if priority <= 2 else "🟡" if priority == 3 else "🟢"
+                )
+
+                click.echo(
+                    f"{priority_icon} [#{todo.id}] {todo.summary or todo.content}"
+                )
+
+                if todo.workspace:
+                    click.echo(f"   📂 {todo.workspace}")
+
+                if todo.tags:
+                    click.echo(f"   🏷️  {', '.join(todo.tags)}")
+
+                click.echo()
+        else:
+            # TOON compact output (default)
+            ids = [t.id for t in todos]
+            data = {"count": len(todos), "ids": ids}
+            click.echo(f"ok:{toon_format(data, workspace=workspace)}")
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@todo.command("complete")
+@click.argument("todo_id", type=int)
+def todo_complete(todo_id):
+    """Mark TODO as completed."""
+    try:
+        success = manager.complete_todo(todo_id)
+        if success:
+            click.echo(f"✅ TODO #{todo_id} completed")
+        else:
+            click.echo(f"❌ TODO #{todo_id} not found", err=True)
+            sys.exit(1)
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@todo.command("search")
+@click.argument("query")
+@click.option("--workspace", "-w", help="Filter by workspace")
+@click.option("--limit", "-l", default=20, type=int, help="Max results")
+def todo_search(query, workspace, limit):
+    """Search TODOs by full-text."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        results = manager.search(
+            query, context_type="todo", workspace=workspace, limit=limit
+        )
+
+        if not results:
+            click.echo(f"📭 No TODOs found for '{query}'")
+            return
+
+        click.echo(f"\n🔍 Search: '{query}' ({len(results)} results)\n")
+
+        for r in results:
+            click.echo(f"[#{r.id}] {r.summary or r.content[:80]}")
+            click.echo(f"   📅 {r.created_at}")
+            if r.workspace:
+                click.echo(f"   📂 {r.workspace}")
+            click.echo()
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+# =============================================================================
+# Message Commands
+# =============================================================================
+
+
+@cli.group()
+def message():
+    """Manage agent messages."""
+    pass
+
+
+@message.command("send")
+@click.option("--from", "sender", required=True, help="Sender agent")
+@click.option("--to", "recipient", required=True, help="Recipient agent")
+@click.option("--subject", "-s", required=True, help="Message subject")
+@click.option("--content", "-c", required=True, help="Message content")
+@click.option("--priority", "-p", default=3, type=int, help="Priority 1-5")
+@click.option("--workspace", "-w", help="Workspace context")
+def message_send(sender, recipient, subject, content, priority, workspace):
+    """Send inter-agent message."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        entry_id = manager.store_message(
+            content=f"{subject}\n\n{content}",
+            from_agent=sender,
+            to_agent=recipient,
+            workspace=workspace,
+            priority=priority,
+            tags=["message"],
+        )
+
+        click.echo(f"✅ Message sent: #{entry_id}")
+        click.echo(f"   {sender} → {recipient}: {subject}")
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@message.command("inbox")
+@click.option("--agent", "-a", required=True, help="Agent name")
+@click.option("--workspace", "-w", help="Filter by workspace")
+@click.option("--all", "show_all", is_flag=True, help="Show all messages")
+@click.option("--limit", "-l", default=50, type=int, help="Max results")
+def message_inbox(agent, workspace, show_all, limit):
+    """View agent inbox."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        status = "active" if not show_all else None
+
+        if status:
+            messages = manager.get_messages_for_agent(agent, status=status, limit=limit)
+        else:
+            # Get all messages for agent
+            conn = manager._get_connection()
+            cursor = conn.execute(
+                """
+                SELECT *
+                FROM context_entries
+                WHERE context_type = 'message'
+                  AND json_extract(metadata, '$.to') = ?
+                ORDER BY priority ASC, created_at DESC
+                LIMIT ?
+            """,
+                (agent, limit),
+            )
+            messages = [manager._row_to_entry(row) for row in cursor.fetchall()]
+            conn.close()
+
+        if not messages:
+            status_text = "unread " if not show_all else ""
+            click.echo(f"📭 No {status_text}messages for {agent}")
+            return
+
+        click.echo(f"\n{'=' * 70}")
+        click.echo(f"📨 Inbox: {agent} ({len(messages)} messages)")
+        click.echo(f"{'=' * 70}\n")
+
+        for msg in messages:
+            status_icon = "📩" if msg.status == "active" else "📨"
+            sender = msg.metadata.get("from", "unknown")
+
+            # Extract subject from content (first line)
+            lines = msg.content.split("\n", 1)
+            subject = lines[0] if lines else msg.summary
+
+            click.echo(f"{status_icon} [#{msg.id}] From {sender}: {subject}")
+            click.echo(f"   📅 {msg.created_at}")
+            click.echo()
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@message.command("read")
+@click.argument("message_id", type=int)
+def message_read(message_id):
+    """Mark message as read and show full content."""
+    try:
+        # Get message
+        conn = manager._get_connection()
+        cursor = conn.execute(
+            "SELECT * FROM context_entries WHERE id = ?", (message_id,)
+        )
+        row = cursor.fetchone()
+        conn.close()
+
+        if not row:
+            click.echo(f"❌ Message #{message_id} not found", err=True)
+            sys.exit(1)
+
+        msg = manager._row_to_entry(row)
+
+        # Show full message
+        click.echo(f"\n{'=' * 70}")
+        click.echo(f"📧 Message #{msg.id}")
+        click.echo(f"{'=' * 70}\n")
+        click.echo(f"From: {msg.metadata.get('from', 'unknown')}")
+        click.echo(f"To: {msg.metadata.get('to', 'unknown')}")
+        click.echo(f"Date: {msg.created_at}")
+        click.echo(f"Priority: {msg.priority}")
+        click.echo(f"\n{msg.content}\n")
+
+        # Mark as read
+        manager.mark_as_read(message_id)
+        click.echo("✅ Message marked as read")
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+# =============================================================================
+# Session Commands
+# =============================================================================
+
+
+@cli.group()
+def session():
+    """Manage agent sessions."""
+    pass
+
+
+@session.command("start")
+@click.option("--workspace", "-w", help="Workspace name")
+@click.option("--agent-name", "-a", default="opencode", help="Agent name")
+@click.option("--purpose", "-p", help="Session purpose/description")
+@click.option("--verbose", is_flag=True, help="Full formatted output")
+def session_start(workspace, agent_name, purpose, verbose):
+    """Create new session (enforces single WIP per workspace)."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        # Enforce business rule: only one WIP session per workspace
+        SessionCoordinator.ensure_no_active_session(workspace, session_repo)
+
+        # Create new session
+        new_session = Session(
+            workspace=workspace,
+            agent_name=agent_name,
+            purpose=purpose,
+            state=SessionState.WIP,
+        )
+
+        # Save to repository
+        session_id = session_repo.save(new_session)
+
+        if verbose:
+            click.echo(f"✅ Session started: #{session_id}")
+            click.echo(f"   Workspace: {workspace}")
+            click.echo(f"   Agent: {agent_name}")
+            if purpose:
+                click.echo(f"   Purpose: {purpose}")
+        else:
+            # TOON compact
+            click.echo(f"ok:session:{session_id},workspace:{workspace},state:wip")
+
+    except Exception as e:
+        click.echo(f"error:{e}", err=True)
+        sys.exit(1)
+
+
+@session.command("finish")
+@click.argument("session_id")
+@click.option("--summary", "-s", help="Completion summary")
+@click.option("--verbose", is_flag=True, help="Full formatted output")
+def session_finish(session_id, summary, verbose):
+    """Mark session as FINISHED with summary."""
+    try:
+        # Find session
+        existing_session = session_repo.find_by_id(session_id)
+
+        if not existing_session:
+            click.echo(f"error:session_not_found:{session_id}", err=True)
+            sys.exit(1)
+
+        # Mark as finished (validates state transition)
+        existing_session.mark_as_finished(summary=summary)
+
+        # Update in repository
+        success = session_repo.update(existing_session)
+
+        if not success:
+            click.echo(f"error:update_failed:{session_id}", err=True)
+            sys.exit(1)
+
+        if verbose:
+            click.echo(f"✅ Session finished: #{session_id}")
+            click.echo(f"   State: {existing_session.state.value}")
+            click.echo(f"   Duration: {existing_session.get_duration()}")
+            if summary:
+                click.echo(f"   Summary: {summary}")
+        else:
+            # TOON compact
+            click.echo(f"ok:session:{session_id},state:finished")
+
+    except Exception as e:
+        click.echo(f"error:{e}", err=True)
+        sys.exit(1)
+
+
+@session.command("list")
+@click.option("--workspace", "-w", help="Filter by workspace")
+@click.option(
+    "--state",
+    "-s",
+    type=click.Choice(["WIP", "FINISHED", "ALL"], case_sensitive=False),
+    default="ALL",
+    help="Filter by state",
+)
+@click.option("--limit", "-l", default=50, type=int, help="Max results")
+@click.option("--verbose", is_flag=True, help="Full formatted output")
+def session_list(workspace, state, limit, verbose):
+    """List sessions by workspace with filters."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        # Get sessions by workspace
+        sessions = session_repo.find_by_workspace(workspace, limit=limit)
+
+        # Filter by state if not ALL
+        if state.upper() != "ALL":
+            target_state = (
+                SessionState.WIP if state.upper() == "WIP" else SessionState.FINISHED
+            )
+            sessions = [s for s in sessions if s.state == target_state]
+
+        if not sessions:
+            click.echo(f"ok:count:0,workspace:{workspace}")
+            return
+
+        if verbose:
+            click.echo(f"\n{'=' * 70}")
+            click.echo(f"🔄 Sessions ({len(sessions)} found)")
+            click.echo(f"   Workspace: {workspace}")
+            if state.upper() != "ALL":
+                click.echo(f"   State: {state.upper()}")
+            click.echo(f"{'=' * 70}\n")
+
+            for sess in sessions:
+                state_icon = "⏳" if sess.state == SessionState.WIP else "✅"
+                click.echo(f"{state_icon} [#{sess.id}] {sess.agent_name}")
+                click.echo(f"   State: {sess.state.value}")
+                click.echo(f"   Created: {sess.created_at}")
+                if sess.purpose:
+                    click.echo(f"   Purpose: {sess.purpose}")
+                if sess.ended_at:
+                    click.echo(f"   Duration: {sess.get_duration()}")
+                click.echo()
+        else:
+            # TOON compact
+            session_ids = [s.id for s in sessions]
+            data = {"count": len(sessions), "sessions": session_ids}
+            click.echo(f"ok:{toon_format(data, workspace=workspace)}")
+
+    except Exception as e:
+        click.echo(f"error:{e}", err=True)
+        sys.exit(1)
+
+
+@session.command("status")
+@click.option("--workspace", "-w", help="Workspace name")
+@click.option("--verbose", is_flag=True, help="Full formatted output")
+def session_status(workspace, verbose):
+    """Show current active session for workspace."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        # Get active session
+        active = SessionCoordinator.get_active_session(workspace, session_repo)
+
+        if not active:
+            if verbose:
+                click.echo(f"ℹ️  No active session in workspace '{workspace}'")
+            else:
+                click.echo("error:no_active_session")
+            return
+
+        if verbose:
+            click.echo(f"\n{'=' * 70}")
+            click.echo(f"⏳ Active Session")
+            click.echo(f"{'=' * 70}\n")
+            click.echo(f"ID: {active.id}")
+            click.echo(f"Workspace: {active.workspace}")
+            click.echo(f"Agent: {active.agent_name}")
+            click.echo(f"State: {active.state.value}")
+            click.echo(f"Created: {active.created_at}")
+            click.echo(f"Duration: {active.get_duration()}")
+            if active.purpose:
+                click.echo(f"Purpose: {active.purpose}")
+            click.echo()
+        else:
+            # TOON compact
+            click.echo(f"ok:session:{active.id},state:{active.state.value}")
+
+    except Exception as e:
+        click.echo(f"error:{e}", err=True)
+        sys.exit(1)
+
+
+# =============================================================================
+# Note Commands
+# =============================================================================
+
+
+@cli.group()
+def note():
+    """Manage notes (auto-completed findings/decisions)."""
+    pass
+
+
+@note.command("add")
+@click.argument("content")
+@click.option("--tags", "-t", required=True, help="Comma-separated tags")
+@click.option("--workspace", "-w", help="Workspace name")
+@click.option("--session", "-s", help="Session ID (auto-detects active if omitted)")
+@click.option("--verbose", is_flag=True, help="Full formatted output")
+def note_add(content, tags, workspace, session, verbose):
+    """Add note (auto-completes immediately)."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        # Auto-detect active session if not provided
+        if not session:
+            active = session_repo.find_active_by_workspace(workspace)
+            if active:
+                session = active.id
+                if verbose:
+                    click.echo(
+                        f"ℹ️  Auto-linked to active session: {session[:8]}...", err=True
+                    )
+
+        tags_list = [t.strip() for t in tags.split(",")]
+
+        # Store as completed TODO with [NOTE] prefix
+        entry_id = manager.store_todo(
+            content=f"[NOTE] {content}",
+            workspace=workspace,
+            priority=3,
+            tags=tags_list + ["note"],
+            session_id=session,
+        )
+
+        # Mark as completed immediately
+        manager.complete_todo(entry_id)
+
+        if verbose:
+            click.echo(f"📝 Note created: #{entry_id}")
+            click.echo(f"   {content}")
+        else:
+            # TOON compact
+            click.echo(f"ok:note:{entry_id},workspace:{workspace}")
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@note.command("list")
+@click.option("--tags", "-t", help="Filter by tags")
+@click.option("--workspace", "-w", help="Filter by workspace")
+@click.option("--limit", "-l", default=50, type=int, help="Max results")
+@click.option("--verbose", is_flag=True, help="Full formatted output")
+def note_list(tags, workspace, limit, verbose):
+    """List notes."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        # Search for notes (completed TODOs with [NOTE] prefix)
+        results = manager.search(
+            query="NOTE", limit=limit, context_type="todo", workspace=workspace
+        )
+
+        # Filter by tags if specified
+        if tags:
+            tags_list = [t.strip() for t in tags.split(",")]
+            results = [r for r in results if any(t in r.tags for t in tags_list)]
+
+        # Filter only completed notes
+        notes = [
+            r
+            for r in results
+            if r.content.startswith("[NOTE]") and r.status == "completed"
+        ]
+
+        if not notes:
+            click.echo(f"ok:count:0,workspace:{workspace}")
+            return
+
+        if verbose:
+            click.echo(f"\n{'=' * 70}")
+            click.echo(f"📝 Notes ({len(notes)} found)")
+            click.echo(f"{'=' * 70}\n")
+            for note in notes[:limit]:
+                content = note.content.replace("[NOTE] ", "")
+                click.echo(
+                    f"#{note.id} | {note.created_at.strftime('%Y-%m-%d')} | "
+                    f"{', '.join(note.tags)}"
+                )
+                click.echo(f"  {content}")
+                click.echo()
+        else:
+            # TOON compact
+            ids = [n.id for n in notes[:limit]]
+            click.echo(
+                f"ok:{toon_format({'count': len(notes), 'ids': ids}, workspace=workspace)}"
+            )
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+# =============================================================================
+# Context Commands
+# =============================================================================
+
+
+@cli.command("search")
+@click.argument("query")
+@click.option("--type", "context_type", help="Filter by type")
+@click.option("--workspace", "-w", help="Filter by workspace")
+@click.option("--limit", "-l", default=20, type=int, help="Max results")
+def search(query, context_type, workspace, limit):
+    """Full-text search across all context."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        results = manager.search(
+            query, context_type=context_type, workspace=workspace, limit=limit
+        )
+
+        if not results:
+            click.echo(f"📭 No results for '{query}'")
+            return
+
+        click.echo(f"\n🔍 Search: '{query}' ({len(results)} results)\n")
+
+        for r in results:
+            type_icon = {
+                "todo": "📋",
+                "message": "📩",
+                "decision": "💡",
+                "learning": "🎓",
+                "workspace": "📂",
+            }.get(r.context_type, "📄")
+
+            click.echo(f"{type_icon} [{r.context_type}] #{r.id}")
+            click.echo(f"   {r.summary or r.content[:80]}")
+            click.echo(f"   📅 {r.created_at}")
+            if r.workspace:
+                click.echo(f"   📂 {r.workspace}")
+            click.echo()
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command("summary")
+@click.option("--workspace", "-w", help="Filter by workspace")
+@click.option("--hours", "-h", default=24, type=int, help="Time window")
+@click.option("--verbose", "-v", is_flag=True, help="Full formatted output")
+def summary(workspace, hours, verbose):
+    """Get activity summary for recent period."""
+    try:
+        # Use provided workspace or detect from environment
+        workspace = workspace or get_active_workspace()
+
+        if verbose:
+            # Show header only in verbose mode
+            llama_status = "🤖 Llama" if LLAMA_AVAILABLE else "📝 Basic"
+            click.echo(f"\n{'=' * 70}")
+            click.echo(f"📊 Activity Summary ({hours}h) - {llama_status}")
+            if workspace:
+                click.echo(f"   Workspace: {workspace}")
+            click.echo(f"{'=' * 70}\n")
+
+        # Get recent entries
+        cutoff = datetime.utcnow() - timedelta(hours=hours)
+        cutoff_str = cutoff.isoformat() + "Z"
+
+        conn = manager._get_connection()
+
+        # Count by type
+        where_clause = " AND workspace = ?" if workspace else ""
+        params = (cutoff_str, workspace) if workspace else (cutoff_str,)
+
+        cursor = conn.execute(
+            f"""
+            SELECT context_type, status, COUNT(*) as count
+            FROM context_entries
+            WHERE created_at >= ?
+            {where_clause}
+            GROUP BY context_type, status
+        """,
+            params,
+        )
+
+        stats = {}
+        for row in cursor.fetchall():
+            ctx_type = row["context_type"]
+            status = row["status"]
+            count = row["count"]
+            if ctx_type not in stats:
+                stats[ctx_type] = {}
+            stats[ctx_type][status] = count
+
+        conn.close()
+
+        if not stats:
+            click.echo(f"ok:count:0,workspace:{workspace}")
+            return
+
+        if verbose:
+            # Full formatted output
+            for ctx_type, statuses in sorted(stats.items()):
+                total = sum(statuses.values())
+                icon = {
+                    "todo": "📋",
+                    "message": "📩",
+                    "decision": "💡",
+                    "learning": "🎓",
+                }.get(ctx_type, "📄")
+                click.echo(f"{icon} {ctx_type.upper()}: {total}")
+                for status, count in sorted(statuses.items()):
+                    click.echo(f"   - {status}: {count}")
+                click.echo()
+        else:
+            # TOON compact (default)
+            totals = {
+                ctx_type: sum(statuses.values()) for ctx_type, statuses in stats.items()
+            }
+            data = {"hours": hours, **totals}
+            click.echo(f"ok:{toon_format(data, workspace=workspace)}")
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command("export")
+@click.option("--format", "-f", default="json", type=click.Choice(["json"]))
+@click.option("--output", "-o", help="Output file (default: stdout)")
+@click.option("--type", "context_type", help="Filter by type")
+@click.option("--workspace", "-w", help="Filter by workspace")
+def export(format, output, context_type, workspace):
+    """Export context memory to JSON."""
+    try:
+        conn = manager._get_connection()
+
+        sql = "SELECT * FROM context_entries WHERE 1=1"
+        params = []
+
+        if context_type:
+            sql += " AND context_type = ?"
+            params.append(context_type)
+
+        if workspace:
+            sql += " AND workspace = ?"
+            params.append(workspace)
+
+        sql += " ORDER BY created_at"
+
+        cursor = conn.execute(sql, params)
+        entries = [dict(row) for row in cursor.fetchall()]
+        conn.close()
+
+        output_text = json.dumps(entries, indent=2)
+
+        if output:
+            Path(output).write_text(output_text)
+            click.echo(f"✅ Exported {len(entries)} entries to {output}")
+        else:
+            click.echo(output_text)
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+# =============================================================================
+# Management Commands
+# =============================================================================
+
+
+@cli.command("stats")
+def stats():
+    """Show database statistics."""
+    try:
+        conn = manager._get_connection()
+
+        click.echo(f"\n{'=' * 70}")
+        click.echo("📊 Context Memory Statistics")
+        click.echo(f"{'=' * 70}\n")
+
+        # Total entries
+        cursor = conn.execute("SELECT COUNT(*) FROM context_entries")
+        total = cursor.fetchone()[0]
+        click.echo(f"Total entries: {total}")
+
+        # By type
+        cursor = conn.execute("""
+            SELECT context_type, COUNT(*)
+            FROM context_entries
+            GROUP BY context_type
+            ORDER BY COUNT(*) DESC
+        """)
+        click.echo("\nBy type:")
+        for row in cursor.fetchall():
+            click.echo(f"  - {row[0]}: {row[1]}")
+
+        # By status
+        cursor = conn.execute("""
+            SELECT status, COUNT(*)
+            FROM context_entries
+            GROUP BY status
+        """)
+        click.echo("\nBy status:")
+        for row in cursor.fetchall():
+            click.echo(f"  - {row[0]}: {row[1]}")
+
+        # Database size
+        cursor = conn.execute(
+            "SELECT page_count * page_size FROM pragma_page_count(), pragma_page_size()"
+        )
+        size_bytes = cursor.fetchone()[0]
+        click.echo(f"\nDatabase size: {size_bytes / 1024 / 1024:.2f} MB")
+
+        # FTS index
+        cursor = conn.execute("SELECT COUNT(*) FROM context_fts")
+        fts_count = cursor.fetchone()[0]
+        synced = "✅" if fts_count == total else "❌"
+        click.echo(f"FTS index: {fts_count} {synced}")
+
+        # Llama availability
+        llama_icon = "✅" if LLAMA_AVAILABLE else "❌"
+        click.echo(f"Llama available: {llama_icon}")
+
+        conn.close()
+        click.echo()
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command("archive")
+@click.option("--days", default=90, type=int, help="Archive older than days")
+@click.option("--dry-run", is_flag=True, help="Show what would be archived")
+def archive(days, dry_run):
+    """Archive old completed entries."""
+    try:
+        if dry_run:
+            # Count entries that would be archived
+            cutoff = datetime.utcnow() - timedelta(days=days)
+            cutoff_str = cutoff.isoformat() + "Z"
+
+            conn = manager._get_connection()
+            cursor = conn.execute(
+                """
+                SELECT COUNT(*) FROM context_entries
+                WHERE updated_at < ?
+                  AND status IN ('completed', 'cancelled')
+            """,
+                (cutoff_str,),
+            )
+            count = cursor.fetchone()[0]
+            conn.close()
+
+            click.echo(
+                f"🔍 Dry run: would archive {count} entries older than {days} days"
+            )
+            return
+
+        count = manager.archive_old_entries(older_than_days=days)
+        click.echo(f"✅ Archived {count} entries older than {days} days")
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command("clean")
+@click.option(
+    "--strategy",
+    type=click.Choice(["notes", "completed", "old", "all"]),
+    default="old",
+    help="Cleanup strategy",
+)
+@click.option("--days", default=30, type=int, help="Age threshold (for old strategy)")
+@click.option(
+    "--keep-tagged", is_flag=True, default=True, help="Protect tagged entries"
+)
+@click.option("--dry-run", is_flag=True, help="Preview without deleting")
+def clean(strategy, days, keep_tagged, dry_run):
+    """Clean up context entries based on strategy."""
+    try:
+        if dry_run:
+            # Count entries that would be deleted
+            cutoff = datetime.utcnow() - timedelta(days=days)
+            cutoff_str = cutoff.isoformat() + "Z"
+
+            conn = manager._get_connection()
+
+            sql = "SELECT COUNT(*) FROM context_entries WHERE 1=1"
+            params = []
+
+            if strategy == "notes":
+                sql += " AND context_type = 'learning'"
+            elif strategy == "completed":
+                sql += " AND status IN ('completed', 'cancelled')"
+            elif strategy == "old":
+                sql += " AND created_at < ?"
+                params.append(cutoff_str)
+
+            if keep_tagged:
+                sql += " AND (tags IS NULL OR tags = '[]')"
+
+            cursor = conn.execute(sql, params)
+            count = cursor.fetchone()[0]
+            conn.close()
+
+            strategy_desc = {
+                "notes": "learning entries",
+                "completed": "completed/cancelled entries",
+                "old": f"entries older than {days} days",
+                "all": "ALL entries",
+            }
+            click.echo(f"🔍 Dry run: would delete {count} {strategy_desc[strategy]}")
+            if keep_tagged:
+                click.echo("   (protecting tagged entries)")
+            return
+
+        count = manager.clean_entries(
+            strategy=strategy, days=days, keep_tagged=keep_tagged
+        )
+
+        strategy_desc = {
+            "notes": "learning entries",
+            "completed": "completed/cancelled entries",
+            "old": f"entries older than {days} days",
+            "all": "entries",
+        }
+        click.echo(f"✅ Deleted {count} {strategy_desc[strategy]}")
+
+    except ValueError as e:
+        click.echo(f"❌ Invalid strategy: {e}", err=True)
+        sys.exit(1)
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command("vacuum")
+def vacuum():
+    """Optimize database (reclaim space, rebuild indexes)."""
+    try:
+        manager.vacuum()
+        click.echo("✅ Database optimized")
+
+    except Exception as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+# Alias: status → stats
+@cli.command("status")
+def status():
+    """Alias for stats command."""
+    stats.invoke(click.Context(stats))
+
+
+if __name__ == "__main__":
+    cli()