claude-memory-agent 2.0.0

package/skills/search.py

@@ -0,0 +1,213 @@
+"""Semantic search skill with context filtering and fallback support."""
+from typing import Dict, Any, Optional, List
+from services.database import DatabaseService
+from services.embeddings import EmbeddingService
+
+
+async def semantic_search(
+    db: DatabaseService,
+    embeddings: EmbeddingService,
+    query: str,
+    limit: int = 10,
+    memory_type: Optional[str] = None,
+    session_id: Optional[str] = None,
+    project_path: Optional[str] = None,
+    agent_type: Optional[str] = None,
+    success_only: bool = False,
+    threshold: float = 0.5
+) -> Dict[str, Any]:
+    """
+    Search memories using semantic similarity with context filters.
+
+    Includes automatic fallback to keyword search when Ollama is unavailable.
+
+    Args:
+        db: Database service instance
+        embeddings: Embedding service instance
+        query: Search query text
+        limit: Maximum number of results
+        memory_type: Filter by type (session, decision, code, chunk, error)
+        session_id: Filter by session ID
+        project_path: Filter by project
+        agent_type: Filter by agent that created the memory
+        success_only: Only return memories marked as successful
+        threshold: Minimum similarity threshold (0-1)
+
+    Returns:
+        Dict with search results ranked by similarity * importance
+    """
+    # Generate embedding for the query (may return None if Ollama unavailable)
+    query_embedding = await embeddings.generate_embedding(query)
+
+    # Determine search method based on embedding availability
+    search_method = "semantic"
+    results = []
+
+    if query_embedding is not None:
+        # Use semantic search with embeddings
+        results = await db.search_similar(
+            embedding=query_embedding,
+            limit=limit,
+            memory_type=memory_type,
+            session_id=session_id,
+            project_path=project_path,
+            agent_type=agent_type,
+            success_only=success_only,
+            threshold=threshold
+        )
+    else:
+        # Fallback to keyword search
+        search_method = "keyword"
+        results = await db.keyword_search(
+            query=query,
+            limit=limit,
+            memory_type=memory_type,
+            session_id=session_id,
+            project_path=project_path,
+            agent_type=agent_type,
+            success_only=success_only
+        )
+
+    return {
+        "success": True,
+        "query": query,
+        "results": results,
+        "count": len(results),
+        "search_method": search_method,
+        "degraded_mode": embeddings.is_degraded(),
+        "filters": {
+            "type": memory_type,
+            "project": project_path,
+            "agent": agent_type,
+            "success_only": success_only
+        },
+        "threshold": threshold if search_method == "semantic" else None
+    }
+
+
+async def search_patterns(
+    db: DatabaseService,
+    embeddings: EmbeddingService,
+    query: str,
+    limit: int = 5,
+    problem_type: Optional[str] = None,
+    threshold: float = 0.5
+) -> Dict[str, Any]:
+    """
+    Search for reusable solution patterns.
+
+    Includes fallback to keyword search when Ollama is unavailable.
+
+    Args:
+        db: Database service instance
+        embeddings: Embedding service instance
+        query: Problem description or search query
+        limit: Maximum number of results
+        problem_type: Filter by problem type
+        threshold: Minimum similarity threshold
+
+    Returns:
+        Dict with patterns ranked by similarity * success_rate
+    """
+    query_embedding = await embeddings.generate_embedding(query)
+
+    search_method = "semantic"
+    results = []
+
+    if query_embedding is not None:
+        results = await db.search_patterns(
+            embedding=query_embedding,
+            limit=limit,
+            problem_type=problem_type,
+            threshold=threshold
+        )
+    else:
+        # Fallback: keyword search on patterns table
+        search_method = "keyword"
+        results = await db.keyword_search_patterns(
+            query=query,
+            limit=limit,
+            problem_type=problem_type
+        )
+
+    return {
+        "success": True,
+        "query": query,
+        "patterns": results,
+        "count": len(results),
+        "search_method": search_method,
+        "degraded_mode": embeddings.is_degraded(),
+        "problem_type": problem_type
+    }
+
+
+async def get_project_context(
+    db: DatabaseService,
+    embeddings: EmbeddingService,
+    project_path: str,
+    query: Optional[str] = None,
+    limit: int = 10
+) -> Dict[str, Any]:
+    """
+    Get all relevant context for a project.
+
+    Includes fallback to keyword search when Ollama is unavailable.
+
+    Args:
+        db: Database service instance
+        embeddings: Embedding service instance
+        project_path: Path to the project
+        query: Optional query to filter relevant memories
+        limit: Max memories to return
+
+    Returns:
+        Dict with project info and relevant memories
+    """
+    # Get project info
+    project = await db.get_project(project_path)
+
+    # Get recent decisions for this project
+    decisions = await db.get_memories_by_type(
+        memory_type="decision",
+        project_path=project_path,
+        limit=limit
+    )
+
+    # Get patterns used in this project
+    patterns = await db.get_memories_by_type(
+        memory_type="code",
+        project_path=project_path,
+        limit=limit
+    )
+
+    # If query provided, search for relevant memories
+    relevant = []
+    search_method = None
+    if query:
+        query_embedding = await embeddings.generate_embedding(query)
+        if query_embedding is not None:
+            search_method = "semantic"
+            relevant = await db.search_similar(
+                embedding=query_embedding,
+                project_path=project_path,
+                limit=limit,
+                threshold=0.4
+            )
+        else:
+            # Fallback to keyword search
+            search_method = "keyword"
+            relevant = await db.keyword_search(
+                query=query,
+                project_path=project_path,
+                limit=limit
+            )
+
+    return {
+        "success": True,
+        "project": project,
+        "decisions": decisions,
+        "code_patterns": patterns,
+        "relevant_to_query": relevant if query else None,
+        "search_method": search_method,
+        "degraded_mode": embeddings.is_degraded()
+    }

package/skills/state.py

@@ -0,0 +1,182 @@
+"""Session state management skills."""
+from typing import Dict, Any, Optional, List
+from services.database import DatabaseService
+from services.timeline import TimelineService, SESSION_GAP_SECONDS
+
+
+async def state_get(
+    db: DatabaseService,
+    session_id: Optional[str] = None,
+    project_path: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Get current session state.
+
+    Args:
+        db: Database service instance
+        session_id: Specific session ID (optional)
+        project_path: Get latest session for project (if no session_id)
+
+    Returns:
+        Dict with session state
+    """
+    if session_id:
+        state = await db.get_or_create_session_state(session_id, project_path)
+    elif project_path:
+        state = await db.get_latest_session_for_project(project_path)
+        if not state:
+            return {
+                "success": True,
+                "state": None,
+                "message": "No session found for this project"
+            }
+    else:
+        return {
+            "success": False,
+            "error": "Must provide either session_id or project_path"
+        }
+
+    return {
+        "success": True,
+        "state": state,
+        "session_id": state.get("session_id"),
+        "current_goal": state.get("current_goal"),
+        "entity_registry": state.get("entity_registry", {}),
+        "pending_questions": state.get("pending_questions", []),
+        "events_since_checkpoint": state.get("events_since_checkpoint", 0)
+    }
+
+
+async def state_update(
+    db: DatabaseService,
+    session_id: str,
+    current_goal: Optional[str] = None,
+    pending_questions: Optional[List[str]] = None,
+    add_question: Optional[str] = None,
+    remove_question: Optional[str] = None,
+    register_entity: Optional[Dict[str, str]] = None,
+    entity_registry: Optional[Dict[str, str]] = None,
+    add_decision: Optional[str] = None,
+    decisions_summary: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Update session state.
+
+    Args:
+        db: Database service instance
+        session_id: The session ID
+        current_goal: Set current goal
+        pending_questions: Replace pending questions list
+        add_question: Add a single question to pending
+        remove_question: Remove a question from pending
+        register_entity: Add entity to registry {"key": "value"}
+        entity_registry: Replace entire entity registry
+        add_decision: Add a decision to the summary
+        decisions_summary: Replace entire decisions summary
+
+    Returns:
+        Dict with updated state
+    """
+    # Get current state first
+    state = await db.get_or_create_session_state(session_id)
+
+    # Handle question modifications
+    final_questions = pending_questions
+    if final_questions is None:
+        final_questions = state.get("pending_questions", [])
+
+    if add_question and add_question not in final_questions:
+        final_questions = list(final_questions) + [add_question]
+
+    if remove_question and remove_question in final_questions:
+        final_questions = [q for q in final_questions if q != remove_question]
+
+    # Handle entity registry modifications
+    final_registry = entity_registry
+    if final_registry is None:
+        final_registry = state.get("entity_registry", {})
+
+    if register_entity:
+        final_registry = {**final_registry, **register_entity}
+
+    # Handle decisions summary
+    final_decisions = decisions_summary
+    if final_decisions is None:
+        final_decisions = state.get("decisions_summary", "")
+
+    if add_decision:
+        if final_decisions:
+            final_decisions = f"{final_decisions}\n- {add_decision}"
+        else:
+            final_decisions = f"- {add_decision}"
+
+    # Perform update
+    success = await db.update_session_state(
+        session_id=session_id,
+        current_goal=current_goal,
+        pending_questions=final_questions,
+        entity_registry=final_registry,
+        decisions_summary=final_decisions
+    )
+
+    # Get updated state
+    updated_state = await db.get_or_create_session_state(session_id)
+
+    return {
+        "success": success,
+        "session_id": session_id,
+        "state": updated_state,
+        "message": "Session state updated"
+    }
+
+
+async def state_init_session(
+    db: DatabaseService,
+    embeddings,
+    project_path: str
+) -> Dict[str, Any]:
+    """
+    Initialize or resume a session for a project.
+
+    Handles the 4-hour gap logic for session boundaries.
+
+    Args:
+        db: Database service instance
+        embeddings: Embedding service instance
+        project_path: Project path
+
+    Returns:
+        Dict with session info and context
+    """
+    timeline = TimelineService(db, embeddings)
+
+    session_id, is_new, previous_state = await timeline.get_or_create_session(project_path)
+
+    result = {
+        "success": True,
+        "session_id": session_id,
+        "is_new_session": is_new,
+        "project_path": project_path
+    }
+
+    if is_new and previous_state:
+        # Load context from previous session
+        prev_checkpoint = await db.get_latest_checkpoint(previous_state["session_id"])
+        result["previous_session"] = {
+            "session_id": previous_state["session_id"],
+            "last_goal": previous_state.get("current_goal"),
+            "last_activity": previous_state.get("last_activity_at"),
+            "checkpoint": prev_checkpoint
+        }
+        result["message"] = f"New session created (previous session timed out after {SESSION_GAP_SECONDS // 3600}h gap)"
+    elif not is_new:
+        # Load current session context
+        context = await timeline.load_session_context(session_id)
+        result["state"] = context["state"]
+        result["recent_events"] = context["recent_events"][:5]  # Last 5 events
+        result["checkpoint"] = context["checkpoint"]
+        result["message"] = "Continuing existing session"
+    else:
+        result["message"] = "New session created (no previous session)"
+
+    return result

package/skills/store.py

@@ -0,0 +1,179 @@
+"""Store memory skill with rich context support."""
+from typing import Dict, Any, Optional, List
+from services.database import DatabaseService
+from services.embeddings import EmbeddingService
+
+
+async def store_memory(
+    db: DatabaseService,
+    embeddings: EmbeddingService,
+    content: str,
+    memory_type: str = "chunk",
+    metadata: Optional[Dict[str, Any]] = None,
+    session_id: Optional[str] = None,
+    # Project context
+    project_path: Optional[str] = None,
+    project_name: Optional[str] = None,
+    project_type: Optional[str] = None,
+    tech_stack: Optional[List[str]] = None,
+    # Session context
+    chat_id: Optional[str] = None,
+    # Agent context
+    agent_type: Optional[str] = None,
+    skill_used: Optional[str] = None,
+    tools_used: Optional[List[str]] = None,
+    # Outcome
+    outcome: Optional[str] = None,
+    success: Optional[bool] = None,
+    # Classification
+    tags: Optional[List[str]] = None,
+    importance: int = 5
+) -> Dict[str, Any]:
+    """
+    Store a memory with semantic embedding and rich context.
+
+    Args:
+        db: Database service instance
+        embeddings: Embedding service instance
+        content: The text content to store
+        memory_type: Type of memory:
+            - 'session': Session summaries
+            - 'decision': Architectural/design decisions
+            - 'code': Code patterns and snippets
+            - 'chunk': General conversation chunks
+            - 'error': Error patterns and solutions
+            - 'preference': User preferences
+        metadata: Optional additional metadata
+        session_id: Session identifier
+        project_path: Full path to the project
+        project_name: Human-readable project name
+        project_type: Type (wordpress, react, python, etc.)
+        tech_stack: List of technologies used
+        chat_id: Specific chat/conversation ID
+        agent_type: Agent that processed this (Explore, Plan, etc.)
+        skill_used: Skill that was invoked
+        tools_used: List of tools that were called
+        outcome: Description of what happened
+        success: Whether the operation succeeded
+        tags: Classification tags
+        importance: 1-10 scale of importance (default 5)
+
+    Returns:
+        Dict with stored memory ID and status
+    """
+    # Generate embedding for the content
+    embedding = await embeddings.generate_embedding(content)
+
+    # Store in database with full context
+    memory_id = await db.store_memory(
+        memory_type=memory_type,
+        content=content,
+        embedding=embedding,
+        metadata=metadata,
+        session_id=session_id,
+        project_path=project_path,
+        project_name=project_name,
+        project_type=project_type,
+        tech_stack=tech_stack,
+        chat_id=chat_id,
+        agent_type=agent_type,
+        skill_used=skill_used,
+        tools_used=tools_used,
+        outcome=outcome,
+        success=success,
+        tags=tags,
+        importance=importance
+    )
+
+    return {
+        "success": True,
+        "memory_id": memory_id,
+        "type": memory_type,
+        "importance": importance,
+        "project": project_path,
+        "message": f"Memory stored successfully with ID {memory_id}"
+    }
+
+
+async def store_project(
+    db: DatabaseService,
+    path: str,
+    name: Optional[str] = None,
+    project_type: Optional[str] = None,
+    tech_stack: Optional[List[str]] = None,
+    conventions: Optional[Dict[str, Any]] = None,
+    preferences: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Store or update project-level information.
+
+    Args:
+        db: Database service instance
+        path: Full path to the project
+        name: Human-readable project name
+        project_type: Type (wordpress, react, python, etc.)
+        tech_stack: List of technologies
+        conventions: Coding conventions (naming, structure, etc.)
+        preferences: User preferences for this project
+
+    Returns:
+        Dict with project info
+    """
+    project_id = await db.store_project(
+        path=path,
+        name=name,
+        project_type=project_type,
+        tech_stack=tech_stack,
+        conventions=conventions,
+        preferences=preferences
+    )
+
+    return {
+        "success": True,
+        "project_id": project_id,
+        "path": path,
+        "message": f"Project info stored/updated for {path}"
+    }
+
+
+async def store_pattern(
+    db: DatabaseService,
+    embeddings: EmbeddingService,
+    name: str,
+    solution: str,
+    problem_type: Optional[str] = None,
+    tech_context: Optional[List[str]] = None,
+    metadata: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Store a reusable solution pattern.
+
+    Args:
+        db: Database service instance
+        embeddings: Embedding service instance
+        name: Pattern name
+        solution: The solution/approach
+        problem_type: Category (bug_fix, feature, refactor, config, etc.)
+        tech_context: Technologies this applies to
+        metadata: Additional info
+
+    Returns:
+        Dict with pattern info
+    """
+    embedding = await embeddings.generate_embedding(f"{name}: {solution}")
+
+    pattern_id = await db.store_pattern(
+        name=name,
+        solution=solution,
+        embedding=embedding,
+        problem_type=problem_type,
+        tech_context=tech_context,
+        metadata=metadata
+    )
+
+    return {
+        "success": True,
+        "pattern_id": pattern_id,
+        "name": name,
+        "message": f"Pattern '{name}' stored successfully"
+    }