claude-memory-agent 2.0.0

package/services/confidence.py

@@ -0,0 +1,301 @@
+"""Confidence scoring and verification service for memories.
+
+Calculates confidence scores based on:
+- Age (newer = higher confidence)
+- Access count (frequently accessed = higher)
+- Verification status
+- Source reliability
+- Contradiction checks
+"""
+import time
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timedelta
+
+
+class ConfidenceService:
+    """Service for memory confidence scoring and verification.
+
+    Confidence is a value 0-1 representing how reliable a memory is.
+    """
+
+    def __init__(self, db, embeddings):
+        self.db = db
+        self.embeddings = embeddings
+
+        # Weights for confidence calculation
+        self.weights = {
+            "age": 0.20,           # How recent
+            "access": 0.15,        # How often accessed
+            "importance": 0.15,    # User-assigned importance
+            "verification": 0.25,  # Verified status
+            "consistency": 0.25,   # No contradictions
+        }
+
+        # Age decay parameters
+        self.age_half_life_days = 90  # 50% confidence after 90 days
+
+    def _calculate_age_score(self, created_at: str) -> float:
+        """Calculate age-based confidence (exponential decay)."""
+        try:
+            created = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
+            age_days = (datetime.now(created.tzinfo or None) - created).days
+            if age_days < 0:
+                age_days = 0
+
+            # Exponential decay
+            half_life = self.age_half_life_days
+            score = 0.5 ** (age_days / half_life)
+            return max(0.1, min(1.0, score))  # Clamp to [0.1, 1.0]
+        except:
+            return 0.5  # Default for unparseable dates
+
+    def _calculate_access_score(self, access_count: int) -> float:
+        """Calculate access-based confidence (logarithmic growth)."""
+        if access_count <= 0:
+            return 0.3  # Baseline for never accessed
+        # Logarithmic scale - more accesses = higher confidence
+        import math
+        score = 0.3 + 0.7 * (1 - 1 / (1 + math.log(access_count + 1)))
+        return min(1.0, score)
+
+    def _calculate_importance_score(self, importance: int) -> float:
+        """Normalize importance (1-10) to confidence contribution."""
+        return importance / 10.0
+
+    async def calculate_confidence(
+        self,
+        memory_id: int
+    ) -> Dict[str, Any]:
+        """Calculate confidence score for a memory.
+
+        Returns detailed breakdown of confidence components.
+        """
+        cursor = self.db.conn.cursor()
+        cursor.execute("""
+            SELECT id, content, type, importance, created_at,
+                   access_count, decay_factor, metadata
+            FROM memories WHERE id = ?
+        """, [memory_id])
+
+        row = cursor.fetchone()
+        if not row:
+            return {"success": False, "error": "Memory not found"}
+
+        memory = {
+            "id": row[0],
+            "content": row[1],
+            "type": row[2],
+            "importance": row[3] or 5,
+            "created_at": row[4],
+            "access_count": row[5] or 0,
+            "decay_factor": row[6] or 1.0,
+            "metadata": row[7]
+        }
+
+        # Calculate component scores
+        age_score = self._calculate_age_score(memory["created_at"])
+        access_score = self._calculate_access_score(memory["access_count"])
+        importance_score = self._calculate_importance_score(memory["importance"])
+
+        # Check verification status from metadata
+        verified = False
+        if memory.get("metadata"):
+            try:
+                import json
+                meta = json.loads(memory["metadata"])
+                verified = meta.get("verified", False)
+            except:
+                pass
+        verification_score = 1.0 if verified else 0.5
+
+        # Check for contradictions (anchors)
+        consistency_score = await self._check_consistency(memory_id, memory["content"])
+
+        # Apply decay factor
+        decay = memory["decay_factor"]
+
+        # Weighted sum
+        raw_confidence = (
+            self.weights["age"] * age_score +
+            self.weights["access"] * access_score +
+            self.weights["importance"] * importance_score +
+            self.weights["verification"] * verification_score +
+            self.weights["consistency"] * consistency_score
+        ) * decay
+
+        confidence = min(1.0, max(0.0, raw_confidence))
+
+        return {
+            "success": True,
+            "memory_id": memory_id,
+            "confidence": round(confidence, 3),
+            "breakdown": {
+                "age": round(age_score, 3),
+                "access": round(access_score, 3),
+                "importance": round(importance_score, 3),
+                "verification": round(verification_score, 3),
+                "consistency": round(consistency_score, 3),
+                "decay_factor": round(decay, 3)
+            },
+            "verified": verified,
+            "interpretation": self._interpret_confidence(confidence)
+        }
+
+    async def _check_consistency(self, memory_id: int, content: str) -> float:
+        """Check if memory is consistent with anchors."""
+        # Look for any conflicts involving this memory
+        cursor = self.db.conn.cursor()
+        cursor.execute("""
+            SELECT COUNT(*) FROM anchor_conflicts
+            WHERE (anchor1_id = ? OR anchor2_id = ?)
+            AND status = 'unresolved'
+        """, [memory_id, memory_id])
+
+        conflicts = cursor.fetchone()[0]
+
+        if conflicts > 0:
+            return 0.3  # Low consistency if conflicts exist
+        return 1.0  # Full consistency if no conflicts
+
+    def _interpret_confidence(self, confidence: float) -> str:
+        """Human-readable interpretation of confidence score."""
+        if confidence is None:
+            return "Unknown - no confidence score"
+        if confidence >= 0.9:
+            return "Very high - this memory is reliable"
+        elif confidence >= 0.7:
+            return "High - likely accurate"
+        elif confidence >= 0.5:
+            return "Moderate - use with caution"
+        elif confidence >= 0.3:
+            return "Low - may be outdated or unverified"
+        else:
+            return "Very low - consider verification"
+
+    async def verify_memory(
+        self,
+        memory_id: int,
+        verified: bool = True,
+        verified_by: str = "user"
+    ) -> Dict[str, Any]:
+        """Mark a memory as verified or unverified."""
+        import json
+
+        cursor = self.db.conn.cursor()
+
+        # Get current metadata
+        cursor.execute("SELECT metadata FROM memories WHERE id = ?", [memory_id])
+        row = cursor.fetchone()
+        if not row:
+            return {"success": False, "error": "Memory not found"}
+
+        try:
+            metadata = json.loads(row[0]) if row[0] else {}
+        except:
+            metadata = {}
+
+        metadata["verified"] = verified
+        metadata["verified_by"] = verified_by
+        metadata["verified_at"] = datetime.now().isoformat()
+
+        cursor.execute(
+            "UPDATE memories SET metadata = ? WHERE id = ?",
+            [json.dumps(metadata), memory_id]
+        )
+        self.db.conn.commit()
+
+        # Recalculate confidence
+        new_confidence = await self.calculate_confidence(memory_id)
+
+        return {
+            "success": True,
+            "memory_id": memory_id,
+            "verified": verified,
+            "new_confidence": new_confidence.get("confidence")
+        }
+
+    async def mark_outdated(
+        self,
+        memory_id: int,
+        reason: str = "manually marked"
+    ) -> Dict[str, Any]:
+        """Mark a memory as outdated (reduces confidence significantly)."""
+        cursor = self.db.conn.cursor()
+
+        # Set decay factor to low value
+        cursor.execute(
+            "UPDATE memories SET decay_factor = 0.3 WHERE id = ?",
+            [memory_id]
+        )
+        self.db.conn.commit()
+
+        return {
+            "success": True,
+            "memory_id": memory_id,
+            "marked_outdated": True,
+            "reason": reason
+        }
+
+    async def get_low_confidence_memories(
+        self,
+        project_path: Optional[str] = None,
+        threshold: float = 0.5,
+        limit: int = 20
+    ) -> Dict[str, Any]:
+        """Get memories with low confidence that may need verification."""
+        cursor = self.db.conn.cursor()
+
+        query = """
+            SELECT id, content, type, importance, created_at, access_count, decay_factor
+            FROM memories
+            WHERE decay_factor < 0.8 OR access_count = 0
+        """
+        params = []
+
+        if project_path:
+            query += " AND project_path = ?"
+            params.append(project_path)
+
+        query += " ORDER BY decay_factor ASC, access_count ASC LIMIT ?"
+        params.append(limit)
+
+        cursor.execute(query, params)
+        rows = cursor.fetchall()
+
+        results = []
+        for row in rows:
+            memory = {
+                "id": row[0],
+                "content": row[1][:200],
+                "type": row[2],
+                "importance": row[3],
+                "created_at": row[4],
+                "access_count": row[5],
+                "decay_factor": row[6]
+            }
+
+            # Calculate full confidence
+            conf = await self.calculate_confidence(row[0])
+            if conf.get("confidence", 1.0) <= threshold:
+                memory["confidence"] = conf.get("confidence")
+                memory["interpretation"] = conf.get("interpretation")
+                results.append(memory)
+
+        return {
+            "success": True,
+            "low_confidence_memories": results,
+            "count": len(results),
+            "threshold": threshold
+        }
+
+
+# Global instance
+_confidence_service: Optional[ConfidenceService] = None
+
+
+def get_confidence_service(db, embeddings) -> ConfidenceService:
+    """Get the global confidence service."""
+    global _confidence_service
+    if _confidence_service is None:
+        _confidence_service = ConfidenceService(db, embeddings)
+    return _confidence_service

package/services/daily_log.py

@@ -0,0 +1,333 @@
+"""Daily Log Service - Moltbot-inspired human-readable session logs.
+
+Creates and manages YYYY-MM-DD.md append-only files for session activity.
+Provides transparent, human-readable logs that persist beyond context window.
+
+Storage: <project>/.claude/memory/YYYY-MM-DD.md
+"""
+import os
+import logging
+from datetime import date, datetime, timedelta
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+def get_log_path(project_path: str, log_date: Optional[date] = None) -> Path:
+    """Get the path for a daily log file.
+
+    Args:
+        project_path: Root path of the project
+        log_date: Date for the log file (defaults to today)
+
+    Returns:
+        Path to the daily log markdown file
+    """
+    if log_date is None:
+        log_date = date.today()
+
+    # Normalize project path
+    project_path = project_path.replace("\\", "/").rstrip("/")
+
+    # Create memory directory structure
+    memory_dir = Path(project_path) / ".claude" / "memory"
+    memory_dir.mkdir(parents=True, exist_ok=True)
+
+    # Log filename is YYYY-MM-DD.md
+    filename = log_date.strftime("%Y-%m-%d.md")
+    return memory_dir / filename
+
+
+def _get_log_header(log_date: date) -> str:
+    """Generate header for a new daily log file."""
+    return f"# Daily Log - {log_date.strftime('%Y-%m-%d')}\n\n"
+
+
+async def append_entry(
+    project_path: str,
+    content: str,
+    entry_type: str = "note",
+    session_id: Optional[str] = None,
+    timestamp: Optional[datetime] = None
+) -> Dict[str, Any]:
+    """Append an entry to today's daily log.
+
+    Args:
+        project_path: Root path of the project
+        content: Content to append
+        entry_type: Type of entry (decision, accomplishment, note, error, session_summary)
+        session_id: Optional session ID for context
+        timestamp: Optional timestamp (defaults to now)
+
+    Returns:
+        Dict with success status and file path
+    """
+    if timestamp is None:
+        timestamp = datetime.now()
+
+    log_path = get_log_path(project_path)
+
+    # Create file with header if it doesn't exist
+    file_existed = log_path.exists()
+
+    try:
+        with open(log_path, "a", encoding="utf-8") as f:
+            if not file_existed:
+                f.write(_get_log_header(timestamp.date()))
+
+            # Format entry based on type
+            time_str = timestamp.strftime("%H:%M:%S")
+
+            if entry_type == "session_summary":
+                # Session summary gets its own section
+                session_label = f" ({session_id[:8]})" if session_id else ""
+                f.write(f"\n## Session{session_label} - {time_str}\n")
+                f.write(content)
+                f.write("\n\n---\n")
+            elif entry_type == "decision":
+                f.write(f"- **[{time_str}] Decision**: {content}\n")
+            elif entry_type == "accomplishment":
+                f.write(f"- **[{time_str}] Done**: {content}\n")
+            elif entry_type == "error":
+                f.write(f"- **[{time_str}] Error**: {content}\n")
+            else:
+                # Generic note
+                f.write(f"- [{time_str}] {content}\n")
+
+        return {
+            "success": True,
+            "file_path": str(log_path),
+            "entry_type": entry_type,
+            "timestamp": timestamp.isoformat()
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to append to daily log: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+
+async def append_session_summary(
+    project_path: str,
+    session_id: str,
+    decisions: Optional[List[str]] = None,
+    accomplishments: Optional[List[str]] = None,
+    notes: Optional[List[str]] = None,
+    errors_solved: Optional[List[str]] = None,
+    start_time: Optional[datetime] = None,
+    end_time: Optional[datetime] = None
+) -> Dict[str, Any]:
+    """Append a full session summary to the daily log.
+
+    Args:
+        project_path: Root path of the project
+        session_id: Session identifier
+        decisions: List of decisions made
+        accomplishments: List of things accomplished
+        notes: List of notes/observations
+        errors_solved: List of errors that were solved
+        start_time: Session start time
+        end_time: Session end time (defaults to now)
+
+    Returns:
+        Dict with success status
+    """
+    if end_time is None:
+        end_time = datetime.now()
+
+    # Build summary content
+    lines = []
+
+    if start_time:
+        duration = end_time - start_time
+        hours = duration.seconds // 3600
+        minutes = (duration.seconds % 3600) // 60
+        lines.append(f"**Duration**: {hours}h {minutes}m\n")
+
+    if decisions:
+        lines.append("\n### Decisions")
+        for d in decisions:
+            lines.append(f"- {d}")
+
+    if accomplishments:
+        lines.append("\n### Accomplishments")
+        for a in accomplishments:
+            lines.append(f"- {a}")
+
+    if errors_solved:
+        lines.append("\n### Errors Solved")
+        for e in errors_solved:
+            lines.append(f"- {e}")
+
+    if notes:
+        lines.append("\n### Notes")
+        for n in notes:
+            lines.append(f"- {n}")
+
+    content = "\n".join(lines)
+
+    return await append_entry(
+        project_path=project_path,
+        content=content,
+        entry_type="session_summary",
+        session_id=session_id,
+        timestamp=end_time
+    )
+
+
+async def load_recent_logs(
+    project_path: str,
+    days: int = 2,
+    max_chars: int = 8000
+) -> Dict[str, Any]:
+    """Load recent daily logs.
+
+    Args:
+        project_path: Root path of the project
+        days: Number of days to look back (default 2)
+        max_chars: Maximum characters to return (default 8000)
+
+    Returns:
+        Dict with success status and combined log content
+    """
+    logs = []
+    total_chars = 0
+
+    today = date.today()
+
+    for i in range(days):
+        log_date = today - timedelta(days=i)
+        log_path = get_log_path(project_path, log_date)
+
+        if log_path.exists():
+            try:
+                content = log_path.read_text(encoding="utf-8")
+
+                # Check if adding this would exceed limit
+                if total_chars + len(content) > max_chars:
+                    # Truncate to fit
+                    remaining = max_chars - total_chars
+                    if remaining > 200:  # Only include if meaningful content
+                        content = content[:remaining] + "\n\n... (truncated)"
+                        logs.append({
+                            "date": log_date.isoformat(),
+                            "content": content,
+                            "truncated": True
+                        })
+                    break
+
+                logs.append({
+                    "date": log_date.isoformat(),
+                    "content": content,
+                    "truncated": False
+                })
+                total_chars += len(content)
+
+            except Exception as e:
+                logger.warning(f"Failed to read log {log_path}: {e}")
+
+    return {
+        "success": True,
+        "logs": logs,
+        "days_loaded": len(logs),
+        "total_chars": total_chars
+    }
+
+
+async def get_today_highlights(
+    project_path: str,
+    max_entries: int = 10
+) -> Dict[str, Any]:
+    """Get today's log highlights for context injection.
+
+    Extracts the most important entries from today's log.
+
+    Args:
+        project_path: Root path of the project
+        max_entries: Maximum number of entries to return
+
+    Returns:
+        Dict with success status and highlights
+    """
+    log_path = get_log_path(project_path)
+
+    if not log_path.exists():
+        return {
+            "success": True,
+            "highlights": [],
+            "has_log": False
+        }
+
+    try:
+        content = log_path.read_text(encoding="utf-8")
+        lines = content.split("\n")
+
+        highlights = []
+        for line in lines:
+            # Extract important entries (decisions, accomplishments)
+            if "**Decision**" in line or "**Done**" in line:
+                highlights.append(line.strip("- ").strip())
+                if len(highlights) >= max_entries:
+                    break
+
+        return {
+            "success": True,
+            "highlights": highlights,
+            "has_log": True,
+            "entry_count": len(highlights)
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to get highlights: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+
+async def list_logs(
+    project_path: str,
+    limit: int = 30
+) -> Dict[str, Any]:
+    """List available daily log files.
+
+    Args:
+        project_path: Root path of the project
+        limit: Maximum number of logs to list
+
+    Returns:
+        Dict with list of log files and their sizes
+    """
+    memory_dir = Path(project_path) / ".claude" / "memory"
+
+    if not memory_dir.exists():
+        return {
+            "success": True,
+            "logs": [],
+            "total_count": 0
+        }
+
+    logs = []
+    for log_file in sorted(memory_dir.glob("????-??-??.md"), reverse=True):
+        if len(logs) >= limit:
+            break
+
+        try:
+            stat = log_file.stat()
+            logs.append({
+                "date": log_file.stem,
+                "path": str(log_file),
+                "size_bytes": stat.st_size,
+                "modified": datetime.fromtimestamp(stat.st_mtime).isoformat()
+            })
+        except Exception as e:
+            logger.warning(f"Failed to stat {log_file}: {e}")
+
+    return {
+        "success": True,
+        "logs": logs,
+        "total_count": len(logs)
+    }