total-agent-memory 12.0.0__py3-none-any.whl

claude_total_memory/__init__.py

@@ -0,0 +1,24 @@
+"""Backward-compat shim: the package was renamed to ``total_agent_memory``.
+
+The legacy import path keeps working so existing user scripts and sub-agent
+prompts that do ``from claude_total_memory import ...`` do not break on
+upgrade. Every import emits a DeprecationWarning so callers know to switch.
+
+Migration:
+    from claude_total_memory import x        # old
+    from total_agent_memory import x         # new
+"""
+from __future__ import annotations
+
+import warnings as _warnings
+
+_warnings.warn(
+    "The 'claude_total_memory' module has been renamed to 'total_agent_memory'. "
+    "Update your imports: `from total_agent_memory import ...`. "
+    "The legacy alias will be removed in a future release.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from total_agent_memory import *  # noqa: E402, F401, F403
+from total_agent_memory import __version__  # noqa: E402, F401

claude_total_memory/lookup.py

@@ -0,0 +1,12 @@
+"""Backward-compat shim. Real entry-point: ``total_agent_memory.lookup``.
+
+Replaces this module in ``sys.modules`` with the real implementation so
+every attribute (including private helpers like ``_fts_query``) resolves
+transparently. This keeps third-party tests and sub-agent scripts that do
+``import claude_total_memory.lookup as lookup`` working.
+"""
+import sys as _sys
+
+from total_agent_memory import lookup as _impl
+
+_sys.modules[__name__] = _impl

claude_total_memory/server.py

@@ -0,0 +1,6 @@
+"""Backward-compat shim. Real entry-point: ``total_agent_memory.server``."""
+import sys as _sys
+
+from total_agent_memory import server as _impl
+
+_sys.modules[__name__] = _impl

src/active_context.py

@@ -0,0 +1,205 @@
+"""
+Active Context — live-doc projection of session_continuity.
+
+Maintains a human-readable markdown file (`activeContext.md`) per project
+inside the Obsidian vault. The file is a symlink-style projection of the
+latest session summary/next_steps/pitfalls — a dumb Read can pick it up
+without going through MCP.
+
+Round-trips with `read_active_context` so integration code can detect
+staleness between the DB row and the markdown file.
+
+Env:
+    MEMORY_ACTIVECONTEXT_VAULT    — vault root (default ~/Documents/project/Projects)
+    MEMORY_ACTIVECONTEXT_DISABLE  — "1"/"true"/"yes" disables markdown writes
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_VAULT = Path.home() / "Documents" / "project" / "Projects"
+
+_UPDATED_RE = re.compile(r"^\*\*Updated:\*\*\s*(.+?)\s*$")
+_SESSION_RE = re.compile(r"^\*\*Session:\*\*\s*(.+?)\s*$")
+_SECTION_RE = re.compile(r"^##\s+(.+?)\s*$")
+_BULLET_RE = re.compile(r"^-\s+(.*?)\s*$")
+
+
+def _now_iso() -> str:
+    """Return current UTC time as ISO-8601 with trailing Z."""
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _resolve_vault_root(vault_root: Path | None) -> Path:
+    """Pick vault root: explicit arg > env var > default."""
+    if vault_root is not None:
+        return Path(vault_root).expanduser()
+    raw = os.environ.get("MEMORY_ACTIVECONTEXT_VAULT")
+    if raw:
+        return Path(raw).expanduser()
+    return DEFAULT_VAULT
+
+
+def active_context_path(project: str, vault_root: Path | None = None) -> Path:
+    """Absolute path to the activeContext.md for the given project."""
+    if not project:
+        raise ValueError("project required")
+    root = _resolve_vault_root(vault_root)
+    return root / project / "activeContext.md"
+
+
+def _render_section(title: str, items: list[str]) -> str:
+    """Render a markdown section with bullet items (empty list → '- _(none)_')."""
+    clean = [s for s in (items or []) if s is not None and str(s).strip()]
+    if not clean:
+        return f"## {title}\n- _(none)_\n"
+    lines = [f"## {title}"]
+    for it in clean:
+        lines.append(f"- {it}")
+    return "\n".join(lines) + "\n"
+
+
+def write_active_context(
+    project: str,
+    summary: str,
+    next_steps: list[str],
+    pitfalls: list[str],
+    *,
+    vault_root: Path | None = None,
+    session_id: str | None = None,
+) -> Path:
+    """Write markdown live-doc. Overwrites existing file.
+
+    Creates parent directories. Returns the path written.
+    """
+    if not project:
+        raise ValueError("project required")
+    if summary is None:
+        summary = ""
+
+    path = active_context_path(project, vault_root=vault_root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    updated = _now_iso()
+    sess = session_id or "n/a"
+
+    # Normalize summary: keep multiline intact, strip trailing whitespace
+    summary_body = (summary or "").rstrip()
+    if not summary_body:
+        summary_body = "_(none)_"
+
+    parts = [
+        f"# {project} — Active Context\n",
+        f"\n**Updated:** {updated}\n",
+        f"**Session:** {sess}\n",
+        "\n## Summary\n",
+        f"{summary_body}\n",
+        "\n",
+        _render_section("Next Steps", next_steps or []),
+        "\n",
+        _render_section("Pitfalls", pitfalls or []),
+    ]
+    path.write_text("".join(parts), encoding="utf-8")
+    return path
+
+
+def _parse_bullets(lines: list[str]) -> list[str]:
+    """Extract bullet content. Filter the '(none)' placeholder."""
+    out: list[str] = []
+    for ln in lines:
+        m = _BULLET_RE.match(ln)
+        if not m:
+            continue
+        val = m.group(1).strip()
+        if not val:
+            continue
+        # Drop placeholder from empty section
+        if val in ("_(none)_", "*(none)*", "(none)"):
+            continue
+        out.append(val)
+    return out
+
+
+def read_active_context(
+    project: str,
+    vault_root: Path | None = None,
+) -> dict[str, Any] | None:
+    """Parse markdown back into a dict.
+
+    Returns ``None`` when the file does not exist. Returns a dict with at
+    least the keys ``summary`` / ``next_steps`` / ``pitfalls`` / ``updated_at``
+    even when the file is partly malformed (best-effort).
+    """
+    path = active_context_path(project, vault_root=vault_root)
+    if not path.exists():
+        return None
+
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+    if not text.strip():
+        return None
+
+    lines = text.splitlines()
+
+    updated_at: str | None = None
+    session_id: str | None = None
+    sections: dict[str, list[str]] = {}
+
+    current: str | None = None
+    buf: list[str] = []
+
+    def _flush() -> None:
+        if current is not None:
+            sections[current] = buf.copy()
+
+    for raw in lines:
+        m_upd = _UPDATED_RE.match(raw)
+        if m_upd and updated_at is None:
+            updated_at = m_upd.group(1).strip()
+            continue
+        m_sess = _SESSION_RE.match(raw)
+        if m_sess and session_id is None:
+            session_id = m_sess.group(1).strip()
+            continue
+        m_sec = _SECTION_RE.match(raw)
+        if m_sec:
+            _flush()
+            current = m_sec.group(1).strip().lower()
+            buf = []
+            continue
+        if current is not None:
+            buf.append(raw)
+    _flush()
+
+    # Summary is free text; trim surrounding blank lines
+    summary_lines = sections.get("summary", [])
+    while summary_lines and not summary_lines[0].strip():
+        summary_lines.pop(0)
+    while summary_lines and not summary_lines[-1].strip():
+        summary_lines.pop()
+    summary_text = "\n".join(summary_lines).strip()
+    if summary_text in ("_(none)_", "*(none)*"):
+        summary_text = ""
+
+    next_steps = _parse_bullets(sections.get("next steps", []))
+    pitfalls = _parse_bullets(sections.get("pitfalls", []))
+
+    if session_id in (None, "", "n/a"):
+        session_id = None
+
+    return {
+        "summary": summary_text,
+        "next_steps": next_steps,
+        "pitfalls": pitfalls,
+        "updated_at": updated_at,
+        "session_id": session_id,
+    }

src/ai_layer/__init__.py

@@ -0,0 +1,77 @@
+"""v11.0 AI Layer — every LLM/Ollama/CrossEncoder code path lives here.
+
+Hot-path code in `memory_core` MUST NOT import this package. The
+asymmetry is intentional:
+
+    memory_core   → deterministic, sync, zero LLM, zero network.
+    ai_layer      → may import llm_provider, ollama, anthropic,
+                    cross-encoder, FlagEmbedding, etc.
+
+The async enrichment worker (`ai_layer.enrichment_worker`) is the only
+path through which an LLM/Ollama call may be triggered as a side-effect
+of a `memory_save`. Direct callers of LLM helpers (representations,
+deep_enricher, contradiction_detector, reflection, self_improve) live
+here too so that grep/AST tools can answer "what touches the LLM?" with
+a single directory walk.
+
+The regression suite (`tests/test_v11_layer_separation.py`) enforces the
+import wall: any `from ai_layer.*` reference inside `src/memory_core/`
+will fail CI.
+
+Submodules
+----------
+
+    enrichment_worker          v10.1 inbox/outbox worker (drain, enqueue, run_pending)
+    enrichment_jobs            unified enqueue() shim across the three v10 queues
+    summarizer                 representations.summary
+    keyword_extractor          representations.keywords
+    question_generator         representations.utility_questions
+    relation_extractor         deep_enricher concept/triple extraction
+    contradiction_detector     auto-supersession of decisions/solutions
+    reflection                 ReflectionAgent + run_full
+    self_improve               error/fix logging + pattern checks
+
+The following four LLM-touching modules are also reachable through this
+package so the layer-separation test sees them:
+
+    quality_gate, coref_resolver, reranker, query_rewriter
+
+They are imported by `enrichment_worker` (quality_gate, coref_resolver)
+or by Recall (reranker, query_rewriter) but, by living under `ai_layer`,
+they are guaranteed to be invisible to anything that imports
+`memory_core`.
+"""
+
+from __future__ import annotations
+
+from . import (  # noqa: F401  (re-export entry points)
+    contradiction_detector,
+    coref_resolver,
+    enrichment_jobs,
+    enrichment_worker,
+    keyword_extractor,
+    quality_gate,
+    query_rewriter,
+    question_generator,
+    reflection,
+    relation_extractor,
+    reranker,
+    self_improve,
+    summarizer,
+)
+
+__all__ = [
+    "contradiction_detector",
+    "coref_resolver",
+    "enrichment_jobs",
+    "enrichment_worker",
+    "keyword_extractor",
+    "quality_gate",
+    "query_rewriter",
+    "question_generator",
+    "reflection",
+    "relation_extractor",
+    "reranker",
+    "self_improve",
+    "summarizer",
+]