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

memvcs/retrieval/strategies.py

@@ -0,0 +1,314 @@
+"""
+Recall strategies: recency, importance, similarity, hybrid.
+"""
+
+import fnmatch
+from datetime import datetime
+from pathlib import Path
+from typing import List, Any, Optional
+
+from .base import RetrievalStrategy, RecallResult
+from ..core.constants import MEMORY_TYPES
+
+
+def _matches_exclude(path: str, exclude: List[str]) -> bool:
+    """Return True if path matches any exclude pattern."""
+    if not exclude:
+        return False
+    for pattern in exclude:
+        if fnmatch.fnmatch(path, pattern):
+            return True
+        if fnmatch.fnmatch(path, f"*/{pattern}"):
+            return True
+    return False
+
+
+class RecencyStrategy(RetrievalStrategy):
+    """Sort by commit timestamp / last_updated (newest first)."""
+
+    def __init__(self, repo: Any):
+        self.repo = repo
+
+    def recall(
+        self,
+        context: str,
+        limit: int,
+        exclude: List[str],
+        **kwargs: Any,
+    ) -> List[RecallResult]:
+        """Recall by recency - scan current/ and sort by mtime or frontmatter."""
+        results = []
+        current_dir = self.repo.current_dir
+        if not current_dir.exists():
+            return []
+
+        for subdir in MEMORY_TYPES:
+            dir_path = current_dir / subdir
+            if not dir_path.exists():
+                continue
+            for f in dir_path.rglob("*"):
+                if not f.is_file() or f.suffix.lower() not in (".md", ".txt"):
+                    continue
+                try:
+                    rel_path = str(f.relative_to(current_dir))
+                except ValueError:
+                    continue
+                if _matches_exclude(rel_path, exclude):
+                    continue
+                try:
+                    content = f.read_text(encoding="utf-8", errors="replace")
+                except Exception:
+                    continue
+
+                # Use mtime as recency proxy
+                mtime = f.stat().st_mtime
+                ts = datetime.fromtimestamp(mtime).isoformat() + "Z"
+
+                results.append(
+                    RecallResult(
+                        path=rel_path,
+                        content=content[:2000] + ("..." if len(content) > 2000 else ""),
+                        relevance_score=1.0 / (1.0 + mtime),  # newer = higher
+                        source={"indexed_at": ts, "commit_hash": None, "author": None},
+                        importance=None,
+                    )
+                )
+
+        # Sort by mtime descending (newest first)
+        results.sort(key=lambda r: r.source.get("indexed_at", ""), reverse=True)
+        return results[:limit]
+
+
+class ImportanceStrategy(RetrievalStrategy):
+    """Sort by importance from commit metadata."""
+
+    def __init__(self, repo: Any):
+        self.repo = repo
+
+    def recall(
+        self,
+        context: str,
+        limit: int,
+        exclude: List[str],
+        **kwargs: Any,
+    ) -> List[RecallResult]:
+        """Recall by importance - use commit metadata and frontmatter."""
+        from ..core.objects import Commit, Blob, Tree
+        from ..core.schema import FrontmatterParser
+
+        results = []
+        head = self.repo.get_head_commit()
+        if not head:
+            return []
+
+        tree = self.repo.get_commit_tree(head.store(self.repo.object_store))
+        if not tree:
+            return []
+
+        commit_importance = head.metadata.get("importance", 0.5)
+
+        def collect_files(entries: list, prefix: str = "") -> None:
+            for entry in entries:
+                # Support both hierarchical trees and flat trees (entry.path = parent dir)
+                path = (
+                    f"{prefix}/{entry.path}/{entry.name}".replace("//", "/").lstrip("/")
+                    if prefix or entry.path
+                    else entry.name
+                )
+                if entry.obj_type == "tree":
+                    subtree = Tree.load(self.repo.object_store, entry.hash)
+                    if subtree:
+                        collect_files(subtree.entries, path)
+                else:
+                    if _matches_exclude(path, exclude):
+                        continue
+                    blob = Blob.load(self.repo.object_store, entry.hash)
+                    if not blob:
+                        continue
+                    try:
+                        content = blob.content.decode("utf-8", errors="replace")
+                    except Exception:
+                        continue
+                    fm, body = FrontmatterParser.parse(content)
+                    importance = None
+                    if fm and fm.importance is not None:
+                        importance = fm.importance
+                    elif fm and fm.confidence_score is not None:
+                        importance = fm.confidence_score
+                    else:
+                        importance = commit_importance
+
+                    results.append(
+                        RecallResult(
+                            path=path,
+                            content=content[:2000] + ("..." if len(content) > 2000 else ""),
+                            relevance_score=float(importance) if importance else 0.5,
+                            source={
+                                "commit_hash": head.store(self.repo.object_store),
+                                "author": head.author,
+                                "indexed_at": head.timestamp,
+                            },
+                            importance=float(importance) if importance else None,
+                        )
+                    )
+
+        collect_files(tree.entries)
+        results.sort(key=lambda r: r.relevance_score, reverse=True)
+        return results[:limit]
+
+
+class SimilarityStrategy(RetrievalStrategy):
+    """Use vector store for embedding similarity."""
+
+    def __init__(self, repo: Any, vector_store: Any):
+        self.repo = repo
+        self.vector_store = vector_store
+
+    def recall(
+        self,
+        context: str,
+        limit: int,
+        exclude: List[str],
+        **kwargs: Any,
+    ) -> List[RecallResult]:
+        """Recall by semantic similarity to context."""
+        raw = self.vector_store.search_with_provenance(context, limit=limit * 2)
+        results = []
+        for item in raw:
+            path = item.get("path", "")
+            if _matches_exclude(path, exclude):
+                continue
+            results.append(
+                RecallResult(
+                    path=path,
+                    content=item.get("content", ""),
+                    relevance_score=item.get("similarity", 1.0 - item.get("distance", 0)),
+                    source={
+                        "commit_hash": item.get("commit_hash"),
+                        "author": item.get("author"),
+                        "indexed_at": item.get("indexed_at"),
+                        "blob_hash": item.get("blob_hash"),
+                    },
+                    importance=None,
+                )
+            )
+            if len(results) >= limit:
+                break
+        return results
+
+
+class HybridStrategy(RetrievalStrategy):
+    """Weighted combo of similarity, recency, importance."""
+
+    def __init__(
+        self,
+        repo: Any,
+        vector_store: Optional[Any] = None,
+        weights: Optional[dict] = None,
+    ):
+        self.repo = repo
+        self.vector_store = vector_store
+        self.weights = weights or {
+            "similarity": 0.4,
+            "recency": 0.3,
+            "importance": 0.3,
+        }
+
+    def recall(
+        self,
+        context: str,
+        limit: int,
+        exclude: List[str],
+        **kwargs: Any,
+    ) -> List[RecallResult]:
+        """Combine strategies with configurable weights."""
+        from ..core.schema import FrontmatterParser
+
+        # Collect candidates from all sources
+        path_to_result: dict = {}
+
+        # Similarity (if vector store available)
+        if self.vector_store:
+            sim = SimilarityStrategy(self.repo, self.vector_store)
+            for r in sim.recall(context, limit * 2, exclude):
+                path_to_result[r.path] = {
+                    "result": r,
+                    "sim_score": r.relevance_score,
+                    "rec_score": 0.5,
+                    "imp_score": r.importance or 0.5,
+                }
+
+        # Recency and importance from current/
+        current_dir = self.repo.current_dir
+        if current_dir.exists():
+            import time
+
+            head = self.repo.get_head_commit()
+            commit_imp = head.metadata.get("importance", 0.5) if head else 0.5
+
+            for subdir in MEMORY_TYPES:
+                dir_path = current_dir / subdir
+                if not dir_path.exists():
+                    continue
+                for f in dir_path.rglob("*"):
+                    if not f.is_file() or f.suffix.lower() not in (".md", ".txt"):
+                        continue
+                    try:
+                        rel_path = str(f.relative_to(current_dir))
+                    except ValueError:
+                        continue
+                    if _matches_exclude(rel_path, exclude):
+                        continue
+                    try:
+                        content = f.read_text(encoding="utf-8", errors="replace")
+                    except Exception:
+                        continue
+
+                    mtime = f.stat().st_mtime
+                    rec_score = 1.0 - (time.time() - mtime) / (86400 * 30)  # normalize to ~30 days
+                    rec_score = max(0, min(1, rec_score))
+
+                    fm, _ = FrontmatterParser.parse(content)
+                    imp_score = 0.5
+                    if fm and fm.importance is not None:
+                        imp_score = fm.importance
+                    elif fm and fm.confidence_score is not None:
+                        imp_score = fm.confidence_score
+                    else:
+                        imp_score = commit_imp
+
+                    if rel_path in path_to_result:
+                        path_to_result[rel_path]["rec_score"] = rec_score
+                        path_to_result[rel_path]["imp_score"] = imp_score
+                    else:
+                        path_to_result[rel_path] = {
+                            "result": RecallResult(
+                                path=rel_path,
+                                content=content[:2000] + ("..." if len(content) > 2000 else ""),
+                                relevance_score=0,
+                                source={
+                                    "indexed_at": datetime.fromtimestamp(mtime).isoformat() + "Z"
+                                },
+                                importance=imp_score,
+                            ),
+                            "sim_score": 0.5,
+                            "rec_score": rec_score,
+                            "imp_score": imp_score,
+                        }
+
+        # Compute hybrid score
+        w = self.weights
+        scored = []
+        for path, data in path_to_result.items():
+            score = (
+                w.get("similarity", 0.33) * data["sim_score"]
+                + w.get("recency", 0.33) * data["rec_score"]
+                + w.get("importance", 0.33) * data["imp_score"]
+            )
+            r = data["result"]
+            r.relevance_score = score
+            r.importance = data.get("imp_score")
+            scored.append(r)
+
+        scored.sort(key=lambda x: x.relevance_score, reverse=True)
+        return scored[:limit]

memvcs/utils/__init__.py

@@ -3,7 +3,7 @@
 from .helpers import find_repo_root, format_timestamp, shorten_hash
 
 __all__ = [
-    'find_repo_root',
-    'format_timestamp',
-    'shorten_hash',
+    "find_repo_root",
+    "format_timestamp",
+    "shorten_hash",
 ]

memvcs/utils/helpers.py

@@ -9,42 +9,42 @@ from typing import Optional
 def find_repo_root(start_path: Optional[Path] = None) -> Optional[Path]:
     """
     Find the repository root by looking for .mem directory.
-    
+
     Args:
         start_path: Path to start searching from (default: current directory)
-        
+
     Returns:
         Path to repository root or None if not found
     """
     if start_path is None:
-        start_path = Path('.').resolve()
-    
+        start_path = Path(".").resolve()
+
     current = start_path
-    
+
     while current != current.parent:
-        if (current / '.mem').exists():
+        if (current / ".mem").exists():
             return current
         current = current.parent
-    
+
     return None
 
 
-def format_timestamp(timestamp_str: str, format_str: str = '%Y-%m-%d %H:%M:%S') -> str:
+def format_timestamp(timestamp_str: str, format_str: str = "%Y-%m-%d %H:%M:%S") -> str:
     """
     Format an ISO timestamp string.
-    
+
     Args:
         timestamp_str: ISO format timestamp
         format_str: Output format string
-        
+
     Returns:
         Formatted timestamp string
     """
     try:
         # Handle 'Z' suffix
-        if timestamp_str.endswith('Z'):
+        if timestamp_str.endswith("Z"):
             timestamp_str = timestamp_str[:-1]
-        
+
         dt = datetime.fromisoformat(timestamp_str)
         return dt.strftime(format_str)
     except (ValueError, TypeError):
@@ -54,11 +54,11 @@ def format_timestamp(timestamp_str: str, format_str: str = '%Y-%m-%d %H:%M:%S')
 def shorten_hash(hash_id: str, length: int = 8) -> str:
     """
     Shorten a hash for display.
-    
+
     Args:
         hash_id: Full hash string
         length: Length of shortened hash
-        
+
     Returns:
         Shortened hash
     """
@@ -70,18 +70,18 @@ def shorten_hash(hash_id: str, length: int = 8) -> str:
 def human_readable_size(size_bytes: int) -> str:
     """
     Convert bytes to human readable format.
-    
+
     Args:
         size_bytes: Size in bytes
-        
+
     Returns:
         Human readable string (e.g., "1.5 MB")
     """
     if size_bytes < 1024:
         return f"{size_bytes} B"
-    elif size_bytes < 1024 ** 2:
+    elif size_bytes < 1024**2:
         return f"{size_bytes / 1024:.1f} KB"
-    elif size_bytes < 1024 ** 3:
+    elif size_bytes < 1024**3:
         return f"{size_bytes / (1024 ** 2):.1f} MB"
     else:
         return f"{size_bytes / (1024 ** 3):.1f} GB"
@@ -90,89 +90,89 @@ def human_readable_size(size_bytes: int) -> str:
 def parse_memory_type(filepath: str) -> str:
     """
     Parse memory type from file path.
-    
+
     Args:
         filepath: Path to memory file
-        
+
     Returns:
         Memory type ('episodic', 'semantic', 'procedural', 'unknown')
     """
     path_lower = filepath.lower()
-    
-    if 'episodic' in path_lower:
-        return 'episodic'
-    elif 'semantic' in path_lower:
-        return 'semantic'
-    elif 'procedural' in path_lower or 'workflow' in path_lower:
-        return 'procedural'
-    elif 'checkpoint' in path_lower:
-        return 'checkpoint'
-    elif 'summary' in path_lower:
-        return 'summary'
-    
-    return 'unknown'
+
+    if "episodic" in path_lower:
+        return "episodic"
+    elif "semantic" in path_lower:
+        return "semantic"
+    elif "procedural" in path_lower or "workflow" in path_lower:
+        return "procedural"
+    elif "checkpoint" in path_lower:
+        return "checkpoint"
+    elif "summary" in path_lower:
+        return "summary"
+
+    return "unknown"
 
 
 def is_binary_content(content: bytes) -> bool:
     """
     Check if content appears to be binary.
-    
+
     Args:
         content: Content bytes to check
-        
+
     Returns:
         True if content appears binary
     """
     # Check for null bytes
-    if b'\x00' in content:
+    if b"\x00" in content:
         return True
-    
+
     # Check for high ratio of non-printable characters
     if len(content) == 0:
         return False
-    
-    text_chars = bytearray({7, 8, 9, 10, 12, 13, 27} | set(range(0x20, 0x100)) - {0x7f})
+
+    text_chars = bytearray({7, 8, 9, 10, 12, 13, 27} | set(range(0x20, 0x100)) - {0x7F})
     non_text = sum(1 for byte in content if byte not in text_chars)
-    
+
     return non_text / len(content) > 0.30
 
 
 def sanitize_filename(filename: str) -> str:
     """
     Sanitize a filename for safe use.
-    
+
     Args:
         filename: Original filename
-        
+
     Returns:
         Sanitized filename
     """
     # Remove or replace unsafe characters
     unsafe_chars = '<>:"/\\|?*'
     for char in unsafe_chars:
-        filename = filename.replace(char, '_')
-    
+        filename = filename.replace(char, "_")
+
     # Remove leading/trailing whitespace and dots
-    filename = filename.strip(' .')
-    
+    filename = filename.strip(" .")
+
     # Ensure not empty
     if not filename:
-        filename = 'unnamed'
-    
+        filename = "unnamed"
+
     return filename
 
 
 def generate_session_id() -> str:
     """
     Generate a unique session ID.
-    
+
     Returns:
         Session ID string
     """
     from datetime import datetime
     import uuid
-    
-    timestamp = datetime.utcnow().strftime('%Y%m%d-%H%M%S')
+
+    timestamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
     short_uuid = str(uuid.uuid4())[:8]
-    
+
     return f"session-{timestamp}-{short_uuid}"

agmem-0.1.1.dist-info/RECORD

@@ -1,67 +0,0 @@
-agmem-0.1.1.dist-info/licenses/LICENSE,sha256=X_S6RBErW-F0IDbM3FAEoDB-zxExFnl2m8640rTXphM,1067
-memvcs/__init__.py,sha256=Gs0A8GAivdcePvlse8yWE3t6-vutFO9tWl5dh8lun6I,193
-memvcs/cli.py,sha256=ImQKXb423bHZ2iPr3GndHVojx2KcTuX8rXHwJV1cku0,5364
-memvcs/commands/__init__.py,sha256=lPKiWp-ywEGk1JPK0DeiHSublDwwSD1pU_LyPT-2BhY,510
-memvcs/commands/add.py,sha256=n0J0N_5Mk4uNMtsEt2podLqSKeenaOBRNWMUb9gsq70,8874
-memvcs/commands/base.py,sha256=yWvIYuofRxbHXvChlSd_DL_hJMaQdbZwa2XBDWj5Bio,634
-memvcs/commands/blame.py,sha256=NbaaL3kt9K2zRvYWX6mh-NmXNt5ZOdacSzHDmGY0_Oo,5874
-memvcs/commands/branch.py,sha256=7ocWZVn-WJ1c9pR9Z493ytd_VE6CY6Lakgl5lIzoNeE,3418
-memvcs/commands/checkout.py,sha256=8-fVF9HC5b0dkyO1u0wkGLUwGXrRBc8eSIDD9XBcnjI,3310
-memvcs/commands/clean.py,sha256=SXQqnd31KwmuIFUc2tBVm8ZjZ_3bP2mhbOR9cPBdbIs,2090
-memvcs/commands/clone.py,sha256=YYYURUiW850CHDgctlM4_ysQlPeh35BrS-UG2LSwWZ0,2872
-memvcs/commands/commit.py,sha256=SmeU0MDIMSYQe9PHNZzOLEK1duvflqWdRMrQXkQ6zGM,6380
-memvcs/commands/daemon.py,sha256=nTaWx19MN1IR4u293yna8fuwhHRiYstykSq_3zoUFPc,8385
-memvcs/commands/diff.py,sha256=TxfeqQS84rG2wHRff_WxdwjsNBKRnMkkX4B-7rsVG9Q,5410
-memvcs/commands/fsck.py,sha256=kvJYO0Kr073qZwGtvVqL1c7n7E34QuNzSc-HG3GpWZQ,6890
-memvcs/commands/garden.py,sha256=P8rvC6xYu6q_8VfXEUvtOa2Wez3jHLGGArGeAbn_o4Y,3496
-memvcs/commands/graph.py,sha256=caPyoo-myqmvtg_HEBUGBgQEnNFQXnCIkiNte4zQhqs,4993
-memvcs/commands/init.py,sha256=2TfBniqqJ6PsyHSIgBmkdtpF-kU9UCsc-V4Ct4BSumM,1767
-memvcs/commands/log.py,sha256=tY0Hrn2xkC1SWG_DT2VGbdK-W-oajrM_1r9NVLoEq5k,3141
-memvcs/commands/mcp.py,sha256=PMfwVD6uHltN58Jh7IOiS1w7oND42tg14QKRCJNudmY,1740
-memvcs/commands/merge.py,sha256=qUsJelBynpdv63tL9Oga3t29AnUQCMMJo_CNl3rNvaw,2631
-memvcs/commands/pull.py,sha256=Sk0zfCloyksYbMGCSM9z91pH1gZJ-KLKZasckQhrNd4,2082
-memvcs/commands/push.py,sha256=bCHuxrrBwRNhVDh9GVwhRICtaNLk_a_47EHix4Z66BQ,5081
-memvcs/commands/reflog.py,sha256=AtfJ2dzhsgJVvdQlHU5LUEiAW310QI8yWeUD7GmLoco,1256
-memvcs/commands/remote.py,sha256=sTXf-r6w4OsZgB68ffW9jUtP1xOL8p-kttxvApZNs08,1760
-memvcs/commands/reset.py,sha256=vvHgSb79zVJizWyH-XN6u5jHK2e_gqrNI0JoIUi22es,2991
-memvcs/commands/search.py,sha256=rg-cQfUDl6aNRFa64szpPbqzw508sL9a2u8YtHBhSRM,5324
-memvcs/commands/serve.py,sha256=mhfsULAtU5Gxe43RVo94RRYT1ui4Zmg5Ptatj5rNIUc,1396
-memvcs/commands/show.py,sha256=525-T_na_B3gX6lmFJ05Q4675XNyEd7FFrVl63X2X7Q,3932
-memvcs/commands/stash.py,sha256=aLeeOLUXcFHQYzsYsi9KIg5e_8VFANHMAEvzaqTOgsg,3293
-memvcs/commands/status.py,sha256=P02DFM2-gIf8-dkslzpnj6xNmpxhqmf8bOhHkxA3srw,3647
-memvcs/commands/tag.py,sha256=UCTggFnzHXVMBYjX8usz58duqg4xyOHnIUdVNyoAlWQ,3409
-memvcs/commands/test.py,sha256=xAIzN60U1xL1TieIXOQBsvTRRfZfElVqxEqqHUn72VU,4235
-memvcs/commands/tree.py,sha256=GzA7RYH3bYgSg9QmztYpis6EZWEt6fzwBltoQjaukf4,5059
-memvcs/core/__init__.py,sha256=dkIC-4tS0GhwV2mZIbofEe8xR8uiFwrxslGf1aXwhYg,493
-memvcs/core/config_loader.py,sha256=ebljEMDyVJjQdlpP8if10Whg0I3DfMUBiuAl7S5NVNE,8264
-memvcs/core/constants.py,sha256=WUjAb50BFcF0mbFi_GNteDLCxLihmViBm9Fb-JMPmbM,220
-memvcs/core/diff.py,sha256=wZynRRAF08HyQ_SCcseC0vlmnkoaqoQfQWne3w1o__M,13390
-memvcs/core/gardener.py,sha256=Fr_Zpo_3eZAtA_9zXVT_PpAHfhZkp2-ukLn69FV93rA,16335
-memvcs/core/hooks.py,sha256=3PWqebAt2c6nPw7ZX3epcb5FGLJLrwxh_UMrQeFTyr0,4679
-memvcs/core/knowledge_graph.py,sha256=Ntm4My73Ov3u9YKEgwvDonUVwewx-svCDJD4hGA0hPc,13572
-memvcs/core/merge.py,sha256=i_X-0ye14r62dvlxRWZVkRbIvxd_MtfQSYwuZQEYaCA,17041
-memvcs/core/objects.py,sha256=MvWhQ-L74Rl2lf0rnJE-N3qo78dWGoclJSQinTloNPg,10289
-memvcs/core/pii_scanner.py,sha256=MOycqGTuLJaCNGkaMyMH1ju8gPxQTyLAONoIML7gHKU,11141
-memvcs/core/refs.py,sha256=1-ELwSXWmqdivD_967zb3hw5V3gIiujyn4eRGf8e1u8,16831
-memvcs/core/remote.py,sha256=MhQTfxpzmH0mAMb7hoQJrTOAoqX0tqZxx1Yq5Q5niS8,10117
-memvcs/core/repository.py,sha256=fZ-UUh9EK9nmM8dk9y4TeipkhgGEp5JqDizR6QAEVe4,18119
-memvcs/core/schema.py,sha256=oiStwqD1crbQJf86yJTMI50efd2SaDG3RIPyUxmcxEk,14322
-memvcs/core/staging.py,sha256=EvACqotgi-LKgOdZr6-8Ud1Lkjnflam0KAzpq8eAAp0,7499
-memvcs/core/test_runner.py,sha256=QfEPMjBebM4L4COn9p0XqMcq1Grvij5rOXByUWAcEAg,11823
-memvcs/core/vector_store.py,sha256=Z_C1VZy3Ytv9dfEaqgE6zCb8nNabLaIsDcc1ATstDRI,10546
-memvcs/core/storage/__init__.py,sha256=b2MLjyFgE6L6JAFoyEldxsrR16FGO65qAtxgRj5XFcM,1959
-memvcs/core/storage/base.py,sha256=hHPXuJPR5X1bh7xYAqACHYRfzU4CmPx9trT5tgRghdI,10384
-memvcs/core/storage/gcs.py,sha256=mjcuQHiK6goQ3opRDE6Ky2fSEA9W-MNTOShlGXhY0cM,10953
-memvcs/core/storage/local.py,sha256=CHi3Ot0-u-pCJJOWKW3IP_UIkdz32QAkHcJl1DxatHY,6193
-memvcs/core/storage/s3.py,sha256=rPxZ7avw5KXMSrJrsA2YpM6gVv7Qhn9IQjfoApZIyxE,14230
-memvcs/integrations/__init__.py,sha256=hVtJoFaXt6ErAZwctcSBDZLXRHFs1CNgtltIBQiroQ0,103
-memvcs/integrations/mcp_server.py,sha256=-si5ymayhiRTIfNJwc4EEp4kudav28x8RjzIEDN-n2c,9091
-memvcs/integrations/web_ui/__init__.py,sha256=MQIfgDKDgPctlcTUjwkwueS_MDsDssVRmIUnpECGS0k,51
-memvcs/integrations/web_ui/server.py,sha256=yqokrs6T9l4vAWdRHKMSFLUIkodTJFWihw5Aq_dhGPg,12782
-memvcs/utils/__init__.py,sha256=h74jw3O37su7BFxp52IcZmVReLfd8yDcuk4VzBHbd_s,185
-memvcs/utils/helpers.py,sha256=4k7Jdm-8vCWDASW2kST2vZs-vA9HX8UvqoCwIGsq49g,4273
-agmem-0.1.1.dist-info/METADATA,sha256=8ovwtZcCCNfSeQA6IH5HfAY0MzQgeqxBo1BfRZIkLIU,25844
-agmem-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-agmem-0.1.1.dist-info/entry_points.txt,sha256=at7eWycgjqOo1wbUMECnXUsNo3gpCkJTU71OzrGLHu0,42
-agmem-0.1.1.dist-info/top_level.txt,sha256=HtMMsKuwLKLOdgF1GxqQztqFM54tTJctVdJuOec6B-4,7
-agmem-0.1.1.dist-info/RECORD,,