claude-memory-agent 2.0.0

package/skills/insights.py

@@ -0,0 +1,231 @@
+"""Skills for cross-session learning and insight management.
+
+These skills allow Claude to:
+- Run aggregation to detect patterns
+- Retrieve insights for current context
+- Get CLAUDE.md improvement suggestions
+- Record feedback on insight usefulness
+"""
+from typing import Dict, Any, Optional, List
+from services.insights import get_insights_service
+
+
+async def run_aggregation(
+    db,
+    embeddings,
+    days_back: int = 30
+) -> Dict[str, Any]:
+    """Run cross-session learning aggregation.
+
+    Analyzes memories across sessions to identify:
+    - Recurring error patterns
+    - Repeated decision patterns
+    - User correction patterns (Claude blind spots)
+    - High-value frequently accessed memories
+
+    Args:
+        db: Database service
+        embeddings: Embeddings service
+        days_back: Number of days to analyze
+
+    Returns:
+        Summary of generated insights
+    """
+    insights_service = get_insights_service(db, embeddings)
+    results = await insights_service.run_aggregation(days_back)
+
+    return {
+        "success": True,
+        "message": f"Generated {results['total_insights']} insights",
+        "results": results
+    }
+
+
+async def get_insights(
+    db,
+    embeddings,
+    insight_type: Optional[str] = None,
+    project_path: Optional[str] = None,
+    min_confidence: float = 0.5,
+    limit: int = 10
+) -> Dict[str, Any]:
+    """Retrieve cross-session learning insights.
+
+    Args:
+        db: Database service
+        embeddings: Embeddings service
+        insight_type: Filter by type (recurring_error, decision_pattern,
+                      correction_pattern, high_value_memory)
+        project_path: Filter by project
+        min_confidence: Minimum confidence threshold (0-1)
+        limit: Maximum results
+
+    Returns:
+        List of relevant insights
+    """
+    insights_service = get_insights_service(db, embeddings)
+    insights = await insights_service.get_insights(
+        insight_type=insight_type,
+        project_path=project_path,
+        min_confidence=min_confidence,
+        limit=limit
+    )
+
+    return {
+        "success": True,
+        "insights": insights,
+        "count": len(insights),
+        "filters": {
+            "insight_type": insight_type,
+            "project_path": project_path,
+            "min_confidence": min_confidence
+        }
+    }
+
+
+async def suggest_improvements(
+    db,
+    embeddings,
+    min_confidence: float = 0.7
+) -> Dict[str, Any]:
+    """Get suggestions for CLAUDE.md improvements based on insights.
+
+    Analyzes high-confidence insights that haven't been applied yet
+    and generates actionable instructions to add to CLAUDE.md.
+
+    Args:
+        db: Database service
+        embeddings: Embeddings service
+        min_confidence: Minimum confidence for suggestions
+
+    Returns:
+        List of suggested CLAUDE.md updates
+    """
+    insights_service = get_insights_service(db, embeddings)
+    suggestions = await insights_service.suggest_claude_md_updates(min_confidence)
+
+    return {
+        "success": True,
+        "suggestions": suggestions,
+        "count": len(suggestions),
+        "message": f"Found {len(suggestions)} potential CLAUDE.md improvements"
+    }
+
+
+async def record_insight_feedback(
+    db,
+    embeddings,
+    insight_id: int,
+    helpful: bool,
+    session_id: Optional[str] = None,
+    comment: Optional[str] = None
+) -> Dict[str, Any]:
+    """Record feedback on whether an insight was helpful.
+
+    This helps improve the accuracy of future insights by
+    tracking which patterns are actually useful.
+
+    Args:
+        db: Database service
+        embeddings: Embeddings service
+        insight_id: The insight ID
+        helpful: Whether the insight was helpful
+        session_id: Current session
+        comment: Optional feedback comment
+
+    Returns:
+        Confirmation of recorded feedback
+    """
+    insights_service = get_insights_service(db, embeddings)
+    success = await insights_service.record_feedback(
+        insight_id=insight_id,
+        helpful=helpful,
+        session_id=session_id,
+        comment=comment
+    )
+
+    return {
+        "success": success,
+        "message": "Feedback recorded" if success else "Failed to record feedback",
+        "insight_id": insight_id,
+        "helpful": helpful
+    }
+
+
+async def mark_insight_applied(
+    db,
+    embeddings,
+    insight_id: int
+) -> Dict[str, Any]:
+    """Mark an insight as applied to CLAUDE.md.
+
+    Call this after adding an insight's suggestion to CLAUDE.md
+    to prevent it from being suggested again.
+
+    Args:
+        db: Database service
+        embeddings: Embeddings service
+        insight_id: The insight ID
+
+    Returns:
+        Confirmation
+    """
+    insights_service = get_insights_service(db, embeddings)
+    success = await insights_service.mark_applied_to_claude_md(insight_id)
+
+    return {
+        "success": success,
+        "message": "Insight marked as applied" if success else "Insight not found",
+        "insight_id": insight_id
+    }
+
+
+async def get_project_insights(
+    db,
+    embeddings,
+    project_path: str,
+    include_global: bool = True,
+    limit: int = 10
+) -> Dict[str, Any]:
+    """Get insights relevant to a specific project.
+
+    Retrieves both project-specific insights and global insights
+    that may apply to this project's tech stack.
+
+    Args:
+        db: Database service
+        embeddings: Embeddings service
+        project_path: Project path to get insights for
+        include_global: Include insights without a specific project
+        limit: Maximum results
+
+    Returns:
+        Project-relevant insights
+    """
+    insights_service = get_insights_service(db, embeddings)
+
+    # Get project-specific insights
+    project_insights = await insights_service.get_insights(
+        project_path=project_path,
+        limit=limit
+    )
+
+    result = {
+        "success": True,
+        "project_path": project_path,
+        "project_insights": project_insights,
+        "project_count": len(project_insights)
+    }
+
+    if include_global:
+        # Get global insights (no project_path)
+        global_insights = await insights_service.get_insights(
+            project_path=None,
+            limit=limit // 2
+        )
+        # Filter to only truly global ones
+        global_only = [i for i in global_insights if not i.get("project_path")]
+        result["global_insights"] = global_only
+        result["global_count"] = len(global_only)
+
+    return result

package/skills/natural_language.py

@@ -0,0 +1,277 @@
+"""Natural language interface for memory system.
+
+Allows users to interact with memory using natural commands like:
+- "remember this: ..."
+- "what did I learn about X?"
+- "forget about Y"
+- "show me past errors"
+"""
+import re
+from typing import Dict, Any, Optional, Tuple
+
+
+# Intent patterns - ordered from most specific to least specific
+# More specific patterns (list_errors, list_decisions, etc.) must come before generic "search"
+INTENT_PATTERNS = {
+    "list_errors": [
+        r"(?:show|list|get)\s+(?:me\s+)?(?:past\s+)?errors?",
+        r"what\s+errors?\s+(?:have\s+I\s+)?(?:had|seen|encountered)",
+        r"(?:past|recent)\s+errors?",
+    ],
+    "list_decisions": [
+        r"(?:show|list|get)\s+(?:me\s+)?(?:past\s+)?decisions?",
+        r"what\s+(?:have\s+I\s+)?decided",
+        r"(?:past|recent)\s+decisions?",
+    ],
+    "list_patterns": [
+        r"(?:show|list|get)\s+(?:me\s+)?patterns?",
+        r"what\s+patterns?\s+(?:do\s+I\s+)?(?:have|know)",
+        r"useful\s+patterns?",
+    ],
+    "stats": [
+        r"(?:memory\s+)?stats?",
+        r"how\s+(?:many|much)\s+(?:do\s+I\s+)?remember",
+        r"memory\s+(?:status|info|summary)",
+    ],
+    "project_context": [
+        r"(?:what|tell\s+me)\s+about\s+(?:this\s+)?project",
+        r"project\s+(?:info|context|summary)",
+        r"current\s+project",
+    ],
+    "store": [
+        r"remember\s+(?:this|that)?[:\s]*(.+)",
+        r"save\s+(?:this|that)?[:\s]*(.+)",
+        r"store\s+(?:this|that)?[:\s]*(.+)",
+        r"note\s+(?:this|that)?[:\s]*(.+)",
+        r"keep\s+(?:in\s+mind)?[:\s]*(.+)",
+    ],
+    "forget": [
+        r"forget\s+(?:about\s+)?(.+)",
+        r"delete\s+(?:memory\s+about\s+)?(.+)",
+        r"remove\s+(?:memory\s+about\s+)?(.+)",
+        r"clear\s+(?:memory\s+about\s+)?(.+)",
+    ],
+    "search": [
+        r"what\s+(?:did\s+I|do\s+I|have\s+I)\s+(?:learn|know|remember)\s+about\s+(.+)",
+        r"show\s+me\s+(?:memories?\s+about\s+)?(.+)",
+        r"find\s+(?:memories?\s+about\s+)?(.+)",
+        r"search\s+(?:for\s+)?(.+)",
+        r"recall\s+(.+)",
+        r"what\s+about\s+(.+)",
+    ],
+}
+
+
+def parse_intent(text: str) -> Tuple[Optional[str], Optional[str]]:
+    """Parse natural language to determine intent and extract content.
+
+    Returns:
+        Tuple of (intent, extracted_content)
+    """
+    text = text.strip().lower()
+
+    for intent, patterns in INTENT_PATTERNS.items():
+        for pattern in patterns:
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                # Extract captured group if any
+                content = match.group(1).strip() if match.groups() else None
+                return intent, content
+
+    return None, None
+
+
+async def process_natural_command(
+    db,
+    embeddings,
+    command: str,
+    project_path: Optional[str] = None,
+    session_id: Optional[str] = None
+) -> Dict[str, Any]:
+    """Process a natural language memory command.
+
+    Args:
+        db: Database service
+        embeddings: Embeddings service
+        command: Natural language command
+        project_path: Current project path
+        session_id: Current session ID
+
+    Returns:
+        Result of the processed command
+    """
+    intent, content = parse_intent(command)
+
+    if not intent:
+        return {
+            "success": False,
+            "understood": False,
+            "message": "I didn't understand that memory command. Try:\n"
+                      "- 'remember this: [content]'\n"
+                      "- 'what did I learn about [topic]?'\n"
+                      "- 'show me past errors'\n"
+                      "- 'memory stats'"
+        }
+
+    result = {"success": True, "understood": True, "intent": intent}
+
+    if intent == "store":
+        if not content:
+            return {"success": False, "message": "What should I remember?"}
+
+        from skills.store import store_memory
+        store_result = await store_memory(
+            db=db,
+            embeddings=embeddings,
+            content=content,
+            memory_type="chunk",
+            project_path=project_path,
+            session_id=session_id,
+            importance=6,
+            tags=["natural-language", "user-stored"]
+        )
+        result["memory_id"] = store_result.get("memory_id")
+        result["message"] = f"Got it! I'll remember that. (Memory #{result['memory_id']})"
+
+    elif intent == "search":
+        if not content:
+            return {"success": False, "message": "What should I search for?"}
+
+        from skills.search import semantic_search
+        search_result = await semantic_search(
+            db=db,
+            embeddings=embeddings,
+            query=content,
+            project_path=project_path,
+            limit=5
+        )
+
+        results = search_result.get("results", [])
+        if results:
+            result["results"] = results
+            result["message"] = f"Found {len(results)} related memories:\n"
+            for i, r in enumerate(results[:3], 1):
+                result["message"] += f"\n{i}. {r['content'][:150]}..."
+        else:
+            result["message"] = f"No memories found about '{content}'"
+
+    elif intent == "forget":
+        if not content:
+            return {"success": False, "message": "What should I forget?"}
+
+        # Search and mark for deletion (soft delete via archive)
+        from skills.search import semantic_search
+        search_result = await semantic_search(
+            db=db,
+            embeddings=embeddings,
+            query=content,
+            project_path=project_path,
+            limit=3,
+            threshold=0.7  # High threshold to be sure
+        )
+
+        results = search_result.get("results", [])
+        if results:
+            # Archive the most relevant match
+            from services.cleanup import get_cleanup_service
+            cleanup = get_cleanup_service(db, embeddings)
+            top_result = results[0]
+            await cleanup._archive_memory(
+                top_result["id"],
+                "user_requested",
+                f"User asked to forget: {content}"
+            )
+            result["archived_id"] = top_result["id"]
+            result["message"] = f"Archived memory about: {top_result['content'][:100]}..."
+        else:
+            result["message"] = f"No memories found matching '{content}'"
+
+    elif intent == "list_errors":
+        from skills.search import semantic_search
+        errors = await semantic_search(
+            db=db,
+            embeddings=embeddings,
+            query="error bug problem exception",
+            project_path=project_path,
+            memory_type="error",
+            limit=5
+        )
+
+        results = errors.get("results", [])
+        if results:
+            result["results"] = results
+            result["message"] = f"Found {len(results)} past errors:\n"
+            for i, r in enumerate(results[:5], 1):
+                status = "Fixed" if r.get("success") else "Unresolved"
+                result["message"] += f"\n{i}. [{status}] {r['content'][:100]}..."
+        else:
+            result["message"] = "No past errors recorded"
+
+    elif intent == "list_decisions":
+        from skills.search import semantic_search
+        decisions = await semantic_search(
+            db=db,
+            embeddings=embeddings,
+            query="decided chose selected approach",
+            project_path=project_path,
+            memory_type="decision",
+            limit=5
+        )
+
+        results = decisions.get("results", [])
+        if results:
+            result["results"] = results
+            result["message"] = f"Found {len(results)} past decisions:\n"
+            for i, r in enumerate(results[:5], 1):
+                result["message"] += f"\n{i}. {r['content'][:100]}..."
+        else:
+            result["message"] = "No past decisions recorded"
+
+    elif intent == "list_patterns":
+        from skills.search import search_patterns
+        patterns = await search_patterns(
+            db=db,
+            embeddings=embeddings,
+            query="pattern solution approach",
+            limit=5
+        )
+
+        results = patterns.get("patterns", [])
+        if results:
+            result["results"] = results
+            result["message"] = f"Found {len(results)} patterns:\n"
+            for i, p in enumerate(results[:5], 1):
+                result["message"] += f"\n{i}. **{p['name']}**: {p['solution'][:80]}..."
+        else:
+            result["message"] = "No patterns recorded"
+
+    elif intent == "stats":
+        stats = await db.get_stats()
+        result["stats"] = stats
+        result["message"] = (
+            f"Memory Stats:\n"
+            f"- Total memories: {stats.get('total_memories', 0)}\n"
+            f"- Patterns: {stats.get('total_patterns', 0)}\n"
+            f"- Projects: {stats.get('total_projects', 0)}"
+        )
+
+    elif intent == "project_context":
+        from skills.search import get_project_context
+        context = await get_project_context(
+            db=db,
+            embeddings=embeddings,
+            project_path=project_path
+        )
+
+        if context.get("project"):
+            proj = context["project"]
+            result["project"] = proj
+            result["message"] = (
+                f"Project: {proj.get('name', 'Unknown')}\n"
+                f"Type: {proj.get('project_type', 'Unknown')}\n"
+                f"Tech Stack: {', '.join(proj.get('tech_stack', []))}"
+            )
+        else:
+            result["message"] = "No project info stored for this path"
+
+    return result

package/skills/retrieve.py

@@ -0,0 +1,67 @@
+"""Retrieve memory skill with project filtering."""
+from typing import Dict, Any, Optional, List
+from services.database import DatabaseService
+
+
+async def retrieve_memory(
+    db: DatabaseService,
+    memory_id: Optional[int] = None,
+    memory_type: Optional[str] = None,
+    session_id: Optional[str] = None,
+    project_path: Optional[str] = None,
+    limit: int = 10
+) -> Dict[str, Any]:
+    """
+    Retrieve memories by ID or filter criteria.
+
+    Args:
+        db: Database service instance
+        memory_id: Specific memory ID to retrieve
+        memory_type: Filter by memory type
+        session_id: Filter by session ID
+        project_path: Filter by project path
+        limit: Maximum number of memories to return
+
+    Returns:
+        Dict with retrieved memories
+    """
+    if memory_id:
+        memory = await db.get_memory(memory_id)
+        if memory:
+            return {
+                "success": True,
+                "memories": [memory],
+                "count": 1
+            }
+        return {
+            "success": False,
+            "message": f"Memory with ID {memory_id} not found",
+            "memories": [],
+            "count": 0
+        }
+
+    if memory_type:
+        memories = await db.get_memories_by_type(
+            memory_type=memory_type,
+            limit=limit,
+            session_id=session_id,
+            project_path=project_path
+        )
+        return {
+            "success": True,
+            "memories": memories,
+            "count": len(memories),
+            "filters": {
+                "type": memory_type,
+                "project": project_path,
+                "session": session_id
+            }
+        }
+
+    # Return stats if no specific criteria
+    stats = await db.get_stats()
+    return {
+        "success": True,
+        "stats": stats,
+        "message": "Provide memory_id or memory_type to retrieve specific memories"
+    }