claude-memory-agent 3.0.2 → 3.1.0

package/install.py

@@ -542,11 +542,18 @@ def setup_hooks(config: Dict[str, str]) -> bool:
         print_warning("Hooks directory not found in agent, skipping hook setup")
         return True
 
-    # Hooks to install
+    # Hooks to install (all 8 active hooks)
     hooks_to_install = [
         "session_start.py",
-        "session_end.py",
+        "session_end_hook.py",
+        "stop_hook.py",
         "grounding-hook.py",
+        "log-user-request.py",
+        "detect-correction.py",
+        "pre-tool-decision.py",
+        "log-tool-use.py",
+        "auto-detect-response.py",
+        "extract_memories.py",  # Required by session_end_hook
     ]
 
     installed = 0
@@ -574,54 +581,126 @@ def setup_hooks(config: Dict[str, str]) -> bool:
 
 
 def configure_hooks_json(auto: bool = False) -> bool:
-    """Configure hooks.json to enable the hooks."""
-    hooks_file = get_claude_settings_dir() / "hooks.json"
+    """Configure hooks in settings.json (Claude Code hook format).
 
-    # Default hooks configuration
+    Writes hooks config directly into ~/.claude/settings.json
+    using the correct Claude Code settings format.
+    """
+    settings_file = get_claude_settings_file()
+    python_exe = sys.executable
+    hooks_dir = get_hooks_dir()
+
+    # Build the hooks config in Claude Code settings.json format
     hooks_config = {
-        "hooks": {
-            "UserPromptSubmit": [
-                {
-                    "command": f"{sys.executable} {get_hooks_dir() / 'session_start.py'}",
-                    "description": "Initialize memory session",
-                    "timeout": 5000
-                },
-                {
-                    "command": f"{sys.executable} {get_hooks_dir() / 'grounding-hook.py'}",
-                    "description": "Inject grounding context",
-                    "timeout": 3000
-                }
-            ],
-            "SessionEnd": [
-                {
-                    "command": f"{sys.executable} {get_hooks_dir() / 'session_end.py'}",
-                    "description": "Save session summary",
-                    "timeout": 10000
-                }
-            ]
-        }
+        "UserPromptSubmit": [
+            {
+                "matcher": "",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": f"{python_exe} {hooks_dir / 'detect-correction.py'}",
+                        "async": True,
+                    },
+                    {
+                        "type": "command",
+                        "command": f"{python_exe} {hooks_dir / 'log-user-request.py'}",
+                        "async": True,
+                    },
+                    {
+                        "type": "command",
+                        "command": f"{python_exe} {hooks_dir / 'grounding-hook.py'}",
+                    },
+                ],
+            }
+        ],
+        "PreToolUse": [
+            {
+                "matcher": "Edit|Write|Bash|Task",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": f"{python_exe} {hooks_dir / 'pre-tool-decision.py'}",
+                        "async": True,
+                    }
+                ],
+            }
+        ],
+        "PostToolUse": [
+            {
+                "matcher": "Edit|Write|Bash|Read",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": f"{python_exe} {hooks_dir / 'log-tool-use.py'}",
+                        "async": True,
+                    }
+                ],
+            }
+        ],
+        "Stop": [
+            {
+                "matcher": "",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": f"{python_exe} {hooks_dir / 'stop_hook.py'}",
+                        "async": True,
+                    },
+                    {
+                        "type": "command",
+                        "command": f"{python_exe} {hooks_dir / 'auto-detect-response.py'}",
+                        "async": True,
+                    },
+                ],
+            }
+        ],
+        "SessionStart": [
+            {
+                "matcher": "",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": f"{python_exe} {hooks_dir / 'session_start.py'}",
+                    }
+                ],
+            }
+        ],
+        "SessionEnd": [
+            {
+                "matcher": "",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": f"{python_exe} {hooks_dir / 'session_end_hook.py'}",
+                        "async": True,
+                    }
+                ],
+            }
+        ],
     }
 
-    # Merge with existing if present
-    if hooks_file.exists():
+    # Load existing settings
+    settings = {}
+    if settings_file.exists():
         try:
-            existing = json.loads(hooks_file.read_text())
-            # In auto mode, always merge; otherwise ask
-            should_update = auto or prompt_yes_no("hooks.json exists. Update with memory agent hooks?", default=True)
-            if should_update:
-                if "hooks" not in existing:
-                    existing["hooks"] = {}
-                existing["hooks"].update(hooks_config["hooks"])
-                hooks_config = existing
-            else:
-                print_success("Keeping existing hooks.json")
-                return True
+            settings = json.loads(settings_file.read_text())
         except json.JSONDecodeError:
-            pass
+            print_warning(f"Existing {settings_file.name} is invalid, creating backup")
+            shutil.copy(settings_file, settings_file.with_suffix(".json.bak"))
+            settings = {}
+
+    # Check if hooks already configured
+    if "hooks" in settings:
+        should_update = auto or prompt_yes_no("Hooks already configured in settings.json. Update with memory agent hooks?", default=True)
+        if not should_update:
+            print_success("Keeping existing hooks config")
+            return True
+
+    settings["hooks"] = hooks_config
 
     try:
-        hooks_file.write_text(json.dumps(hooks_config, indent=2))
-        print_success(f"Configured hooks: {hooks_file}")
+        settings_file.write_text(json.dumps(settings, indent=2))
+        print_success(f"Configured hooks in: {settings_file}")
         return True
     except Exception as e:
         print_error(f"Failed to configure hooks: {e}")
@@ -762,9 +841,25 @@ def uninstall() -> bool:
         except Exception as e:
             print_warning(f"Could not update settings: {e}")
 
-    # Remove hooks
+    # Remove hooks from settings.json
+    if settings_file.exists():
+        try:
+            settings = json.loads(settings_file.read_text())
+            if "hooks" in settings:
+                del settings["hooks"]
+                settings_file.write_text(json.dumps(settings, indent=2))
+                print_success("Removed hooks config from settings.json")
+        except Exception as e:
+            print_warning(f"Could not update hooks in settings: {e}")
+
+    # Remove hook files
     hooks_dir = get_hooks_dir()
-    hooks_to_remove = ["session_start.py", "session_end.py", "grounding-hook.py"]
+    hooks_to_remove = [
+        "session_start.py", "session_end_hook.py", "stop_hook.py",
+        "grounding-hook.py", "log-user-request.py", "detect-correction.py",
+        "pre-tool-decision.py", "log-tool-use.py", "auto-detect-response.py",
+        "extract_memories.py",
+    ]
     for hook in hooks_to_remove:
         hook_file = hooks_dir / hook
         if hook_file.exists():

package/main.py

@@ -111,11 +111,15 @@ from services.claude_md_sync import get_claude_md_sync
 # Cross-session awareness
 from services.session_awareness import get_session_awareness
 
+# Soul layer — persistent personality and learning
+from services.soul import SoulService
+
 # Agent registry for dashboard
 from services.agent_registry import (
     AVAILABLE_AGENTS, AVAILABLE_MCPS, AVAILABLE_HOOKS,
     AGENT_CATEGORIES, get_agents_by_category, get_agent_by_id,
-    load_configured_hooks, load_configured_mcps
+    load_configured_hooks, load_configured_mcps,
+    discover_agents, discover_categories, find_agent_by_id, toggle_agent
 )
 
 load_dotenv()
@@ -186,6 +190,7 @@ metrics = OperationMetrics()
 
 # Initialize services
 db = DatabaseService()
+soul_service = SoulService(db)
 from config import config as _cfg
 embeddings = EmbeddingService(
     provider_type=_cfg.EMBEDDING_PROVIDER,
@@ -1772,6 +1777,37 @@ async def _handle_session_append_file(query, params, session_id):
     )
 
 
+# ============================================================
+# SOUL LAYER SKILL HANDLERS
+# ============================================================
+
+async def _handle_soul_brief(query, params, session_id):
+    project_path = params.get("project_path", "")
+    brief = await soul_service.generate_soul_brief(project_path)
+    return {"success": True, "brief": brief}
+
+async def _handle_soul_capture(query, params, session_id):
+    sid = params.get("session_id") or session_id or ""
+    project_path = params.get("project_path", "")
+    fragment_type = params.get("fragment_type", "")
+    content = params.get("content", "")
+    if not fragment_type or not content:
+        return {"success": False, "error": "fragment_type and content required"}
+    frag_id = await soul_service.capture_soul_fragment(
+        session_id=sid,
+        fragment_type=fragment_type,
+        content=content,
+        project_path=project_path,
+    )
+    return {"success": frag_id is not None, "fragment_id": frag_id}
+
+async def _handle_soul_integrate(query, params, session_id):
+    sid = params.get("session_id") or session_id or ""
+    project_path = params.get("project_path", "")
+    result = await soul_service.run_soul_integration(sid, project_path)
+    return {"success": True, **result}
+
+
 # ============================================================
 # SKILL DISPATCH TABLE
 # ============================================================
@@ -1928,6 +1964,11 @@ SKILL_DISPATCH = {
     "session_conflicts": _handle_session_conflicts,
     "session_post_activity": _handle_session_post_activity,
     "session_append_file": _handle_session_append_file,
+
+    # Soul Layer
+    "soul_brief": _handle_soul_brief,
+    "soul_capture": _handle_soul_capture,
+    "soul_integrate": _handle_soul_integrate,
 }
 
 
@@ -4362,17 +4403,41 @@ async def api_mark_insight_applied(insight_id: int):
 # ============= Agent Configuration API =============
 
 @app.get("/api/agents")
-async def get_all_agents():
-    """Get all available agents with categories."""
+async def get_all_agents(project_path: Optional[str] = None):
+    """Get all discovered agents from disk with categories."""
+    agents = discover_agents(project_path)
+    categories = discover_categories(agents)
+    enabled_count = sum(1 for a in agents if a["enabled"])
     return {
         "success": True,
-        "agents": AVAILABLE_AGENTS,
-        "categories": AGENT_CATEGORIES,
-        "by_category": get_agents_by_category(),
-        "total": len(AVAILABLE_AGENTS)
+        "agents": agents,
+        "categories": categories,
+        "by_category": get_agents_by_category(agents),
+        "total": len(agents),
+        "enabled": enabled_count,
     }
 
 
+@app.post("/api/agents/{agent_id}/toggle")
+async def toggle_agent_endpoint(agent_id: str, request: Request):
+    """Toggle an agent between enabled/disabled by moving files on disk."""
+    try:
+        body = await request.json()
+        enabled = body.get("enabled", False)
+        project_path = body.get("project_path")
+
+        agent = toggle_agent(agent_id, enabled, project_path)
+        return {
+            "success": True,
+            "agent": agent,
+        }
+    except FileNotFoundError as e:
+        return {"success": False, "error": str(e)}
+    except Exception as e:
+        logger.error(f"Error toggling agent {agent_id}: {e}")
+        return {"success": False, "error": str(e)}
+
+
 @app.get("/api/mcps")
 async def get_all_mcps():
     """Get all available MCP servers with live configured status."""
@@ -4435,7 +4500,8 @@ async def get_project_config(project_path: str):
             (project_path,)
         )
 
-        # Build agent status map (enabled/disabled)
+        # Build agent status map from disk discovery
+        live_agents = discover_agents(project_path)
         agent_status = {}
         for config in (agent_configs or []):
             agent_status[config['agent_id']] = {
@@ -4444,12 +4510,12 @@ async def get_project_config(project_path: str):
                 'settings': json.loads(config['settings']) if config['settings'] else {}
             }
 
-        # Fill in defaults for unconfigured agents
-        for agent in AVAILABLE_AGENTS:
+        # Fill in defaults for agents not in DB config
+        for agent in live_agents:
             if agent['id'] not in agent_status:
                 agent_status[agent['id']] = {
-                    'enabled': agent['default_enabled'],
-                    'priority': agent['priority'],
+                    'enabled': agent['enabled'],
+                    'priority': 5,
                     'settings': {}
                 }
 
@@ -4502,7 +4568,7 @@ async def get_project_config(project_path: str):
             "hooks": hook_status,
             "stats": {
                 "enabled_agents": sum(1 for a in agent_status.values() if a['enabled']),
-                "total_agents": len(AVAILABLE_AGENTS),
+                "total_agents": len(live_agents),
                 "enabled_mcps": sum(1 for m in mcp_status.values() if m.get('enabled')),
                 "total_mcps": len(live_mcps),
                 "configured_mcps": sum(1 for m in mcp_status.values() if m.get('configured')),
@@ -5645,6 +5711,60 @@ async def api_post_session_activity(request: Request):
         return {"success": False, "error": str(e)}
 
 
+# ============= Soul Layer REST Endpoints =============
+
+
+@app.get("/api/soul/brief")
+async def api_soul_brief(project_path: str = ""):
+    """Get the soul brief for a project."""
+    try:
+        brief = await soul_service.generate_soul_brief(project_path)
+        return {"success": True, "brief": brief}
+    except Exception as e:
+        logger.error(f"Soul brief failed: {e}")
+        return {"success": False, "error": str(e), "brief": ""}
+
+
+@app.post("/api/soul/capture")
+async def api_soul_capture(request: Request):
+    """Capture a soul fragment from a session response."""
+    try:
+        body = await request.json()
+        session_id = body.get("session_id", "")
+        project_path = body.get("project_path", "")
+        fragment_type = body.get("fragment_type", "")
+        content = body.get("content", "")
+
+        if not fragment_type or not content:
+            return {"success": False, "error": "fragment_type and content required"}
+
+        frag_id = await soul_service.capture_soul_fragment(
+            session_id=session_id,
+            fragment_type=fragment_type,
+            content=content,
+            project_path=project_path,
+        )
+        return {"success": frag_id is not None, "fragment_id": frag_id}
+    except Exception as e:
+        logger.error(f"Soul capture failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+@app.post("/api/soul/integrate")
+async def api_soul_integrate(request: Request):
+    """Run soul integration for a session — merges fragments into soul_state."""
+    try:
+        body = await request.json()
+        session_id = body.get("session_id", "")
+        project_path = body.get("project_path", "")
+
+        result = await soul_service.run_soul_integration(session_id, project_path)
+        return {"success": True, **result}
+    except Exception as e:
+        logger.error(f"Soul integration failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
 # ============= Aggregated Grounding Context (v2) =============
 
 

package/mcp_proxy.py

@@ -180,6 +180,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)
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-memory-agent",
-  "version": "3.0.2",
-  "description": "Persistent semantic memory system for Claude Code sessions with anti-hallucination grounding",
+  "version": "3.1.0",
+  "description": "Persistent semantic memory for Claude Code with soul layer, personality learning, and anti-hallucination grounding",
   "keywords": [
     "claude",
     "claude-code",