feat: Graphify-Integration — Knowledge-Graph-gestützte Codebase-Analyse

- Neue MCP-Tools: graphify_query, graphify_update, graphify_explain, graphify_path
- graphify_service.py: Wrapper für graphify CLI (Query, Update, Explain, Path)
- project_overview zeigt automatisch graphify-Stats wenn Graph existiert
- Schemas + Protocol registriert: Argument-Validierung, Aliases, Instructions

Author: SIN-Agent

src/simone_mcp/core.py

@@ -279,8 +279,130 @@
         },
         "execution": {"taskSupport": "forbidden"},
     },
+    {
+        "name": "sin_simone_mcp_graphify_query",
+        "title": "Graphify Query",
+        "description": "Ask a question about a codebase using its knowledge graph (graphify BFS traversal).",
+        "inputSchema": {
+            "$schema": _JSON_SCHEMA_2020_12,
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "Natural language question about the codebase"},
+                "root": {"type": "string", "description": "Workspace root path"},
+                "budget": {"type": "integer", "description": "Max output tokens (default 2000)"},
+            },
+            "required": ["query", "root"],
+        },
+        "outputSchema": {
+            "$schema": _JSON_SCHEMA_2020_12,
+            "type": "object",
+            "properties": {
+                "ok": {"type": "boolean"},
+                "output": {"type": "string"},
+                "error": {"type": "string"},
+            },
+        },
+        "annotations": {
+            "readOnlyHint": True,
+            "destructiveHint": False,
+            "idempotentHint": True,
+            "openWorldHint": True,
+        },
+        "execution": {"taskSupport": "forbidden"},
+    },
+    {
+        "name": "sin_simone_mcp_graphify_update",
+        "title": "Graphify Update",
+        "description": "Re-extract code files and update the knowledge graph for a workspace.",
+        "inputSchema": {
+            "$schema": _JSON_SCHEMA_2020_12,
+            "type": "object",
+            "properties": {
+                "root": {"type": "string", "description": "Workspace root path"},
+            },
+            "required": ["root"],
+        },
+        "outputSchema": {
+            "$schema": _JSON_SCHEMA_2020_12,
+            "type": "object",
+            "properties": {
+                "ok": {"type": "boolean"},
+                "output": {"type": "string"},
+                "error": {"type": "string"},
+            },
+        },
+        "annotations": {
+            "readOnlyHint": False,
+            "destructiveHint": True,
+            "idempotentHint": False,
+            "openWorldHint": True,
+        },
+        "execution": {"taskSupport": "forbidden"},
+    },
+    {
+        "name": "sin_simone_mcp_graphify_explain",
+        "title": "Graphify Explain",
+        "description": "Plain-language explanation of a graph node and its neighbors in a codebase.",
+        "inputSchema": {
+            "$schema": _JSON_SCHEMA_2020_12,
+            "type": "object",
+            "properties": {
+                "node": {"type": "string", "description": "Node name or label to explain"},
+                "root": {"type": "string", "description": "Workspace root path"},
+            },
+            "required": ["node", "root"],
+        },
+        "outputSchema": {
+            "$schema": _JSON_SCHEMA_2020_12,
+            "type": "object",
+            "properties": {
+                "ok": {"type": "boolean"},
+                "output": {"type": "string"},
+                "error": {"type": "string"},
+            },
+        },
+        "annotations": {
+            "readOnlyHint": True,
+            "destructiveHint": False,
+            "idempotentHint": True,
+            "openWorldHint": True,
+        },
+        "execution": {"taskSupport": "forbidden"},
+    },
+    {
+        "name": "sin_simone_mcp_graphify_path",
+        "title": "Graphify Path",
+        "description": "Find the shortest path between two nodes in the codebase knowledge graph.",
+        "inputSchema": {
+            "$schema": _JSON_SCHEMA_2020_12,
+            "type": "object",
+            "properties": {
+                "source": {"type": "string", "description": "Source node name"},
+                "target": {"type": "string", "description": "Target node name"},
+                "root": {"type": "string", "description": "Workspace root path"},
+            },
+            "required": ["source", "target", "root"],
+        },
+        "outputSchema": {
+            "$schema": _JSON_SCHEMA_2020_12,
+            "type": "object",
+            "properties": {
+                "ok": {"type": "boolean"},
+                "output": {"type": "string"},
+                "error": {"type": "string"},
+            },
+        },
+        "annotations": {
+            "readOnlyHint": True,
+            "destructiveHint": False,
+            "idempotentHint": True,
+            "openWorldHint": True,
+        },
+        "execution": {"taskSupport": "forbidden"},
+    },
 ]
 CAPABILITIES = [tool["name"] for tool in TOOL_DEFINITIONS] + [
+    "graphify",
     "memory.hybrid",
     "transport.streamable_http",
     "auth.oauth2.1",
@@ -316,6 +438,10 @@ def build_agent_card(base_url: str) -> dict[str, Any]:
             {"id": "sin_simone_mcp_memory_query", "name": "Memory Query"},
             {"id": "sin_simone_mcp_find_references", "name": "Find References"},
             {"id": "sin_simone_mcp_project_overview", "name": "Project Overview"},
+            {"id": "sin_simone_mcp_graphify_query", "name": "Graphify Query"},
+            {"id": "sin_simone_mcp_graphify_update", "name": "Graphify Update"},
+            {"id": "sin_simone_mcp_graphify_explain", "name": "Graphify Explain"},
+            {"id": "sin_simone_mcp_graphify_path", "name": "Graphify Path"},
         ],
         "defaultInputModes": ["application/json", "text/plain"],
         "defaultOutputModes": ["application/json", "text/plain"],
@@ -765,7 +891,7 @@ def get_project_overview(payload: dict[str, Any]) -> dict[str, Any]:
         suffix = path.suffix or "[none]"
         counts[suffix] = counts.get(suffix, 0) + 1
     top_extensions = sorted(counts.items(), key=lambda item: (-item[1], item[0]))[:10]
-    return {
+    result: dict[str, Any] = {
         "ok": True,
         "root": str(root),
         "fileCount": file_count,
@@ -774,15 +900,52 @@ def get_project_overview(payload: dict[str, Any]) -> dict[str, Any]:
             for extension, count in top_extensions
         ],
     }
+    graph_summary = _graphify_summary_impl(str(root))
+    if graph_summary.get("has_graph"):
+        result["graphify"] = graph_summary
+    return result
 
 
 from .hybrid_memory import query_hybrid_memory as _query_hybrid_memory_impl  # noqa: E402
+from .graphify_service import (  # noqa: E402
+    graphify_query as _graphify_query_impl,
+    graphify_update as _graphify_update_impl,
+    graphify_explain as _graphify_explain_impl,
+    graphify_path as _graphify_path_impl,
+    graphify_summary as _graphify_summary_impl,
+    graphify_available as _graphify_available_impl,
+)
 
 
 def query_hybrid_memory(payload: dict[str, Any]) -> dict[str, Any]:
     return _query_hybrid_memory_impl(payload)
 
 
+def _graphify_query(payload: dict[str, Any]) -> dict[str, Any]:
+    question = str(payload.get("query") or "").strip()
+    root = str(payload.get("root") or _workspace_root(None))
+    budget = int(payload.get("budget", 2000))
+    return _graphify_query_impl(question, root, budget=budget)
+
+
+def _graphify_update(payload: dict[str, Any]) -> dict[str, Any]:
+    root = str(payload.get("root") or _workspace_root(None))
+    return _graphify_update_impl(root)
+
+
+def _graphify_explain(payload: dict[str, Any]) -> dict[str, Any]:
+    node = str(payload.get("node") or "").strip()
+    root = str(payload.get("root") or _workspace_root(None))
+    return _graphify_explain_impl(node, root)
+
+
+def _graphify_path(payload: dict[str, Any]) -> dict[str, Any]:
+    source = str(payload.get("source") or "").strip()
+    target = str(payload.get("target") or "").strip()
+    root = str(payload.get("root") or _workspace_root(None))
+    return _graphify_path_impl(source, target, root)
+
+
 _SYNC_ACTIONS = frozenset({
     "sin_simone_mcp_symbol_search",
     "sin_simone_mcp_find_references",
@@ -791,6 +954,10 @@ def query_hybrid_memory(payload: dict[str, Any]) -> dict[str, Any]:
     "sin_simone_mcp_project_overview",
     "sin_simone_mcp_health",
     "sin_simone_mcp_insert_after",
+    "sin_simone_mcp_graphify_query",
+    "sin_simone_mcp_graphify_update",
+    "sin_simone_mcp_graphify_explain",
+    "sin_simone_mcp_graphify_path",
 })
 
 
@@ -809,6 +976,10 @@ async def execute_simone_action(payload: dict[str, Any]) -> dict[str, Any]:
                     "sin_simone_mcp_memory_query",
                     "sin_simone_mcp_find_references",
                     "sin_simone_mcp_project_overview",
+                    "sin_simone_mcp_graphify_query",
+                    "sin_simone_mcp_graphify_update",
+                    "sin_simone_mcp_graphify_explain",
+                    "sin_simone_mcp_graphify_path",
                 ],
             }
         if action in {"simone.mcp.health", "sin.simone.mcp.health", "sin_simone_mcp_health"}:
@@ -840,6 +1011,14 @@ def _execute_sync_action(action: str, payload: dict[str, Any]) -> dict[str, Any]
         return query_hybrid_memory(payload)
     if action == "sin_simone_mcp_insert_after":
         return insert_after_symbol(payload)
+    if action == "sin_simone_mcp_graphify_query":
+        return _graphify_query(payload)
+    if action == "sin_simone_mcp_graphify_update":
+        return _graphify_update(payload)
+    if action == "sin_simone_mcp_graphify_explain":
+        return _graphify_explain(payload)
+    if action == "sin_simone_mcp_graphify_path":
+        return _graphify_path(payload)
     return {"ok": False, "error": "unknown_action", "action": action}
 
 

src/simone_mcp/graphify_service.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_GRAPHIFY_BIN: str | None = None
+
+
+def _find_graphify() -> str | None:
+    global _GRAPHIFY_BIN
+    if _GRAPHIFY_BIN is not None:
+        return _GRAPHIFY_BIN
+    candidates = [
+        "/opt/homebrew/bin/graphify",
+        "/usr/local/bin/graphify",
+        os.path.expanduser("~/.local/bin/graphify"),
+    ]
+    for c in candidates:
+        if os.path.isfile(c) and os.access(c, os.X_OK):
+            _GRAPHIFY_BIN = c
+            return c
+    which = os.popen("which graphify 2>/dev/null").read().strip()
+    if which and os.path.isfile(which):
+        _GRAPHIFY_BIN = which
+        return which
+    _GRAPHIFY_BIN = ""
+    return None
+
+
+def _run_graphify(args: list[str], cwd: str | None = None) -> dict[str, Any]:
+    gpath = _find_graphify()
+    if not gpath:
+        return {"ok": False, "error": "graphify not installed"}
+    try:
+        result = subprocess.run(
+            [gpath] + args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+        output = result.stdout.strip()
+        stderr = result.stderr.strip()
+        if result.returncode != 0:
+            error_msg = stderr or output or f"exit code {result.returncode}"
+            return {"ok": False, "error": error_msg}
+        return {"ok": True, "output": output, "stderr": stderr}
+    except subprocess.TimeoutExpired:
+        return {"ok": False, "error": "graphify command timed out (120s)"}
+    except FileNotFoundError:
+        return {"ok": False, "error": "graphify not found"}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+def _graph_path(root: str) -> str:
+    return os.path.join(root, "graphify-out", "graph.json")
+
+
+def _has_graph(root: str) -> bool:
+    return os.path.isfile(_graph_path(root))
+
+
+def graphify_update(root: str) -> dict[str, Any]:
+    """Run `graphify update <root>` to regenerate the knowledge graph."""
+    root_path = os.path.abspath(os.path.expanduser(root))
+    if not os.path.isdir(root_path):
+        return {"ok": False, "error": f"directory not found: {root_path}"}
+    return _run_graphify(["update", root_path], cwd=root_path)
+
+
+def graphify_query(question: str, root: str, budget: int = 2000, dfs: bool = False) -> dict[str, Any]:
+    """Run `graphify query <question>` on a repo's graph."""
+    root_path = os.path.abspath(os.path.expanduser(root))
+    if not _has_graph(root_path):
+        return {"ok": False, "error": f"No graph found at {_graph_path(root_path)}. Run graphify_update first."}
+    graph_arg = _graph_path(root_path)
+
+    args = ["query", question, "--graph", graph_arg, "--budget", str(budget)]
+    if dfs:
+        args.append("--dfs")
+
+    result = _run_graphify(args, cwd=root_path)
+    return result
+
+
+def graphify_explain(node: str, root: str) -> dict[str, Any]:
+    """Run `graphify explain <node>` to understand a node."""
+    root_path = os.path.abspath(os.path.expanduser(root))
+    if not _has_graph(root_path):
+        return {"ok": False, "error": f"No graph found at {_graph_path(root_path)}"}
+    graph_arg = _graph_path(root_path)
+    return _run_graphify(["explain", node, "--graph", graph_arg], cwd=root_path)
+
+
+def graphify_path(source: str, target: str, root: str) -> dict[str, Any]:
+    """Run `graphify path <source> <target>` to find shortest path."""
+    root_path = os.path.abspath(os.path.expanduser(root))
+    if not _has_graph(root_path):
+        return {"ok": False, "error": f"No graph found at {_graph_path(root_path)}"}
+    graph_arg = _graph_path(root_path)
+    return _run_graphify(["path", source, target, "--graph", graph_arg], cwd=root_path)
+
+
+def graphify_install(platform: str = "opencode") -> dict[str, Any]:
+    """Run `graphify install --platform <platform>`."""
+    return _run_graphify(["install", "--platform", platform])
+
+
+def graphify_summary(root: str) -> dict[str, Any]:
+    """Read graph.json and return summary stats (no CLI call)."""
+    root_path = os.path.abspath(os.path.expanduser(root))
+    gp = _graph_path(root_path)
+    if not os.path.isfile(gp):
+        return {"ok": False, "error": f"No graph found at {gp}", "has_graph": False}
+    try:
+        with open(gp) as f:
+            graph = json.load(f)
+        nodes = graph.get("nodes", [])
+        edges = graph.get("edges", [])
+        communities = graph.get("communities", [])
+        god_nodes = sorted(
+            nodes,
+            key=lambda n: len(n.get("neighbors", [])),
+            reverse=True,
+        )[:10]
+        return {
+            "ok": True,
+            "has_graph": True,
+            "node_count": len(nodes),
+            "edge_count": len(edges),
+            "community_count": len(communities),
+            "top_nodes": [
+                {"name": n.get("label", n.get("id", "?")), "edges": len(n.get("neighbors", []))}
+                for n in god_nodes
+            ],
+        }
+    except Exception as e:
+        return {"ok": False, "error": str(e), "has_graph": False}
+
+
+def graphify_available() -> bool:
+    return _find_graphify() is not None