claude-memory-agent 2.0.0

package/skills/admin.py

@@ -0,0 +1,469 @@
+"""Admin skills for memory system management.
+
+Provides:
+- Embedding model switching
+- Memory reindexing
+- System statistics
+- Background reindexing with progress tracking
+"""
+import asyncio
+import time
+from typing import Dict, Any, Optional, List
+from services.embeddings import get_embedding_service, MODEL_CONFIGS
+
+
+# Global reindex state for progress tracking
+_reindex_state: Dict[str, Any] = {
+    "running": False,
+    "progress": 0,
+    "total": 0,
+    "current_model": None,
+    "started_at": None,
+    "errors": [],
+    "completed_at": None
+}
+
+
+async def get_embedding_status(
+    db,
+    embeddings
+) -> Dict[str, Any]:
+    """Get current embedding service status.
+
+    Returns:
+        Status including model, health, and available models
+    """
+    status = embeddings.get_status()
+    health = await embeddings.check_health()
+
+    # Get memory stats by model
+    cursor = db.conn.cursor()
+    cursor.execute("""
+        SELECT embedding_model, COUNT(*) as count
+        FROM memories
+        GROUP BY embedding_model
+    """)
+    model_counts = {row[0] or 'nomic-embed-text': row[1] for row in cursor.fetchall()}
+
+    return {
+        "success": True,
+        "status": status,
+        "health": health,
+        "available_models": embeddings.get_available_models(),
+        "memories_by_model": model_counts
+    }
+
+
+async def switch_embedding_model(
+    db,
+    embeddings,
+    model: str,
+    reindex_existing: bool = False
+) -> Dict[str, Any]:
+    """Switch the default embedding model.
+
+    Args:
+        db: Database service
+        embeddings: Embedding service
+        model: New model name to use
+        reindex_existing: If True, queue background reindex of existing memories
+
+    Returns:
+        Switch result with optional reindex status
+    """
+    # Validate model
+    if model not in MODEL_CONFIGS and model != "default":
+        available = [k for k in MODEL_CONFIGS.keys() if "alias_for" not in MODEL_CONFIGS.get(k, {})]
+        return {
+            "success": False,
+            "error": f"Unknown model '{model}'. Available: {available}"
+        }
+
+    old_model = embeddings.get_current_model()
+    embeddings.set_model(model)
+    new_model = embeddings.get_current_model()
+
+    # Check if model is available in Ollama
+    health = await embeddings.check_health(force=True)
+
+    result = {
+        "success": True,
+        "old_model": old_model,
+        "new_model": new_model,
+        "new_dimension": embeddings.get_dimension(),
+        "model_available": health.get("model_loaded", False),
+        "message": f"Switched from {old_model} to {new_model}"
+    }
+
+    if not health.get("model_loaded", False):
+        result["warning"] = f"Model '{new_model}' not found in Ollama. Run: ollama pull {new_model}"
+
+    if reindex_existing:
+        # Start background reindex
+        asyncio.create_task(_background_reindex(db, embeddings, new_model))
+        result["reindex_started"] = True
+        result["message"] += ". Background reindexing started."
+
+    return result
+
+
+async def reindex_memories(
+    db,
+    embeddings,
+    model: Optional[str] = None,
+    project_path: Optional[str] = None,
+    batch_size: int = 10,
+    dry_run: bool = False
+) -> Dict[str, Any]:
+    """Reindex memories with current or specified embedding model.
+
+    Args:
+        db: Database service
+        embeddings: Embedding service
+        model: Model to use (None = current model)
+        project_path: Filter to specific project
+        batch_size: Number of memories per batch
+        dry_run: If True, only count what would be reindexed
+
+    Returns:
+        Reindex results
+    """
+    global _reindex_state
+
+    if _reindex_state["running"]:
+        return {
+            "success": False,
+            "error": "Reindex already in progress",
+            "progress": _reindex_state
+        }
+
+    use_model = model or embeddings.get_current_model()
+
+    # Count memories to reindex
+    cursor = db.conn.cursor()
+    query = "SELECT COUNT(*) FROM memories WHERE embedding_model IS NULL OR embedding_model != ?"
+    params = [use_model]
+
+    if project_path:
+        query += " AND project_path = ?"
+        params.append(project_path)
+
+    cursor.execute(query, params)
+    total = cursor.fetchone()[0]
+
+    if dry_run:
+        return {
+            "success": True,
+            "dry_run": True,
+            "would_reindex": total,
+            "target_model": use_model,
+            "project_filter": project_path
+        }
+
+    if total == 0:
+        return {
+            "success": True,
+            "message": "No memories need reindexing",
+            "total": 0
+        }
+
+    # Start background reindex
+    asyncio.create_task(_background_reindex(db, embeddings, use_model, project_path, batch_size))
+
+    return {
+        "success": True,
+        "message": f"Background reindexing started for {total} memories",
+        "total": total,
+        "target_model": use_model,
+        "project_filter": project_path
+    }
+
+
+async def get_reindex_progress(
+    db,
+    embeddings
+) -> Dict[str, Any]:
+    """Get current reindex progress.
+
+    Returns:
+        Progress status including completion percentage
+    """
+    global _reindex_state
+
+    if not _reindex_state["running"] and _reindex_state["completed_at"] is None:
+        return {
+            "success": True,
+            "status": "idle",
+            "message": "No reindex in progress"
+        }
+
+    progress_pct = 0
+    if _reindex_state["total"] > 0:
+        progress_pct = round(_reindex_state["progress"] / _reindex_state["total"] * 100, 1)
+
+    status = "running" if _reindex_state["running"] else "completed"
+
+    result = {
+        "success": True,
+        "status": status,
+        "progress": _reindex_state["progress"],
+        "total": _reindex_state["total"],
+        "progress_percent": progress_pct,
+        "model": _reindex_state["current_model"],
+        "started_at": _reindex_state["started_at"],
+        "errors_count": len(_reindex_state["errors"])
+    }
+
+    if _reindex_state["completed_at"]:
+        result["completed_at"] = _reindex_state["completed_at"]
+        result["duration_seconds"] = _reindex_state["completed_at"] - _reindex_state["started_at"]
+
+    if _reindex_state["errors"]:
+        result["recent_errors"] = _reindex_state["errors"][-5:]  # Last 5 errors
+
+    return result
+
+
+async def cancel_reindex(
+    db,
+    embeddings
+) -> Dict[str, Any]:
+    """Cancel a running reindex operation.
+
+    Returns:
+        Cancellation result
+    """
+    global _reindex_state
+
+    if not _reindex_state["running"]:
+        return {
+            "success": False,
+            "error": "No reindex in progress"
+        }
+
+    _reindex_state["running"] = False
+    _reindex_state["completed_at"] = time.time()
+
+    return {
+        "success": True,
+        "message": f"Reindex cancelled at {_reindex_state['progress']}/{_reindex_state['total']}",
+        "progress": _reindex_state["progress"],
+        "total": _reindex_state["total"]
+    }
+
+
+async def get_model_info(
+    db,
+    embeddings,
+    model: Optional[str] = None
+) -> Dict[str, Any]:
+    """Get detailed information about an embedding model.
+
+    Args:
+        db: Database service
+        embeddings: Embedding service
+        model: Model name (None = current model)
+
+    Returns:
+        Model details including dimension and availability
+    """
+    use_model = model or embeddings.get_current_model()
+
+    config = MODEL_CONFIGS.get(use_model, {})
+    if "alias_for" in config:
+        use_model = config["alias_for"]
+        config = MODEL_CONFIGS.get(use_model, {})
+
+    # Check availability in Ollama
+    ollama_models = await embeddings.get_ollama_models()
+    is_available = any(use_model in m for m in ollama_models)
+
+    # Count memories using this model
+    cursor = db.conn.cursor()
+    cursor.execute(
+        "SELECT COUNT(*) FROM memories WHERE embedding_model = ?",
+        [use_model]
+    )
+    memory_count = cursor.fetchone()[0]
+
+    return {
+        "success": True,
+        "model": use_model,
+        "dimension": config.get("dimension", 768),
+        "description": config.get("description", "Unknown model"),
+        "is_current": use_model == embeddings.get_current_model(),
+        "available_in_ollama": is_available,
+        "memory_count": memory_count,
+        "pull_command": f"ollama pull {use_model}" if not is_available else None
+    }
+
+
+async def _background_reindex(
+    db,
+    embeddings,
+    model: str,
+    project_path: Optional[str] = None,
+    batch_size: int = 10
+):
+    """Background task for reindexing memories.
+
+    Updates global _reindex_state for progress tracking.
+    """
+    global _reindex_state
+
+    _reindex_state = {
+        "running": True,
+        "progress": 0,
+        "total": 0,
+        "current_model": model,
+        "started_at": time.time(),
+        "errors": [],
+        "completed_at": None
+    }
+
+    try:
+        cursor = db.conn.cursor()
+
+        # Get memories to reindex
+        query = """
+            SELECT id, content FROM memories
+            WHERE embedding_model IS NULL OR embedding_model != ?
+        """
+        params = [model]
+
+        if project_path:
+            query += " AND project_path = ?"
+            params.append(project_path)
+
+        cursor.execute(query, params)
+        memories = cursor.fetchall()
+        _reindex_state["total"] = len(memories)
+
+        # Process in batches
+        for i in range(0, len(memories), batch_size):
+            if not _reindex_state["running"]:
+                break  # Cancelled
+
+            batch = memories[i:i + batch_size]
+
+            for memory_id, content in batch:
+                if not _reindex_state["running"]:
+                    break
+
+                try:
+                    # Generate new embedding
+                    embedding = await embeddings.generate_embedding(content, model=model)
+
+                    if embedding:
+                        # Update memory with new embedding
+                        import json
+                        cursor.execute("""
+                            UPDATE memories
+                            SET embedding = ?, embedding_model = ?
+                            WHERE id = ?
+                        """, [json.dumps(embedding), model, memory_id])
+                        db.conn.commit()
+                    else:
+                        _reindex_state["errors"].append({
+                            "memory_id": memory_id,
+                            "error": "Failed to generate embedding"
+                        })
+
+                except Exception as e:
+                    _reindex_state["errors"].append({
+                        "memory_id": memory_id,
+                        "error": str(e)
+                    })
+
+                _reindex_state["progress"] += 1
+
+            # Small delay between batches to avoid overwhelming Ollama
+            await asyncio.sleep(0.1)
+
+        _reindex_state["running"] = False
+        _reindex_state["completed_at"] = time.time()
+
+    except Exception as e:
+        _reindex_state["running"] = False
+        _reindex_state["completed_at"] = time.time()
+        _reindex_state["errors"].append({
+            "error": f"Reindex failed: {str(e)}"
+        })
+
+
+async def get_system_stats(
+    db,
+    embeddings
+) -> Dict[str, Any]:
+    """Get comprehensive system statistics.
+
+    Returns:
+        System-wide statistics including memory counts, models, and health
+    """
+    cursor = db.conn.cursor()
+
+    # Memory counts
+    cursor.execute("SELECT COUNT(*) FROM memories")
+    total_memories = cursor.fetchone()[0]
+
+    cursor.execute("SELECT COUNT(*) FROM patterns")
+    total_patterns = cursor.fetchone()[0]
+
+    cursor.execute("SELECT COUNT(*) FROM projects")
+    total_projects = cursor.fetchone()[0]
+
+    # Memories by type
+    cursor.execute("""
+        SELECT type, COUNT(*) FROM memories
+        GROUP BY type
+    """)
+    memories_by_type = {row[0]: row[1] for row in cursor.fetchall()}
+
+    # Memories by model
+    cursor.execute("""
+        SELECT embedding_model, COUNT(*) FROM memories
+        GROUP BY embedding_model
+    """)
+    memories_by_model = {row[0] or 'nomic-embed-text': row[1] for row in cursor.fetchall()}
+
+    # Recent activity
+    cursor.execute("""
+        SELECT COUNT(*) FROM memories
+        WHERE created_at > datetime('now', '-24 hours')
+    """)
+    memories_24h = cursor.fetchone()[0]
+
+    cursor.execute("""
+        SELECT COUNT(*) FROM memories
+        WHERE created_at > datetime('now', '-7 days')
+    """)
+    memories_7d = cursor.fetchone()[0]
+
+    # Embedding health
+    health = await embeddings.check_health()
+
+    return {
+        "success": True,
+        "totals": {
+            "memories": total_memories,
+            "patterns": total_patterns,
+            "projects": total_projects
+        },
+        "memories_by_type": memories_by_type,
+        "memories_by_model": memories_by_model,
+        "recent_activity": {
+            "last_24h": memories_24h,
+            "last_7d": memories_7d
+        },
+        "embedding_service": {
+            "model": embeddings.get_current_model(),
+            "dimension": embeddings.get_dimension(),
+            "healthy": health.get("healthy", False),
+            "degraded": embeddings.is_degraded()
+        },
+        "reindex_status": {
+            "running": _reindex_state["running"],
+            "progress": _reindex_state["progress"],
+            "total": _reindex_state["total"]
+        }
+    }

package/skills/checkpoint.py

@@ -0,0 +1,198 @@
+"""Checkpoint skills for session snapshots and resumption."""
+from typing import Dict, Any, Optional, List
+from services.database import DatabaseService
+from services.embeddings import EmbeddingService
+from services.timeline import TimelineService
+
+
+async def checkpoint_create(
+    db: DatabaseService,
+    embeddings: EmbeddingService,
+    session_id: str,
+    summary: Optional[str] = None,
+    key_facts: Optional[List[str]] = None,
+    include_state: bool = True
+) -> Dict[str, Any]:
+    """
+    Create a checkpoint snapshot of the current session.
+
+    Args:
+        db: Database service instance
+        embeddings: Embedding service instance
+        session_id: The session ID
+        summary: Optional custom summary (auto-generated if not provided)
+        key_facts: Optional list of key facts to highlight
+        include_state: Include current state in checkpoint
+
+    Returns:
+        Dict with checkpoint info
+    """
+    timeline = TimelineService(db, embeddings)
+
+    # Get current state
+    state = await db.get_or_create_session_state(session_id)
+
+    # Get recent events
+    events_since = state.get("events_since_checkpoint", 0)
+    recent_events = await db.get_timeline_events(
+        session_id=session_id,
+        limit=max(events_since, 25)
+    )
+
+    # Build summary if not provided
+    if not summary:
+        parts = []
+        if state.get("current_goal"):
+            parts.append(f"Goal: {state['current_goal']}")
+        parts.append(f"{len(recent_events)} events since last checkpoint")
+        summary = ". ".join(parts) if parts else "Manual checkpoint"
+
+    # Extract key facts if not provided
+    if not key_facts:
+        key_facts = [
+            e["summary"] for e in recent_events
+            if e.get("is_anchor") or (e.get("event_type") == "decision" and e.get("confidence", 0) >= 0.8)
+        ][:10]
+
+    # Extract decisions
+    decisions = [
+        e["summary"] for e in recent_events
+        if e.get("event_type") == "decision"
+    ][:10]
+
+    # Get last event ID
+    event_id = recent_events[0]["id"] if recent_events else None
+
+    # Generate embedding for checkpoint summary
+    embedding = None
+    if embeddings:
+        embed_text = summary
+        if key_facts:
+            embed_text += "\n" + "\n".join(key_facts[:5])
+        embedding = await embeddings.generate_embedding(embed_text)
+
+    # Store checkpoint
+    checkpoint_id = await db.store_checkpoint(
+        session_id=session_id,
+        summary=summary,
+        event_id=event_id,
+        key_facts=key_facts,
+        decisions=decisions,
+        entities=state.get("entity_registry") if include_state else None,
+        current_goal=state.get("current_goal") if include_state else None,
+        pending_items=state.get("pending_questions") if include_state else None,
+        embedding=embedding,
+        event_count=len(recent_events)
+    )
+
+    return {
+        "success": True,
+        "checkpoint_id": checkpoint_id,
+        "session_id": session_id,
+        "summary": summary,
+        "key_facts_count": len(key_facts),
+        "decisions_count": len(decisions),
+        "events_captured": len(recent_events),
+        "message": f"Checkpoint created with ID {checkpoint_id}"
+    }
+
+
+async def checkpoint_load(
+    db: DatabaseService,
+    session_id: Optional[str] = None,
+    checkpoint_id: Optional[int] = None,
+    project_path: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Load context from a checkpoint for session resumption.
+
+    Args:
+        db: Database service instance
+        session_id: Load latest checkpoint for this session
+        checkpoint_id: Load specific checkpoint by ID
+        project_path: Load latest checkpoint for this project
+
+    Returns:
+        Dict with checkpoint context
+    """
+    checkpoint = None
+
+    if checkpoint_id:
+        # Load specific checkpoint
+        cursor = db.conn.cursor()
+        cursor.execute("SELECT * FROM checkpoints WHERE id = ?", (checkpoint_id,))
+        row = cursor.fetchone()
+        if row:
+            import json
+            checkpoint = {
+                "id": row["id"],
+                "session_id": row["session_id"],
+                "summary": row["summary"],
+                "key_facts": json.loads(row["key_facts"]) if row["key_facts"] else [],
+                "decisions": json.loads(row["decisions"]) if row["decisions"] else [],
+                "entities": json.loads(row["entities"]) if row["entities"] else {},
+                "current_goal": row["current_goal"],
+                "pending_items": json.loads(row["pending_items"]) if row["pending_items"] else [],
+                "event_count": row["event_count"],
+                "created_at": row["created_at"]
+            }
+    elif session_id:
+        checkpoint = await db.get_latest_checkpoint(session_id)
+    elif project_path:
+        # Get latest session for project, then its checkpoint
+        state = await db.get_latest_session_for_project(project_path)
+        if state:
+            checkpoint = await db.get_latest_checkpoint(state["session_id"])
+
+    if not checkpoint:
+        return {
+            "success": True,
+            "checkpoint": None,
+            "message": "No checkpoint found"
+        }
+
+    # Build grounding summary
+    grounding = []
+    if checkpoint.get("current_goal"):
+        grounding.append(f"Goal: {checkpoint['current_goal']}")
+    if checkpoint.get("key_facts"):
+        grounding.append(f"Key facts: {', '.join(checkpoint['key_facts'][:3])}")
+    if checkpoint.get("decisions"):
+        grounding.append(f"Decisions: {', '.join(checkpoint['decisions'][:3])}")
+    if checkpoint.get("pending_items"):
+        grounding.append(f"Pending: {', '.join(checkpoint['pending_items'][:3])}")
+
+    return {
+        "success": True,
+        "checkpoint": checkpoint,
+        "grounding_summary": " | ".join(grounding) if grounding else checkpoint.get("summary"),
+        "session_id": checkpoint.get("session_id"),
+        "message": f"Loaded checkpoint from {checkpoint.get('created_at')}"
+    }
+
+
+async def checkpoint_list(
+    db: DatabaseService,
+    session_id: str,
+    limit: int = 10
+) -> Dict[str, Any]:
+    """
+    List checkpoints for a session.
+
+    Args:
+        db: Database service instance
+        session_id: The session ID
+        limit: Max checkpoints to return
+
+    Returns:
+        Dict with checkpoint list
+    """
+    checkpoints = await db.get_checkpoints_for_session(session_id, limit)
+
+    return {
+        "success": True,
+        "session_id": session_id,
+        "checkpoints": checkpoints,
+        "count": len(checkpoints),
+        "message": f"Found {len(checkpoints)} checkpoints"
+    }