memem 2.9.5__py3-none-any.whl

memem/__init__.py

@@ -0,0 +1,3 @@
+"""memem — persistent, self-evolving memory for Claude Code."""
+
+__version__ = "2.9.5"

memem/assembly.py

@@ -0,0 +1,104 @@
+"""Explicit assembly projection.
+
+context_assemble is the secondary path for building a structured context
+briefing. After m4, it calls the active slice engine 1-2 times, merges the
+resulting slices into a composite "assembled" MemorySlice, and renders it
+via render_slice_markdown.
+"""
+
+import logging
+from typing import Any
+
+from memem.models import _normalize_scope_id, now_iso
+
+log = logging.getLogger("memem-assembly")
+
+# Threshold: if the primary slice has fewer items than this, augment with general scope.
+_SPARSE_THRESHOLD = 5
+
+
+def _merge_slices(sub_slices: "list[dict]", query: str, project: str) -> "dict":
+    """Fold N item lists into one composite slice dict."""
+    from memem.recall import _layer_summary_from_items, _stable_id
+
+    seen_ids: set[str] = set()
+    merged_items: list[dict] = []
+
+    for sub in sub_slices:
+        for item in sub.get("items", []):
+            item_id = item.get("id", "")
+            if item_id and item_id in seen_ids:
+                continue
+            if item_id:
+                seen_ids.add(item_id)
+            merged_items.append(item)
+
+    layer_summary = _layer_summary_from_items(merged_items)
+
+    n_subs = len(sub_slices)
+    strategy = "primary-only" if n_subs == 1 else "primary+general-augmentation"
+
+    return {
+        "slice_id": _stable_id("assembled", {"query": query, "project": project, "generated_at": now_iso()}),
+        "scope_id": project,
+        "query": query,
+        "generated_at": now_iso(),
+        "slice_kind": "assembled",
+        "items": merged_items,
+        "layer_summary": layer_summary,
+        "sub_slices": sub_slices,
+        "composition_strategy": strategy,
+    }
+
+
+def context_assemble(query: str, project: str = "default") -> str:
+    """Assemble a composite briefing using the v2.0.0 recall pipeline.
+
+    Calls memory_search for the active project scope, and optionally augments
+    with general scope results when the primary result is sparse. Renders via
+    the inline recall markdown renderer.
+    """
+    from memem.recall import (
+        _memory_to_item,
+        _render_recall_markdown,
+        _search_memories,
+        _stable_id,
+    )
+
+    normalized = _normalize_scope_id(project)
+
+    # Primary slice: search active project scope
+    primary_mems = _search_memories(
+        query, scope_id=normalized, limit=10, record_access=False, expand_links=False
+    )
+    primary_items = [_memory_to_item(m, include_snippet=True) for m in primary_mems]
+    primary_as_sub: dict = {
+        "scope_id": normalized,
+        "slice_id": _stable_id("assembled-primary", {"query": query, "project": normalized}),
+        "items": primary_items,
+    }
+
+    sub_slices = [primary_as_sub]
+
+    # Cross-project augmentation when primary is sparse
+    if len(primary_items) < _SPARSE_THRESHOLD and normalized != "general":
+        general_mems = _search_memories(
+            query, scope_id="general", limit=10, record_access=False, expand_links=False
+        )
+        general_items = [_memory_to_item(m, include_snippet=True) for m in general_mems]
+        if general_items:
+            sub_slices.append({
+                "scope_id": "general",
+                "slice_id": _stable_id("assembled-general", {"query": query}),
+                "items": general_items,
+            })
+
+    composite = _merge_slices(sub_slices, query=query, project=normalized)
+
+    # Early return if nothing was assembled
+    if not composite.get("items"):
+        return ""
+
+    composite["slice_kind"] = "search"
+    composite["query"] = query
+    return _render_recall_markdown(composite)

memem/capabilities.py

@@ -0,0 +1,153 @@
+"""Runtime capability detection + serialization.
+
+memem writes a small JSON file at ``~/.memem/.capabilities`` during the
+bootstrap shim (bootstrap.sh) and on every ``--doctor`` invocation.
+
+The capabilities file is written by ``write_capabilities()`` (called by
+--doctor/bootstrap) and is used by ``pretty_report()`` for diagnostic output.
+The package itself does NOT read this file at runtime — capability checks are
+done live (e.g. shutil.which) at the point of use.
+
+Schema (v1)::
+
+    {
+      "schema_version": 1,
+      "updated_at": "2026-04-14T12:34:56+00:00",
+      "python_version": "3.11.6",
+      "mcp": true,
+      "claude_cli": true,
+      "writable_state_dir": true,
+      "writable_vault": true,
+      "uv": true,
+      "notes": []
+    }
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from memem.models import MEMEM_DIR, OBSIDIAN_MEMORIES_DIR, now_iso
+
+log = logging.getLogger("memem-capabilities")
+
+CAPABILITIES_FILE = MEMEM_DIR / ".capabilities"
+SCHEMA_VERSION = 1
+
+
+def _can_write(path: Path) -> bool:
+    """Probe whether we can actually create and remove a file under ``path``."""
+    try:
+        path.mkdir(parents=True, exist_ok=True)
+        canary = path / ".memem-write-check"
+        canary.write_text("ok")
+        canary.unlink(missing_ok=True)
+        return True
+    except OSError:
+        return False
+
+
+def _mcp_importable() -> bool:
+    try:
+        import importlib.util
+        return importlib.util.find_spec("mcp") is not None
+    except Exception:
+        return False
+
+
+def _claude_cli_available() -> bool:
+    if shutil.which("claude") is None:
+        return False
+    # Extra sanity: make sure it actually runs (some installs are stale symlinks).
+    try:
+        result = subprocess.run(
+            ["claude", "--version"],
+            capture_output=True, text=True, timeout=3,
+        )
+        return result.returncode == 0
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def _uv_available() -> bool:
+    return shutil.which("uv") is not None
+
+
+def detect_capabilities() -> dict[str, Any]:
+    """Run every probe and return the capabilities dict. Does not write to disk."""
+    caps: dict[str, Any] = {
+        "schema_version": SCHEMA_VERSION,
+        "updated_at": now_iso(),
+        "python_version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+        "mcp": _mcp_importable(),
+        "claude_cli": _claude_cli_available(),
+        "writable_state_dir": _can_write(MEMEM_DIR),
+        "writable_vault": _can_write(OBSIDIAN_MEMORIES_DIR),
+        "uv": _uv_available(),
+        "notes": [],
+    }
+    return caps
+
+
+def write_capabilities(caps: dict[str, Any] | None = None) -> dict[str, Any]:
+    """Detect (if not supplied) and atomically persist to ``~/.memem/.capabilities``."""
+    if caps is None:
+        caps = detect_capabilities()
+    MEMEM_DIR.mkdir(parents=True, exist_ok=True)
+    tmp = CAPABILITIES_FILE.with_suffix(".tmp")
+    with open(tmp, "w") as fh:
+        fh.write(json.dumps(caps, indent=2, sort_keys=True))
+        fh.flush()
+        os.fsync(fh.fileno())
+    os.replace(tmp, CAPABILITIES_FILE)
+    return caps
+
+
+def pretty_report(caps: dict[str, Any] | None = None) -> str:
+    """Human-readable multi-line report. Used by ``--doctor``."""
+    if caps is None:
+        caps = detect_capabilities()
+    lines = [
+        "memem Doctor",
+        "=" * 40,
+        f"  Python version     : {caps.get('python_version', '?')}",
+        f"  mcp importable     : {'yes' if caps.get('mcp') else 'NO — pip install mcp'}",
+        f"  claude CLI on PATH : {'yes' if caps.get('claude_cli') else 'NO — Haiku assembly disabled (degraded)'}",
+        f"  uv available       : {'yes' if caps.get('uv') else 'no (bootstrap.sh will install)'}",
+        f"  state dir writable : {'yes' if caps.get('writable_state_dir') else 'NO — set MEMEM_DIR env var'}",
+        f"  vault writable     : {'yes' if caps.get('writable_vault') else 'NO — set MEMEM_OBSIDIAN_VAULT env var'}",
+        f"  updated_at         : {caps.get('updated_at', '?')}",
+        "=" * 40,
+    ]
+    if caps.get("notes"):
+        lines.append("Notes:")
+        for note in caps["notes"]:
+            lines.append(f"  - {note}")
+        lines.append("=" * 40)
+
+    blockers = []
+    if not caps.get("mcp"):
+        blockers.append("mcp package missing — MCP server cannot start")
+    if not caps.get("writable_state_dir"):
+        blockers.append("~/.memem is not writable")
+    if not caps.get("writable_vault"):
+        blockers.append("obsidian vault directory is not writable")
+
+    if blockers:
+        lines.append("BLOCKERS:")
+        for b in blockers:
+            lines.append(f"  ✗ {b}")
+        lines.append("=" * 40)
+        lines.append("RESULT: FAILING — fix blockers above before first use.")
+    else:
+        degraded = not caps.get("claude_cli", False)
+        status = "DEGRADED (FTS-only recall, no Haiku assembly)" if degraded else "HEALTHY"
+        lines.append(f"RESULT: {status}")
+    return "\n".join(lines)