PyPI - agmem - Versions diffs - 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl - Mend

agmem 0.1.1py3-none-any.whl → 0.1.2py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (80) hide show

{agmem-0.1.1.dist-info → agmem-0.1.2.dist-info}/METADATA +20 -3
agmem-0.1.2.dist-info/RECORD +86 -0
memvcs/__init__.py +1 -1
memvcs/cli.py +35 -31
memvcs/commands/__init__.py +9 -9
memvcs/commands/add.py +77 -76
memvcs/commands/blame.py +46 -53
memvcs/commands/branch.py +13 -33
memvcs/commands/checkout.py +27 -32
memvcs/commands/clean.py +18 -23
memvcs/commands/clone.py +4 -1
memvcs/commands/commit.py +40 -39
memvcs/commands/daemon.py +81 -76
memvcs/commands/decay.py +77 -0
memvcs/commands/diff.py +56 -57
memvcs/commands/distill.py +74 -0
memvcs/commands/fsck.py +55 -61
memvcs/commands/garden.py +28 -37
memvcs/commands/graph.py +41 -48
memvcs/commands/init.py +16 -24
memvcs/commands/log.py +25 -40
memvcs/commands/merge.py +16 -28
memvcs/commands/pack.py +129 -0
memvcs/commands/pull.py +4 -1
memvcs/commands/push.py +4 -2
memvcs/commands/recall.py +145 -0
memvcs/commands/reflog.py +13 -22
memvcs/commands/remote.py +1 -0
memvcs/commands/repair.py +66 -0
memvcs/commands/reset.py +23 -33
memvcs/commands/resurrect.py +82 -0
memvcs/commands/search.py +3 -4
memvcs/commands/serve.py +2 -1
memvcs/commands/show.py +66 -36
memvcs/commands/stash.py +34 -34
memvcs/commands/status.py +27 -35
memvcs/commands/tag.py +23 -47
memvcs/commands/test.py +30 -44
memvcs/commands/timeline.py +111 -0
memvcs/commands/tree.py +26 -27
memvcs/commands/verify.py +59 -0
memvcs/commands/when.py +115 -0
memvcs/core/access_index.py +167 -0
memvcs/core/config_loader.py +3 -1
memvcs/core/consistency.py +214 -0
memvcs/core/decay.py +185 -0
memvcs/core/diff.py +158 -143
memvcs/core/distiller.py +277 -0
memvcs/core/gardener.py +164 -132
memvcs/core/hooks.py +48 -14
memvcs/core/knowledge_graph.py +134 -138
memvcs/core/merge.py +248 -171
memvcs/core/objects.py +95 -96
memvcs/core/pii_scanner.py +147 -146
memvcs/core/refs.py +132 -115
memvcs/core/repository.py +174 -164
memvcs/core/schema.py +155 -113
memvcs/core/staging.py +60 -65
memvcs/core/storage/__init__.py +20 -18
memvcs/core/storage/base.py +74 -70
memvcs/core/storage/gcs.py +70 -68
memvcs/core/storage/local.py +42 -40
memvcs/core/storage/s3.py +105 -110
memvcs/core/temporal_index.py +112 -0
memvcs/core/test_runner.py +101 -93
memvcs/core/vector_store.py +41 -35
memvcs/integrations/mcp_server.py +1 -3
memvcs/integrations/web_ui/server.py +25 -26
memvcs/retrieval/__init__.py +22 -0
memvcs/retrieval/base.py +54 -0
memvcs/retrieval/pack.py +128 -0
memvcs/retrieval/recaller.py +105 -0
memvcs/retrieval/strategies.py +314 -0
memvcs/utils/__init__.py +3 -3
memvcs/utils/helpers.py +52 -52
agmem-0.1.1.dist-info/RECORD +0 -67
{agmem-0.1.1.dist-info → agmem-0.1.2.dist-info}/WHEEL +0 -0
{agmem-0.1.1.dist-info → agmem-0.1.2.dist-info}/entry_points.txt +0 -0
{agmem-0.1.1.dist-info → agmem-0.1.2.dist-info}/licenses/LICENSE +0 -0
{agmem-0.1.1.dist-info → agmem-0.1.2.dist-info}/top_level.txt +0 -0

memvcs/integrations/web_ui/server.py CHANGED Viewed

@@ -50,7 +50,9 @@ def create_app(repo_path: Path) -> FastAPI:
         if not repo.is_valid_repo():
             raise HTTPException(status_code=400, detail="Not an agmem repository")
-        resolved = repo.resolve_ref(commit_hash) or (commit_hash if _valid_commit_hash(commit_hash) else None)
+        resolved = repo.resolve_ref(commit_hash) or (
+            commit_hash if _valid_commit_hash(commit_hash) else None
+        )
         if not resolved:
             raise HTTPException(status_code=400, detail="Invalid revision or hash")
         c = Commit.load(repo.object_store, resolved)
@@ -87,13 +89,15 @@ def create_app(repo_path: Path) -> FastAPI:
         tree_diff = engine.diff_commits(c1, c2)
         files = []
         for fd in tree_diff.files:
-            files.append({
-                "path": fd.path,
-                "diff_type": fd.diff_type.value,
-                "old_hash": fd.old_hash,
-                "new_hash": fd.new_hash,
-                "diff_lines": fd.diff_lines,
-            })
+            files.append(
+                {
+                    "path": fd.path,
+                    "diff_type": fd.diff_type.value,
+                    "old_hash": fd.old_hash,
+                    "new_hash": fd.new_hash,
+                    "diff_lines": fd.diff_lines,
+                }
+            )
         return {
             "base": base,
             "head": head,
@@ -138,37 +142,32 @@ def create_app(repo_path: Path) -> FastAPI:
         if include_similarity:
             try:
                 from memvcs.core.vector_store import VectorStore
-                vector_store = VectorStore(_repo_path / '.mem')
+                vector_store = VectorStore(_repo_path / ".mem")
             except ImportError:
                 pass
         builder = KnowledgeGraphBuilder(repo, vector_store)
         graph_data = builder.build_graph(
-            include_similarity=include_similarity,
-            similarity_threshold=threshold
+            include_similarity=include_similarity, similarity_threshold=threshold
         )
         # Return D3-compatible format
         return {
-            'nodes': [
+            "nodes": [
                 {
-                    'id': n.id,
-                    'name': n.label,
-                    'group': n.memory_type,
-                    'size': min(20, max(5, n.size // 100))
+                    "id": n.id,
+                    "name": n.label,
+                    "group": n.memory_type,
+                    "size": min(20, max(5, n.size // 100)),
                 }
                 for n in graph_data.nodes
             ],
-            'links': [
-                {
-                    'source': e.source,
-                    'target': e.target,
-                    'type': e.edge_type,
-                    'value': e.weight
-                }
+            "links": [
+                {"source": e.source, "target": e.target, "type": e.edge_type, "value": e.weight}
                 for e in graph_data.edges
             ],
-            'metadata': graph_data.metadata
+            "metadata": graph_data.metadata,
         }
     @app.get("/graph", response_class=HTMLResponse)
@@ -185,7 +184,7 @@ def create_app(repo_path: Path) -> FastAPI:
 # Embedded graph viewer template
-GRAPH_HTML_TEMPLATE = '''<!DOCTYPE html>
+GRAPH_HTML_TEMPLATE = """<!DOCTYPE html>
 <html>
 <head>
     <title>agmem Knowledge Graph</title>
@@ -349,4 +348,4 @@ GRAPH_HTML_TEMPLATE = '''<!DOCTYPE html>
     </script>
 </body>
 </html>
-'''
+"""

memvcs/retrieval/__init__.py ADDED Viewed

@@ -0,0 +1,22 @@
+"""
+Retrieval module for agmem - context-aware recall with pluggable strategies.
+"""
+from .base import RetrievalStrategy, RecallResult
+from .strategies import (
+    RecencyStrategy,
+    ImportanceStrategy,
+    SimilarityStrategy,
+    HybridStrategy,
+)
+from .recaller import RecallEngine
+__all__ = [
+    "RetrievalStrategy",
+    "RecallResult",
+    "RecencyStrategy",
+    "ImportanceStrategy",
+    "SimilarityStrategy",
+    "HybridStrategy",
+    "RecallEngine",
+]

memvcs/retrieval/base.py ADDED Viewed

@@ -0,0 +1,54 @@
+"""
+Base retrieval interfaces for agmem recall.
+"""
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List, Any, Optional
+@dataclass
+class RecallResult:
+    """Single recalled memory with metadata."""
+    path: str
+    content: str
+    relevance_score: float
+    source: dict  # commit_hash, author, indexed_at, etc.
+    importance: Optional[float] = None
+    def to_dict(self) -> dict:
+        """Convert to JSON-serializable dict."""
+        return {
+            "path": self.path,
+            "content": self.content,
+            "relevance_score": self.relevance_score,
+            "source": self.source,
+            "importance": self.importance,
+        }
+class RetrievalStrategy(ABC):
+    """Abstract base for recall strategies."""
+    @abstractmethod
+    def recall(
+        self,
+        context: str,
+        limit: int,
+        exclude: List[str],
+        **kwargs: Any,
+    ) -> List[RecallResult]:
+        """
+        Retrieve and rank memories for the given context.
+        Args:
+            context: Current task description
+            limit: Max results to return
+            exclude: Tag/branch patterns to exclude (e.g., "experiment/*")
+            **kwargs: Strategy-specific options
+        Returns:
+            Ranked list of RecallResult
+        """
+        pass

memvcs/retrieval/pack.py ADDED Viewed

@@ -0,0 +1,128 @@
+"""
+Pack engine - context window budget manager for agmem.
+Fills token budget with most relevant memories, optionally with summarization cascade.
+"""
+from typing import List, Optional, Any
+from dataclasses import dataclass
+from .base import RecallResult
+from .recaller import RecallEngine
+@dataclass
+class PackResult:
+    """Result of packing memories into budget."""
+    content: str
+    total_tokens: int
+    budget: int
+    items_used: int
+    items_total: int
+class PackEngine:
+    """Packs recalled memories into a token budget."""
+    def __init__(
+        self,
+        recall_engine: RecallEngine,
+        model: str = "gpt-4o-mini",
+        summarization_cascade: bool = False,
+    ):
+        self.recall_engine = recall_engine
+        self.model = model
+        self.summarization_cascade = summarization_cascade
+    def _count_tokens(self, text: str) -> int:
+        """Count tokens using tiktoken."""
+        try:
+            import tiktoken
+            enc = tiktoken.encoding_for_model(self.model)
+            return len(enc.encode(text))
+        except ImportError:
+            # Fallback: ~4 chars per token
+            return len(text) // 4
+        except Exception:
+            return len(text) // 4
+    def pack(
+        self,
+        context: str,
+        budget: int = 4000,
+        strategy: str = "relevance",
+        exclude: Optional[List[str]] = None,
+    ) -> PackResult:
+        """
+        Pack memories into token budget.
+        Args:
+            context: Current task description for recall
+            budget: Max tokens to use
+            strategy: recall strategy (relevance=hybrid, recency, importance)
+            exclude: Path patterns to exclude
+        Returns:
+            PackResult with packed content and metadata
+        """
+        exclude = exclude or []
+        recall_strategy = "hybrid" if strategy == "relevance" else strategy
+        if recall_strategy not in ("hybrid", "recency", "importance", "similarity"):
+            recall_strategy = "hybrid"
+        results = self.recall_engine.recall(
+            context=context,
+            limit=50,  # Get more candidates
+            strategy=recall_strategy,
+            exclude=exclude,
+        )
+        # Sort by relevance (already sorted by recall)
+        # Add tokens, fill greedily
+        total_tokens = 0
+        packed_items: List[RecallResult] = []
+        separator = "\n\n---\n\n"
+        header = f"# Context for: {context}\n\n" if context else ""
+        header_tokens = self._count_tokens(header)
+        budget -= header_tokens
+        for r in results:
+            item_text = f"## {r.path}\n{r.content}"
+            item_tokens = self._count_tokens(item_text)
+            if total_tokens + item_tokens <= budget:
+                packed_items.append(r)
+                total_tokens += item_tokens
+            else:
+                # Try truncated
+                if total_tokens < budget and item_tokens > 0:
+                    ratio = (budget - total_tokens) / item_tokens
+                    if ratio > 0.2:  # At least 20% of item
+                        trunc_len = int(len(item_text) * ratio)
+                        truncated = item_text[:trunc_len] + "\n..."
+                        pack_tokens = self._count_tokens(truncated)
+                        if total_tokens + pack_tokens <= budget:
+                            r_trunc = RecallResult(
+                                path=r.path,
+                                content=r.content[: int(len(r.content) * ratio)] + "...",
+                                relevance_score=r.relevance_score,
+                                source=r.source,
+                                importance=r.importance,
+                            )
+                            packed_items.append(r_trunc)
+                            total_tokens += pack_tokens
+                break
+        content_parts = [r.content for r in packed_items]
+        body = separator.join(content_parts)
+        full_content = header + body
+        total_tokens = header_tokens + self._count_tokens(body)
+        return PackResult(
+            content=full_content,
+            total_tokens=total_tokens,
+            budget=budget + header_tokens,
+            items_used=len(packed_items),
+            items_total=len(results),
+        )

memvcs/retrieval/recaller.py ADDED Viewed

@@ -0,0 +1,105 @@
+"""
+Recall engine - orchestrates strategies and access tracking.
+"""
+from typing import List, Optional, Any
+from .base import RetrievalStrategy, RecallResult
+from .strategies import RecencyStrategy, ImportanceStrategy, SimilarityStrategy, HybridStrategy
+class RecallEngine:
+    """Orchestrates recall with pluggable strategies and access tracking."""
+    STRATEGIES = ["recency", "importance", "similarity", "hybrid"]
+    def __init__(
+        self,
+        repo: Any,
+        vector_store: Optional[Any] = None,
+        access_index: Optional[Any] = None,
+        use_cache: bool = True,
+    ):
+        self.repo = repo
+        self.vector_store = vector_store
+        self.access_index = access_index
+        self.use_cache = use_cache
+    def _get_strategy(self, strategy_name: str) -> RetrievalStrategy:
+        """Get strategy instance by name."""
+        name = strategy_name.lower()
+        if name == "recency":
+            return RecencyStrategy(self.repo)
+        if name == "importance":
+            return ImportanceStrategy(self.repo)
+        if name == "similarity":
+            if not self.vector_store:
+                raise ImportError(
+                    "Similarity strategy requires agmem[vector]. Install with: pip install agmem[vector]"
+                )
+            return SimilarityStrategy(self.repo, self.vector_store)
+        if name == "hybrid":
+            return HybridStrategy(self.repo, self.vector_store)
+        raise ValueError(f"Unknown strategy: {strategy_name}. Choose from {self.STRATEGIES}")
+    def recall(
+        self,
+        context: str,
+        limit: int = 10,
+        strategy: str = "hybrid",
+        exclude: Optional[List[str]] = None,
+    ) -> List[RecallResult]:
+        """
+        Recall memories for the given context.
+        Args:
+            context: Current task description
+            limit: Max results
+            strategy: recency, importance, similarity, or hybrid
+            exclude: Tag/path patterns to exclude
+        Returns:
+            Ranked list of RecallResult
+        """
+        exclude_list = [e.strip() for e in (exclude or []) if e.strip()]
+        cached = self._get_cached_results(context, strategy, limit, exclude_list)
+        if cached is not None:
+            return cached
+        effective_strategy = (
+            "recency" if (strategy == "hybrid" and not self.vector_store) else strategy
+        )
+        strat = self._get_strategy(effective_strategy)
+        results = strat.recall(context=context, limit=limit, exclude=exclude_list)
+        self._record_access_and_cache(context, effective_strategy, limit, exclude_list, results)
+        return results
+    def _get_cached_results(
+        self, context: str, strategy: str, limit: int, exclude: List[str]
+    ) -> Optional[List[RecallResult]]:
+        if not (self.use_cache and self.access_index and context):
+            return None
+        cached = self.access_index.get_cached_recall(context, strategy, limit, exclude)
+        if not cached or not cached.get("results"):
+            return None
+        return [RecallResult(**r) if isinstance(r, dict) else r for r in cached["results"]]
+    def _record_access_and_cache(
+        self,
+        context: str,
+        strategy: str,
+        limit: int,
+        exclude: List[str],
+        results: List[RecallResult],
+    ) -> None:
+        if self.access_index:
+            head = self.repo.get_head_commit()
+            commit_hash = head.store(self.repo.object_store) if head else ""
+            for r in results:
+                self.access_index.record_access(r.path, commit_hash)
+        if self.use_cache and self.access_index and context and results:
+            self.access_index.set_cached_recall(
+                context, strategy, limit, exclude, [r.to_dict() for r in results]
+            )

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

agmem 0.1.1py3-none-any.whl → 0.1.2py3-none-any.whl