claude-memory-agent 3.0.3 → 3.2.0

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) =============
 
 
@@ -5810,6 +5930,395 @@ async def api_grounding_context(request: Request):
     }
 
 
+# ============= Session Recovery System (v3.2.0) =============
+
+
+@app.post("/api/workflow/capture")
+async def api_workflow_capture(request: Request):
+    """Capture or upsert a workflow (name + steps + commands).
+
+    If same workflow name exists for this project, increments success_count and merges commands.
+    """
+    try:
+        body = await request.json()
+        name = body.get("name", "").strip()
+        if not name:
+            return {"success": False, "error": "name required"}
+
+        workflow_id = await db.store_workflow_knowledge(
+            name=name,
+            steps=body.get("steps"),
+            commands=body.get("commands"),
+            tags=body.get("tags"),
+            project_path=body.get("project_path") or None,
+        )
+        return {"success": workflow_id > 0, "workflow_id": workflow_id}
+    except Exception as e:
+        logger.error(f"Workflow capture failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+@app.post("/api/session/brain-dump")
+async def api_session_brain_dump(request: Request):
+    """Aggregate full session state for writing to MEMORY.md before compaction.
+
+    Runs parallel queries: session_state, latest checkpoint, recent memories,
+    workflow_knowledge, and soul brief.
+
+    Body:
+        session_id: str
+        project_path: str
+    """
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+
+    session_id = body.get("session_id", "")
+    project_path = body.get("project_path", "")
+
+    result = {
+        "success": True,
+        "timestamp": datetime.now().isoformat(),
+        "session_id": session_id,
+    }
+
+    tasks_dict = {}
+
+    # Session state
+    if session_id:
+        async def _get_state():
+            try:
+                cursor = db.conn.cursor()
+                cursor.execute(
+                    "SELECT * FROM session_state WHERE session_id = ?",
+                    (session_id,)
+                )
+                row = cursor.fetchone()
+                if row:
+                    return {
+                        "current_goal": row["current_goal"],
+                        "entity_registry": json.loads(row["entity_registry"]) if row["entity_registry"] else {},
+                        "decisions_summary": row["decisions_summary"],
+                        "pending_questions": json.loads(row["pending_questions"]) if row["pending_questions"] else [],
+                    }
+                return None
+            except Exception:
+                return None
+        tasks_dict["state"] = _get_state()
+
+    # Latest checkpoint
+    if session_id:
+        tasks_dict["checkpoint"] = db.get_latest_checkpoint(session_id)
+
+    # Recent memories (last 10 high-importance)
+    if project_path:
+        async def _get_recent_memories():
+            try:
+                cursor = db.conn.cursor()
+                cursor.execute(
+                    """SELECT content, type, importance, tags, created_at
+                       FROM memories
+                       WHERE project_path = ? AND importance >= 6
+                       ORDER BY created_at DESC LIMIT 10""",
+                    (project_path,)
+                )
+                return [dict(r) for r in cursor.fetchall()]
+            except Exception:
+                return []
+        tasks_dict["memories"] = _get_recent_memories()
+
+    # Workflow knowledge
+    tasks_dict["workflows"] = db.get_workflow_knowledge(
+        project_path=project_path, limit=10
+    )
+
+    # Soul brief
+    if project_path:
+        async def _get_soul():
+            try:
+                return await soul_service.generate_soul_brief(project_path)
+            except Exception:
+                return ""
+        tasks_dict["soul"] = _get_soul()
+
+    # Run all in parallel
+    keys = list(tasks_dict.keys())
+    gathered = await asyncio.gather(
+        *[tasks_dict[k] for k in keys],
+        return_exceptions=True,
+    )
+
+    for k, v in zip(keys, gathered):
+        if isinstance(v, Exception):
+            result[k] = None
+        else:
+            result[k] = v
+
+    return result
+
+
+@app.post("/api/session/resume")
+async def api_session_resume(request: Request):
+    """Complete catch-up package for resuming a session after context clear.
+
+    Returns: goal, decisions, entity registry, learned workflows,
+    recent memories, and soul brief — all in one call.
+
+    Body:
+        session_id: str (optional — uses latest for project if missing)
+        project_path: str
+    """
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+
+    session_id = body.get("session_id", "")
+    project_path = body.get("project_path", "")
+
+    result = {"success": True}
+
+    tasks_dict = {}
+
+    # Session state — try by ID first, fall back to latest for project
+    async def _get_state():
+        try:
+            if session_id:
+                cursor = db.conn.cursor()
+                cursor.execute(
+                    "SELECT * FROM session_state WHERE session_id = ?",
+                    (session_id,)
+                )
+                row = cursor.fetchone()
+                if row:
+                    return {
+                        "session_id": row["session_id"],
+                        "current_goal": row["current_goal"],
+                        "entity_registry": json.loads(row["entity_registry"]) if row["entity_registry"] else {},
+                        "decisions_summary": row["decisions_summary"],
+                        "pending_questions": json.loads(row["pending_questions"]) if row["pending_questions"] else [],
+                    }
+            if project_path:
+                return await db.get_latest_session_for_project(project_path)
+            return None
+        except Exception:
+            return None
+    tasks_dict["session_state"] = _get_state()
+
+    # Latest checkpoint
+    async def _get_checkpoint():
+        try:
+            if session_id:
+                return await db.get_latest_checkpoint(session_id)
+            if project_path:
+                state = await db.get_latest_session_for_project(project_path)
+                if state:
+                    return await db.get_latest_checkpoint(state["session_id"])
+            return None
+        except Exception:
+            return None
+    tasks_dict["checkpoint"] = _get_checkpoint()
+
+    # Workflow knowledge
+    tasks_dict["workflows"] = db.get_workflow_knowledge(
+        project_path=project_path, limit=10
+    )
+
+    # Recent high-importance memories
+    async def _get_memories():
+        try:
+            cursor = db.conn.cursor()
+            if project_path:
+                cursor.execute(
+                    """SELECT id, content, type, importance, tags, created_at
+                       FROM memories
+                       WHERE project_path = ? AND importance >= 5
+                       ORDER BY importance DESC, created_at DESC
+                       LIMIT 15""",
+                    (project_path,)
+                )
+            else:
+                cursor.execute(
+                    """SELECT id, content, type, importance, tags, created_at
+                       FROM memories
+                       WHERE importance >= 6
+                       ORDER BY importance DESC, created_at DESC
+                       LIMIT 10"""
+                )
+            return [dict(r) for r in cursor.fetchall()]
+        except Exception:
+            return []
+    tasks_dict["memories"] = _get_memories()
+
+    # Soul brief
+    async def _get_soul():
+        try:
+            if project_path:
+                return await soul_service.generate_soul_brief(project_path)
+            return ""
+        except Exception:
+            return ""
+    tasks_dict["soul_brief"] = _get_soul()
+
+    # Run all in parallel
+    keys = list(tasks_dict.keys())
+    gathered = await asyncio.gather(
+        *[tasks_dict[k] for k in keys],
+        return_exceptions=True,
+    )
+
+    for k, v in zip(keys, gathered):
+        result[k] = v if not isinstance(v, Exception) else None
+
+    return result
+
+
+@app.post("/api/grounding-context/rich")
+async def api_grounding_context_rich(request: Request):
+    """Rich multi-section grounding context for fresh sessions (~500-800 tokens).
+
+    Used by grounding hook when detecting a fresh/resumed session.
+    Includes soul brief, checkpoint summary, workflows, entities, pending items.
+
+    Body:
+        session_id: str
+        project_path: str
+
+    Returns:
+        {"success": true, "context": "[MEM:RESUME] ...", "token_estimate": N}
+    """
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+
+    session_id = body.get("session_id", "")
+    project_path = body.get("project_path", "")
+
+    tasks_dict = {}
+
+    # Session state (by ID or latest for project)
+    async def _get_state():
+        try:
+            if session_id:
+                cursor = db.conn.cursor()
+                cursor.execute(
+                    "SELECT * FROM session_state WHERE session_id = ?",
+                    (session_id,)
+                )
+                row = cursor.fetchone()
+                if row:
+                    return {
+                        "current_goal": row["current_goal"],
+                        "entity_registry": json.loads(row["entity_registry"]) if row["entity_registry"] else {},
+                        "decisions_summary": row["decisions_summary"],
+                        "pending_questions": json.loads(row["pending_questions"]) if row["pending_questions"] else [],
+                    }
+            if project_path:
+                return await db.get_latest_session_for_project(project_path)
+            return None
+        except Exception:
+            return None
+    tasks_dict["state"] = _get_state()
+
+    # Latest checkpoint
+    async def _get_checkpoint():
+        try:
+            if session_id:
+                return await db.get_latest_checkpoint(session_id)
+            if project_path:
+                st = await db.get_latest_session_for_project(project_path)
+                if st:
+                    return await db.get_latest_checkpoint(st["session_id"])
+            return None
+        except Exception:
+            return None
+    tasks_dict["checkpoint"] = _get_checkpoint()
+
+    # Workflow knowledge (top 5)
+    tasks_dict["workflows"] = db.get_workflow_knowledge(
+        project_path=project_path, limit=5
+    )
+
+    # Soul brief
+    async def _get_soul():
+        try:
+            if project_path:
+                return await soul_service.generate_soul_brief(project_path)
+            return ""
+        except Exception:
+            return ""
+    tasks_dict["soul"] = _get_soul()
+
+    # Run all in parallel
+    keys = list(tasks_dict.keys())
+    gathered = await asyncio.gather(
+        *[tasks_dict[k] for k in keys],
+        return_exceptions=True,
+    )
+    results = {}
+    for k, v in zip(keys, gathered):
+        results[k] = v if not isinstance(v, Exception) else None
+
+    # -- Build rich context (budget ~550 tokens / 2200 chars) --
+    sections = []
+
+    # Soul brief (cap 100 tokens)
+    soul = results.get("soul") or ""
+    if soul:
+        sections.append(f"## Soul\n{soul[:400]}")
+
+    # Goal & decisions
+    state = results.get("state")
+    if state and isinstance(state, dict):
+        goal = state.get("current_goal", "")
+        if goal:
+            sections.append(f"## Goal\n{goal[:150]}")
+        decisions = state.get("decisions_summary", "")
+        if decisions:
+            sections.append(f"## Decisions\n{decisions[:300]}")
+        pending = state.get("pending_questions") or state.get("pending_items") or []
+        if pending:
+            items = [f"- {p[:60]}" for p in pending[:5]]
+            sections.append(f"## Pending\n" + "\n".join(items))
+        entities = state.get("entity_registry") or {}
+        if entities:
+            ent_lines = [f"- {k}: {v[:40]}" for k, v in list(entities.items())[:8]]
+            sections.append(f"## Entities\n" + "\n".join(ent_lines))
+
+    # Checkpoint summary
+    cp = results.get("checkpoint")
+    if cp and isinstance(cp, dict):
+        summary = cp.get("summary", "")
+        if summary:
+            sections.append(f"## Last Checkpoint\n{summary[:200]}")
+
+    # Workflows
+    workflows = results.get("workflows") or []
+    if workflows:
+        wf_lines = []
+        for wf in workflows[:5]:
+            cmds = wf.get("commands", [])
+            cmd_str = " -> ".join(cmds[:3]) if cmds else ""
+            wf_lines.append(f"- **{wf['name']}**: {cmd_str[:80]}")
+        sections.append(f"## Workflows\n" + "\n".join(wf_lines))
+
+    if sections:
+        context = "[MEM:RESUME]\n" + "\n\n".join(sections)
+        # Hard cap at ~2200 chars to stay within token budget
+        if len(context) > 2200:
+            context = context[:2200] + "\n..."
+    else:
+        context = ""
+
+    return {
+        "success": True,
+        "context": context,
+        "token_estimate": len(context.split()),
+    }
+
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(