agmem 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

memvcs/core/access_index.py

@@ -0,0 +1,167 @@
+"""
+Access index for agmem - tracks recall access patterns for importance weighting and decay.
+
+Stores access log and recall cache in .mem/index.json.
+"""
+
+import json
+import hashlib
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+# Maximum entries in access log before compaction
+ACCESS_LOG_MAX = 10_000
+
+
+class AccessIndex:
+    """Tracks access patterns for recall, importance, and decay."""
+
+    def __init__(self, mem_dir: Path):
+        self.mem_dir = Path(mem_dir)
+        self.index_path = self.mem_dir / "index.json"
+        self._data: Optional[Dict[str, Any]] = None
+
+    def _load(self) -> Dict[str, Any]:
+        """Load index from disk."""
+        if self._data is not None:
+            return self._data
+        if self.index_path.exists():
+            try:
+                self._data = json.loads(self.index_path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                self._data = self._default_structure()
+        else:
+            self._data = self._default_structure()
+        return self._data
+
+    def _default_structure(self) -> Dict[str, Any]:
+        """Return default index structure."""
+        return {
+            "version": 1,
+            "access_log": [],
+            "recall_cache": {},
+        }
+
+    def _save(self, data: Optional[Dict[str, Any]] = None) -> None:
+        """Save index to disk."""
+        data = data or self._data
+        if data is None:
+            return
+        self.mem_dir.mkdir(parents=True, exist_ok=True)
+        self.index_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        self._data = data
+
+    def record_access(self, path: str, commit: str, timestamp: Optional[str] = None) -> None:
+        """
+        Record that a memory file was accessed (e.g., during recall).
+
+        Args:
+            path: File path relative to current/
+            commit: Commit hash at time of access
+            timestamp: ISO 8601 timestamp (default: now)
+        """
+        data = self._load()
+        ts = timestamp or datetime.utcnow().isoformat() + "Z"
+        data["access_log"].append({"path": path, "commit": commit, "timestamp": ts})
+        self._trim_access_log_if_needed(data)
+        self._save()
+
+    def _trim_access_log_if_needed(self, data: Dict[str, Any]) -> None:
+        if len(data.get("access_log", [])) > ACCESS_LOG_MAX:
+            data["access_log"] = data["access_log"][-ACCESS_LOG_MAX:]
+
+    def get_access_count(self, path: Optional[str] = None, commit: Optional[str] = None) -> int:
+        """
+        Get access count for a path and/or commit.
+
+        Args:
+            path: Filter by path (None = any)
+            commit: Filter by commit (None = any)
+
+        Returns:
+            Number of matching access entries
+        """
+        data = self._load()
+        entries = data.get("access_log", [])
+        count = 0
+        for entry in entries:
+            if path is not None and entry.get("path") != path:
+                continue
+            if commit is not None and entry.get("commit") != commit:
+                continue
+            count += 1
+        return count
+
+    def get_recent_accesses(
+        self,
+        limit: int = 100,
+        path: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Get most recent access entries.
+
+        Args:
+            limit: Max entries to return
+            path: Filter by path (None = any)
+
+        Returns:
+            List of access entries (newest first)
+        """
+        data = self._load()
+        entries = data.get("access_log", [])
+        if path is not None:
+            entries = [e for e in entries if e.get("path") == path]
+        return list(reversed(entries[-limit:]))
+
+    def get_access_counts_by_path(self) -> Dict[str, int]:
+        """Aggregate access counts per path (for importance weighting)."""
+        data = self._load()
+        counts: Dict[str, int] = {}
+        for entry in data.get("access_log", []):
+            p = entry.get("path", "")
+            counts[p] = counts.get(p, 0) + 1
+        return counts
+
+    def get_cache_key(self, context: str, strategy: str, limit: int, exclude: List[str]) -> str:
+        """Compute cache key for recall results."""
+        payload = f"{context}|{strategy}|{limit}|{','.join(sorted(exclude))}"
+        return hashlib.sha256(payload.encode()).hexdigest()
+
+    def get_cached_recall(
+        self,
+        context: str,
+        strategy: str,
+        limit: int,
+        exclude: List[str],
+    ) -> Optional[Dict[str, Any]]:
+        """Get cached recall results if available."""
+        key = self.get_cache_key(context, strategy, limit, exclude)
+        data = self._load()
+        cache = data.get("recall_cache", {})
+        return cache.get(key)
+
+    def set_cached_recall(
+        self,
+        context: str,
+        strategy: str,
+        limit: int,
+        exclude: List[str],
+        results: List[Dict[str, Any]],
+    ) -> None:
+        """Cache recall results."""
+        key = self.get_cache_key(context, strategy, limit, exclude)
+        data = self._load()
+        if "recall_cache" not in data:
+            data["recall_cache"] = {}
+        data["recall_cache"][key] = {
+            "results": results,
+            "cached_at": datetime.utcnow().isoformat() + "Z",
+        }
+        # Limit cache size
+        cache = data["recall_cache"]
+        if len(cache) > 100:
+            oldest = sorted(cache.items(), key=lambda x: x[1].get("cached_at", ""))[:50]
+            for k, _ in oldest:
+                del cache[k]
+        self._save()

memvcs/core/audit.py

@@ -0,0 +1,124 @@
+"""
+Tamper-evident audit trail for agmem.
+
+Append-only, hash-chained log of significant operations.
+"""
+
+import datetime
+import hashlib
+import hmac
+import json
+import os
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Tuple
+
+
+def _audit_dir(mem_dir: Path) -> Path:
+    return mem_dir / "audit"
+
+
+def _log_path(mem_dir: Path) -> Path:
+    return _audit_dir(mem_dir) / "log"
+
+
+def _get_previous_hash(mem_dir: Path) -> str:
+    """Read last line of audit log and return its entry hash, or empty for first entry."""
+    path = _log_path(mem_dir)
+    if not path.exists():
+        return ""
+    lines = path.read_text().strip().split("\n")
+    if not lines:
+        return ""
+    # Format per line: entry_hash\tpayload_json
+    for line in reversed(lines):
+        line = line.strip()
+        if not line:
+            continue
+        if "\t" in line:
+            return line.split("\t", 1)[0]
+        return ""
+    return ""
+
+
+def _hash_entry(prev_hash: str, payload: str) -> str:
+    """Compute this entry's hash: SHA-256(prev_hash + payload)."""
+    return hashlib.sha256((prev_hash + payload).encode()).hexdigest()
+
+
+def append_audit(
+    mem_dir: Path,
+    operation: str,
+    details: Optional[Dict[str, Any]] = None,
+) -> None:
+    """
+    Append a tamper-evident audit entry. Write synchronously.
+    Each entry: entry_hash TAB payload_json (payload has timestamp, operation, details, prev_hash).
+    """
+    mem_dir = Path(mem_dir)
+    _audit_dir(mem_dir).mkdir(parents=True, exist_ok=True)
+    path = _log_path(mem_dir)
+    prev_hash = _get_previous_hash(mem_dir)
+    payload = {
+        "timestamp": datetime.datetime.utcnow().isoformat() + "Z",
+        "operation": operation,
+        "details": details or {},
+        "prev_hash": prev_hash,
+    }
+    payload_str = json.dumps(payload, sort_keys=True)
+    entry_hash = _hash_entry(prev_hash, payload_str)
+    line = f"{entry_hash}\t{payload_str}\n"
+    with open(path, "a", encoding="utf-8") as f:
+        f.write(line)
+        f.flush()
+        try:
+            os.fsync(f.fileno())
+        except (AttributeError, OSError):
+            pass
+
+
+def read_audit(mem_dir: Path, max_entries: int = 1000) -> List[Dict[str, Any]]:
+    """Read audit log entries (newest first). Each entry has entry_hash, prev_hash, timestamp, operation, details."""
+    path = _log_path(mem_dir)
+    if not path.exists():
+        return []
+    entries = []
+    for line in reversed(path.read_text().strip().split("\n")):
+        line = line.strip()
+        if not line:
+            continue
+        if "\t" not in line:
+            continue
+        entry_hash, payload_str = line.split("\t", 1)
+        try:
+            payload = json.loads(payload_str)
+        except json.JSONDecodeError:
+            continue
+        payload["entry_hash"] = entry_hash
+        entries.append(payload)
+        if len(entries) >= max_entries:
+            break
+    return entries
+
+
+def verify_audit(mem_dir: Path) -> Tuple[bool, Optional[int]]:
+    """
+    Verify the audit log chain. Returns (valid, first_bad_index).
+    first_bad_index is 0-based index of first entry that fails chain verification.
+    """
+    path = _log_path(mem_dir)
+    if not path.exists():
+        return (True, None)
+    lines = path.read_text().strip().split("\n")
+    prev_hash = ""
+    for i, line in enumerate(lines):
+        line = line.strip()
+        if not line:
+            continue
+        if "\t" not in line:
+            return (False, i)
+        entry_hash, payload_str = line.split("\t", 1)
+        expected_hash = _hash_entry(prev_hash, payload_str)
+        if not hmac.compare_digest(entry_hash, expected_hash):
+            return (False, i)
+        prev_hash = entry_hash
+    return (True, None)

memvcs/core/config_loader.py

@@ -13,6 +13,7 @@ from typing import Any, Dict, List, Optional
 
 try:
     import yaml
+
     YAML_AVAILABLE = True
 except ImportError:
     YAML_AVAILABLE = False
@@ -116,7 +117,8 @@ def _apply_gcs_credentials_path(config: Dict[str, Any], repo_root: Optional[Path
         config[CONFIG_CLOUD][CONFIG_CLOUD_GCS]["credentials_path"] = resolved
     else:
         config[CONFIG_CLOUD][CONFIG_CLOUD_GCS] = {
-            k: v for k, v in config[CONFIG_CLOUD][CONFIG_CLOUD_GCS].items()
+            k: v
+            for k, v in config[CONFIG_CLOUD][CONFIG_CLOUD_GCS].items()
             if k != "credentials_path"
         }
 

memvcs/core/consistency.py

@@ -0,0 +1,214 @@
+"""
+Consistency checker - belief consistency for agmem semantic memories.
+
+Extracts (subject, predicate, object) triples and detects logical contradictions.
+"""
+
+import re
+from pathlib import Path
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass, field
+
+from .constants import MEMORY_TYPES
+from .schema import FrontmatterParser
+
+
+@dataclass
+class Triple:
+    """A (subject, predicate, object) triple."""
+
+    subject: str
+    predicate: str
+    obj: str
+    confidence: float
+    source: str
+    line: int
+
+
+@dataclass
+class Contradiction:
+    """A detected contradiction."""
+
+    triple1: Triple
+    triple2: Triple
+    reason: str
+
+
+@dataclass
+class ConsistencyResult:
+    """Result of consistency check."""
+
+    valid: bool
+    contradictions: List[Contradiction] = field(default_factory=list)
+    triples: List[Triple] = field(default_factory=list)
+    files_checked: int = 0
+
+
+# Inverse predicate pairs (A likes B vs B disliked by A)
+INVERSE_PREDICATES = [
+    ("likes", "dislikes"),
+    ("prefers", "avoids"),
+    ("uses", "avoids"),
+    ("enables", "disables"),
+    ("true", "false"),
+]
+
+
+class ConsistencyChecker:
+    """Detects logical contradictions in semantic memories."""
+
+    def __init__(self, repo: Any, llm_provider: Optional[str] = None):
+        self.repo = repo
+        self.llm_provider = llm_provider
+        self.current_dir = repo.root / "current"
+
+    def _extract_triples_simple(self, content: str, source: str) -> List[Triple]:
+        """Simple heuristic extraction of triples from text."""
+        triples = []
+        for i, line in enumerate(content.splitlines(), 1):
+            line = line.strip()
+            if not line or line.startswith("#") or line.startswith("---"):
+                continue
+            # Pattern: "user prefers X", "user likes Y", "X uses Y"
+            m = re.search(r"(user|agent)\s+(prefers|likes|uses|avoids|dislikes)\s+(.+)", line, re.I)
+            if m:
+                subj, pred, obj = m.group(1), m.group(2), m.group(3).strip()
+                triples.append(
+                    Triple(
+                        subject=subj.lower(),
+                        predicate=pred.lower(),
+                        obj=obj[:100],
+                        confidence=0.6,
+                        source=source,
+                        line=i,
+                    )
+                )
+            # Pattern: "X is Y"
+            m = re.search(r"^(.+?)\s+is\s+(.+?)(?:\.|$)", line)
+            if m:
+                subj, obj = m.group(1).strip(), m.group(2).strip()
+                triples.append(
+                    Triple(
+                        subject=subj[:50],
+                        predicate="is",
+                        obj=obj[:100],
+                        confidence=0.5,
+                        source=source,
+                        line=i,
+                    )
+                )
+        return triples
+
+    def _extract_triples_llm(self, content: str, source: str) -> List[Triple]:
+        """Extract triples using LLM (multi-provider)."""
+        try:
+            from .llm import get_provider
+
+            provider = get_provider(provider_name=self.llm_provider)
+            if not provider:
+                return []
+            text = provider.complete(
+                [
+                    {
+                        "role": "system",
+                        "content": "Extract factual statements as (subject, predicate, object) triples. One per line, format: SUBJECT | PREDICATE | OBJECT",
+                    },
+                    {"role": "user", "content": content[:3000]},
+                ],
+                max_tokens=500,
+            )
+            triples = []
+            for i, line in enumerate(text.splitlines(), 1):
+                if "|" in line:
+                    parts = [p.strip() for p in line.split("|", 2)]
+                    if len(parts) >= 3:
+                        triples.append(
+                            Triple(
+                                subject=parts[0][:50],
+                                predicate=parts[1][:30],
+                                obj=parts[2][:100],
+                                confidence=0.8,
+                                source=source,
+                                line=i,
+                            )
+                        )
+            return triples
+        except Exception:
+            return []
+
+    def extract_triples(self, content: str, source: str, use_llm: bool = False) -> List[Triple]:
+        """Extract triples from content."""
+        if use_llm and self.llm_provider:
+            t = self._extract_triples_llm(content, source)
+            if t:
+                return t
+        return self._extract_triples_simple(content, source)
+
+    def _are_inverse(self, pred1: str, pred2: str) -> bool:
+        """Check if predicates are inverses."""
+        for a, b in INVERSE_PREDICATES:
+            if (pred1 == a and pred2 == b) or (pred1 == b and pred2 == a):
+                return True
+        return False
+
+    def _same_subject_object(self, t1: Triple, t2: Triple) -> bool:
+        """Check if triples refer to same subject and object."""
+        s1, o1 = t1.subject.lower(), t1.obj.lower()
+        s2, o2 = t2.subject.lower(), t2.obj.lower()
+        return (s1 == s2 and o1 == o2) or (s1 == o2 and o1 == s2)
+
+    def detect_contradictions(self, triples: List[Triple]) -> List[Contradiction]:
+        """Detect contradictions among triples."""
+        contradictions = []
+        for i, t1 in enumerate(triples):
+            for t2 in triples[i + 1 :]:
+                if self._same_subject_object(t1, t2) and self._are_inverse(
+                    t1.predicate, t2.predicate
+                ):
+                    contradictions.append(
+                        Contradiction(
+                            triple1=t1,
+                            triple2=t2,
+                            reason=f"{t1.predicate} vs {t2.predicate}",
+                        )
+                    )
+        return contradictions
+
+    def check(self, use_llm: bool = False) -> ConsistencyResult:
+        """Check consistency of semantic memories."""
+        triples = []
+        files_checked = 0
+
+        if not self.current_dir.exists():
+            return ConsistencyResult(valid=True, files_checked=0)
+
+        semantic_dir = self.current_dir / "semantic"
+        if not semantic_dir.exists():
+            return ConsistencyResult(valid=True, files_checked=0)
+
+        for f in semantic_dir.rglob("*.md"):
+            if not f.is_file():
+                continue
+            try:
+                rel = str(f.relative_to(self.current_dir))
+                content = f.read_text(encoding="utf-8", errors="replace")
+            except Exception:
+                continue
+            files_checked += 1
+            triples.extend(self.extract_triples(content, rel, use_llm))
+
+        contradictions = self.detect_contradictions(triples)
+        return ConsistencyResult(
+            valid=len(contradictions) == 0,
+            contradictions=contradictions,
+            triples=triples,
+            files_checked=files_checked,
+        )
+
+    def repair(self, strategy: str = "confidence") -> ConsistencyResult:
+        """Attempt to auto-fix contradictions using strategy."""
+        result = self.check(use_llm=(strategy == "llm"))
+        if result.valid:
+            return result
+        # For now, repair just reports - actual fix would modify files
+        return result