claude-memory-agent 3.0.3 → 3.2.0

package/mcp_proxy.py

@@ -1,16 +1,18 @@
 """Slim MCP proxy for Claude Memory.
 
-Thin adapter that exposes 3 unified tools over stdio JSON-RPC,
+Thin adapter that exposes 4 unified tools over stdio JSON-RPC,
 forwarding all work to the HTTP backend (main.py on port 8102).
 
 NO embedding model loaded. NO database connection. Just HTTP calls.
 
 Tools:
-    memory_ask   - Unified search (replaces memory_search, memory_search_patterns,
-                   memory_context, memory_get_project, memory_active_sessions,
-                   memory_session_catchup)
-    memory_store - Unified store (replaces memory_store, memory_store_pattern,
-                   memory_store_project)
+    memory_ask    - Unified search (replaces memory_search, memory_search_patterns,
+                    memory_context, memory_get_project, memory_active_sessions,
+                    memory_session_catchup)
+    memory_store  - Unified store (replaces memory_store, memory_store_pattern,
+                    memory_store_project)
+    memory_resume - Complete catch-up package for session recovery after context
+                    clear (goal, decisions, entities, workflows, memories, soul)
     memory_status - Quick stats + project info (replaces memory_stats, memory_dashboard)
 
 Usage:
@@ -180,6 +182,12 @@ async def memory_ask(
         elif label == "sessions":
             results["active_sessions"] = result.get("sessions", [])
 
+    # -- Soul context enrichment (lightweight DB read) --
+    if project_path:
+        soul_data = await _rest_get("/api/soul/brief", {"project_path": project_path})
+        if soul_data and soul_data.get("brief"):
+            results["soul_context"] = {"brief": soul_data["brief"]}
+
     results["success"] = bool(results.get("memories") or results.get("patterns"))
     return json.dumps(results, default=str)
 
@@ -262,6 +270,85 @@ async def memory_store(
     return json.dumps(result or {"error": "Memory agent unavailable"}, default=str)
 
 
+@mcp_server.tool()
+async def memory_resume(
+    project_path: Optional[str] = None,
+    session_id: Optional[str] = None,
+) -> str:
+    """Resume after context clear — get complete catch-up package in one call.
+
+    Call this when starting a fresh session or after context was compacted.
+    Returns: goal, decisions, entity registry, learned workflows,
+    recent memories, and soul brief — everything needed to continue working.
+
+    Args:
+        project_path: Project path to resume context for
+        session_id: Optional specific session ID (uses latest for project if omitted)
+    """
+    result = await _rest_post("/api/session/resume", {
+        "session_id": session_id or "",
+        "project_path": project_path or "",
+    })
+
+    if not result:
+        return json.dumps({
+            "success": False,
+            "error": "Memory agent unavailable - is main.py running on port 8102?",
+        })
+
+    # Format for readability
+    output: Dict[str, Any] = {"success": True}
+
+    # Session state
+    state = result.get("session_state")
+    if state and isinstance(state, dict):
+        output["goal"] = state.get("current_goal", "")
+        output["decisions"] = state.get("decisions_summary", "")
+        output["entity_registry"] = state.get("entity_registry", {})
+        output["pending"] = state.get("pending_questions", [])
+
+    # Checkpoint
+    cp = result.get("checkpoint")
+    if cp and isinstance(cp, dict):
+        output["checkpoint"] = {
+            "summary": cp.get("summary", ""),
+            "key_facts": cp.get("key_facts", []),
+            "decisions": cp.get("decisions", []),
+        }
+
+    # Workflows
+    workflows = result.get("workflows")
+    if workflows and isinstance(workflows, list):
+        output["workflows"] = [
+            {
+                "name": wf.get("name", ""),
+                "commands": wf.get("commands", []),
+                "steps": wf.get("steps", []),
+                "success_count": wf.get("success_count", 0),
+            }
+            for wf in workflows[:10]
+        ]
+
+    # Recent memories (compact)
+    memories = result.get("memories")
+    if memories and isinstance(memories, list):
+        output["recent_memories"] = [
+            {
+                "content": m.get("content", "")[:200],
+                "type": m.get("type", ""),
+                "importance": m.get("importance", 5),
+            }
+            for m in memories[:10]
+        ]
+
+    # Soul brief
+    soul = result.get("soul_brief")
+    if soul:
+        output["soul_brief"] = soul
+
+    return json.dumps(output, default=str)
+
+
 @mcp_server.tool()
 async def memory_status(
     project_path: Optional[str] = None,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-memory-agent",
-  "version": "3.0.3",
-  "description": "Persistent semantic memory system for Claude Code sessions with anti-hallucination grounding",
+  "version": "3.2.0",
+  "description": "Persistent semantic memory for Claude Code with session recovery, self-reported learning, soul layer, and anti-hallucination grounding",
   "keywords": [
     "claude",
     "claude-code",

package/services/agent_registry.py

@@ -1,16 +1,24 @@
 """
-Agent Registry - Loads agent/MCP/hook catalogs from JSON data file.
+Agent Registry - Discovers real agents from disk + loads MCP/hook catalogs.
 
-Static display metadata lives in agent_catalog.json (~880 entries).
-Dynamic loading (hooks, MCPs) reads Claude Code settings files at runtime
-to determine which entries are truly configured.
+Agents are discovered from ~/.claude/agents/ (global) and
+<project>/.claude/agents/ (per-project) by scanning .md files with YAML
+frontmatter.  Enabled agents live in the root; disabled agents live in
+_disabled/<category>/ subdirectories.
+
+MCP and hook metadata still comes from agent_catalog.json; dynamic loading
+reads Claude Code settings files at runtime to check configured status.
 """
 
 import json
 import logging
+import re
+import shutil
 from pathlib import Path
 from typing import List, Dict, Any, Optional
 
+import yaml
+
 logger = logging.getLogger(__name__)
 
 # ---------------------------------------------------------------------------
@@ -24,8 +32,11 @@ _GLOBAL_SETTINGS_PATH = _HOME / ".claude" / "settings.json"
 _PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
 _LOCAL_SETTINGS_PATH = _PROJECT_ROOT / ".claude" / "settings.local.json"
 
+# Global agents directory
+_GLOBAL_AGENTS_DIR = _HOME / ".claude" / "agents"
+
 # ---------------------------------------------------------------------------
-# Load static catalog from JSON
+# Load static catalog from JSON (MCPs + hooks only now)
 # ---------------------------------------------------------------------------
 _CATALOG_PATH = Path(__file__).resolve().parent / "agent_catalog.json"
 
@@ -42,11 +53,249 @@ def _load_catalog() -> dict:
 
 _catalog = _load_catalog()
 
+# Categories are now auto-generated from discovered agents, but keep catalog
+# ones as fallback for MCPs/hooks
 AGENT_CATEGORIES = _catalog.get("categories", {})
-AVAILABLE_AGENTS = _catalog.get("agents", [])
 AVAILABLE_MCPS = _catalog.get("mcps", [])
 AVAILABLE_HOOKS = _catalog.get("hooks", [])
 
+# ---------------------------------------------------------------------------
+# Category metadata (colors + icons for known categories)
+# ---------------------------------------------------------------------------
+_CATEGORY_META = {
+    "design":              {"name": "Design",              "color": "#f778ba", "icon": "palette"},
+    "engineering":         {"name": "Engineering",         "color": "#58a6ff", "icon": "code"},
+    "marketing":           {"name": "Marketing",           "color": "#f0883e", "icon": "bullhorn"},
+    "product":             {"name": "Product",             "color": "#a371f7", "icon": "lightbulb"},
+    "project-management":  {"name": "Project Management",  "color": "#3fb950", "icon": "tasks"},
+    "spatial-computing":   {"name": "Spatial Computing",   "color": "#79c0ff", "icon": "cube"},
+    "specialized":         {"name": "Specialized",         "color": "#d2a8ff", "icon": "star"},
+    "support":             {"name": "Support",             "color": "#56d364", "icon": "headset"},
+    "testing":             {"name": "Testing",             "color": "#e3b341", "icon": "vial"},
+}
+
+# Color palette for agent frontmatter colors
+_COLOR_MAP = {
+    "blue":    "#58a6ff",
+    "green":   "#3fb950",
+    "red":     "#f85149",
+    "purple":  "#a371f7",
+    "orange":  "#f0883e",
+    "yellow":  "#e3b341",
+    "pink":    "#f778ba",
+    "cyan":    "#79c0ff",
+    "teal":    "#2ea043",
+}
+
+
+# ---------------------------------------------------------------------------
+# Agent discovery from disk
+# ---------------------------------------------------------------------------
+def _parse_frontmatter(file_path: Path) -> Optional[Dict[str, Any]]:
+    """Parse YAML frontmatter from an agent .md file."""
+    try:
+        text = file_path.read_text(encoding="utf-8")
+    except Exception as e:
+        logger.warning(f"Could not read {file_path}: {e}")
+        return None
+
+    # Match --- delimited frontmatter
+    match = re.match(r'^---\s*\n(.*?)\n---', text, re.DOTALL)
+    if not match:
+        return None
+
+    try:
+        data = yaml.safe_load(match.group(1))
+        if not isinstance(data, dict):
+            return None
+        return data
+    except yaml.YAMLError as e:
+        logger.warning(f"Invalid YAML frontmatter in {file_path}: {e}")
+        return None
+
+
+def _infer_category(filename_stem: str) -> str:
+    """Infer category from filename prefix like 'engineering-senior-developer'."""
+    known = [
+        "design", "engineering", "marketing", "product",
+        "project-management", "spatial-computing", "specialized",
+        "support", "testing",
+    ]
+    for cat in known:
+        if filename_stem.startswith(cat):
+            return cat
+    # Try first word as category
+    parts = filename_stem.split("-")
+    if parts:
+        return parts[0]
+    return "uncategorized"
+
+
+def _resolve_color(color_str: Optional[str]) -> str:
+    """Resolve a color name or hex value to a hex color."""
+    if not color_str:
+        return "#8b949e"
+    if color_str.startswith("#"):
+        return color_str
+    return _COLOR_MAP.get(color_str.lower(), "#8b949e")
+
+
+def _parse_agent_file(
+    file_path: Path,
+    enabled: bool,
+    scope: str,
+    category: Optional[str] = None,
+    base_dir: Optional[Path] = None,
+) -> Optional[Dict[str, Any]]:
+    """Parse a single agent .md file into an agent dict."""
+    fm = _parse_frontmatter(file_path)
+    if fm is None:
+        # Minimal entry for files without valid frontmatter
+        fm = {}
+
+    stem = file_path.stem
+    agent_id = stem
+
+    name = fm.get("name", stem.replace("-", " ").replace("_", " ").title())
+    description = fm.get("description", "").replace("\\n", " ").strip()
+    color = _resolve_color(fm.get("color"))
+
+    if not category:
+        category = _infer_category(stem)
+
+    return {
+        "id": agent_id,
+        "name": name,
+        "description": description,
+        "color": color,
+        "category": category,
+        "enabled": enabled,
+        "scope": scope,
+        "file_path": str(file_path),
+        "filename": file_path.name,
+        "base_dir": str(base_dir or file_path.parent),
+    }
+
+
+def _scan_agent_dir(base_dir: Path, scope: str) -> List[Dict[str, Any]]:
+    """Scan an agents directory for enabled and disabled agents."""
+    agents = []
+    if not base_dir.exists():
+        return agents
+
+    # Enabled agents: .md files directly in base_dir
+    for f in sorted(base_dir.glob("*.md")):
+        if f.name.lower() in ("readme.md", "readme.txt"):
+            continue
+        agent = _parse_agent_file(
+            f, enabled=True, scope=scope, base_dir=base_dir
+        )
+        if agent:
+            agents.append(agent)
+
+    # Disabled agents: .md files in _disabled/ subdirectories
+    disabled_dir = base_dir / "_disabled"
+    if disabled_dir.exists():
+        for f in sorted(disabled_dir.rglob("*.md")):
+            if f.name.lower() in ("readme.md", "readme.txt"):
+                continue
+            # Category = parent dir name if it's a subdirectory of _disabled
+            if f.parent != disabled_dir:
+                category = f.parent.name
+            else:
+                category = _infer_category(f.stem)
+            agent = _parse_agent_file(
+                f, enabled=False, scope=scope,
+                category=category, base_dir=base_dir,
+            )
+            if agent:
+                agents.append(agent)
+
+    return agents
+
+
+def discover_agents(project_path: Optional[str] = None) -> List[Dict[str, Any]]:
+    """Discover all agents from global and project directories.
+
+    Returns a list of agent dicts with id, name, description, color,
+    category, enabled, scope, file_path, filename, base_dir.
+    """
+    agents = []
+
+    # 1. Global agents: ~/.claude/agents/
+    agents += _scan_agent_dir(_GLOBAL_AGENTS_DIR, scope="global")
+
+    # 2. Project agents: <project>/.claude/agents/
+    if project_path:
+        project_dir = Path(project_path) / ".claude" / "agents"
+        agents += _scan_agent_dir(project_dir, scope="project")
+
+    return agents
+
+
+def discover_categories(agents: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    """Build categories dict from discovered agents."""
+    cats: Dict[str, Dict[str, Any]] = {}
+    for agent in agents:
+        cat_key = agent["category"]
+        if cat_key not in cats:
+            meta = _CATEGORY_META.get(cat_key, {
+                "name": cat_key.replace("-", " ").replace("_", " ").title(),
+                "color": "#8b949e",
+                "icon": "circle",
+            })
+            cats[cat_key] = meta
+    return cats
+
+
+def find_agent_by_id(
+    agent_id: str, project_path: Optional[str] = None
+) -> Optional[Dict[str, Any]]:
+    """Find a specific agent by ID across all directories."""
+    for agent in discover_agents(project_path):
+        if agent["id"] == agent_id:
+            return agent
+    return None
+
+
+def toggle_agent(agent_id: str, enabled: bool, project_path: Optional[str] = None) -> Dict[str, Any]:
+    """Toggle an agent between enabled and disabled state.
+
+    - Enable: move from _disabled/<category>/ to agents/ root
+    - Disable: move from agents/ root to _disabled/<category>/
+
+    Returns the updated agent dict.
+    """
+    agent = find_agent_by_id(agent_id, project_path)
+    if not agent:
+        raise FileNotFoundError(f"Agent '{agent_id}' not found")
+
+    src = Path(agent["file_path"])
+    base = Path(agent["base_dir"])
+
+    if enabled and not agent["enabled"]:
+        # Move from _disabled/<category>/ to agents/ root
+        dest = base / agent["filename"]
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(src), str(dest))
+        agent["file_path"] = str(dest)
+        agent["enabled"] = True
+    elif not enabled and agent["enabled"]:
+        # Move from agents/ root to _disabled/<category>/
+        category = agent["category"]
+        category_dir = base / "_disabled" / category
+        category_dir.mkdir(parents=True, exist_ok=True)
+        dest = category_dir / agent["filename"]
+        shutil.move(str(src), str(dest))
+        agent["file_path"] = str(dest)
+        agent["enabled"] = False
+
+    return agent
+
+
+# Backward-compatible: AVAILABLE_AGENTS as lazy discovery result
+AVAILABLE_AGENTS = discover_agents()
+
 
 # ---------------------------------------------------------------------------
 # Helper: derive a hook ID from its command string
@@ -249,10 +498,12 @@ def load_configured_mcps(
 # Helper functions (unchanged interface)
 # ---------------------------------------------------------------------------
 
-def get_agents_by_category():
+def get_agents_by_category(agents: Optional[List[Dict[str, Any]]] = None):
     """Group agents by category."""
+    if agents is None:
+        agents = discover_agents()
     result = {}
-    for agent in AVAILABLE_AGENTS:
+    for agent in agents:
         cat = agent["category"]
         if cat not in result:
             result[cat] = []
@@ -262,7 +513,4 @@ def get_agents_by_category():
 
 def get_agent_by_id(agent_id: str):
     """Get agent by ID."""
-    for agent in AVAILABLE_AGENTS:
-        if agent["id"] == agent_id:
-            return agent
-    return None
+    return find_agent_by_id(agent_id)