@oriro/orirocli 0.1.9 → 0.1.12

package/skills/graphify/manifest.py

@@ -1,4 +0,0 @@
-# re-export manifest helpers from detect for backwards compatibility
-from graphify.detect import save_manifest, load_manifest, detect_incremental
-
-__all__ = ["save_manifest", "load_manifest", "detect_incremental"]

package/skills/graphify/mcp_ingest.py

@@ -1,392 +0,0 @@
-"""mcp_ingest.py — Extract MCP (Model Context Protocol) server configuration files.
-
-Reads `.mcp.json` / `claude_desktop_config.json` / `mcp.json` / `mcp_servers.json`
-and turns the `mcpServers` map into Graphify nodes and edges.
-
-Symmetry with `serve.py`: Graphify exposes itself AS an MCP server. This module
-indexes MCP servers AS a corpus type, completing the loop — an agent that runs
-graphify with `--mcp` can now query its own configured MCP layer.
-
-Entry point:
-  extract_mcp_config(path: Path) -> dict[str, list[dict]]
-
-  Returns `{"nodes": [...], "edges": [...]}` compatible with Graphify's
-  extraction-result format. Returns `{"nodes": [...], "edges": [...], "error": "..."}`
-  when the file is malformed, too large, or has no `mcpServers` map — the empty
-  result keeps it indistinguishable from "no MCP config here" for downstream
-  callers.
-
-Detected filenames (case-sensitive, matched on basename):
-  - .mcp.json                       (Claude Code project config)
-  - claude_desktop_config.json      (Claude Desktop)
-  - mcp.json                        (generic / per-tool)
-  - mcp_servers.json                (alternate naming)
-
-Schema emitted:
-  Node kinds:
-    - file              the config file itself (label = filename)
-    - mcp_server        one per entry under mcpServers
-    - mcp_command       executable (npx, uvx, node, python, ...) — global ID
-    - mcp_package       npm / pypi package id parsed from args — global ID
-    - env_var           env variable NAME only — global ID. VALUES ARE NEVER READ.
-
-  Edge relations:
-    - contains          file -> mcp_server
-    - references        mcp_server -> mcp_command
-    - references        mcp_server -> mcp_package
-    - requires_env      mcp_server -> env_var   (new relation; distinguishes
-                                                  env dependencies from generic refs)
-
-Security:
-  - Env var VALUES are never read, persisted, labelled, or surfaced. Only env
-    var NAMES become nodes. (`env: {"API_KEY": "sk-..."}` -> node "API_KEY" only.)
-  - File size capped at 1 MiB (matches extract_json).
-  - All labels go through `sanitize_label` (control characters stripped, length
-    capped) before emission.
-  - Args are NOT persisted as nodes/edges to avoid leaking paths or secrets that
-    some servers embed as positional args.
-
-Cross-config emergent edges:
-  Because `mcp_command`, `mcp_package`, and `env_var` nodes use global IDs (no
-  per-file stem prefix), the same package or env var across two MCP configs
-  produces shared nodes — naturally surfacing "what configs depend on this
-  thing?" via graph traversal. Server nodes ARE stem-scoped so two configs
-  declaring different servers under the same key (e.g., both have "filesystem")
-  do not collide.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import unicodedata
-from pathlib import Path
-from typing import Any
-
-from graphify.security import sanitize_label
-
-
-MCP_CONFIG_FILENAMES: frozenset[str] = frozenset({
-    ".mcp.json",
-    "claude_desktop_config.json",
-    "mcp.json",
-    "mcp_servers.json",
-})
-
-_MAX_BYTES = 1_048_576  # 1 MiB — same cap as extract_json
-_MAX_SERVERS_PER_FILE = 200  # generous; flags pathological configs
-
-
-def is_mcp_config_path(path: Path) -> bool:
-    """Return True when ``path`` is a recognised MCP config filename."""
-    return path.name in MCP_CONFIG_FILENAMES
-
-
-def extract_mcp_config(path: Path) -> dict[str, Any]:
-    """Parse an MCP config file into Graphify nodes and edges.
-
-    Behaviour matches other extractors in `extract.py`:
-      - returns ``{"nodes": [...], "edges": [...]}`` on success
-      - returns ``{"nodes": [], "edges": [], "error": "<reason>"}`` on parse
-        failure, oversize file, or missing ``mcpServers`` map
-    """
-    try:
-        with path.open("rb") as fh:
-            raw = fh.read(_MAX_BYTES + 1)
-    except OSError as exc:
-        return {"nodes": [], "edges": [], "error": f"mcp_ingest read error: {exc}"}
-
-    if len(raw) > _MAX_BYTES:
-        return {"nodes": [], "edges": [], "error": "mcp config too large to index"}
-
-    try:
-        text = raw.decode("utf-8")
-    except UnicodeDecodeError as exc:
-        return {"nodes": [], "edges": [], "error": f"mcp_ingest decode error: {exc}"}
-
-    try:
-        doc = json.loads(text)
-    except json.JSONDecodeError as exc:
-        return {"nodes": [], "edges": [], "error": f"mcp_ingest json error: {exc}"}
-
-    if not isinstance(doc, dict):
-        return {"nodes": [], "edges": [], "error": "mcp_ingest: root is not an object"}
-
-    servers = doc.get("mcpServers")
-    if not isinstance(servers, dict):
-        # Some tools nest the map (e.g., {"mcp": {"servers": {...}}}). Try one
-        # well-known alternate shape but do not search exhaustively.
-        nested = doc.get("mcp")
-        if isinstance(nested, dict):
-            servers = nested.get("servers")
-        if not isinstance(servers, dict):
-            return {"nodes": [], "edges": [], "error": "mcp_ingest: no mcpServers map"}
-
-    str_path = str(path)
-    file_nid = _make_id(str_path)
-    nodes: list[dict[str, Any]] = []
-    edges: list[dict[str, Any]] = []
-    seen_node_ids: set[str] = set()
-    seen_edge_keys: set[tuple[str, str, str]] = set()
-
-    _add_node(
-        nodes, seen_node_ids,
-        nid=file_nid,
-        label=path.name,
-        kind="mcp_config_file",
-        source_file=str_path,
-        line=1,
-    )
-
-    file_stem = _file_stem(path)
-    server_count = 0
-    for server_name, spec in servers.items():
-        if not isinstance(server_name, str) or not server_name:
-            continue
-        if not isinstance(spec, dict):
-            # Skip non-object server entries silently — the broken entry is
-            # the user's, not ours.
-            continue
-        if server_count >= _MAX_SERVERS_PER_FILE:
-            break
-        server_count += 1
-        _emit_server(
-            server_name=server_name,
-            spec=spec,
-            file_nid=file_nid,
-            file_stem=file_stem,
-            source_file=str_path,
-            nodes=nodes,
-            edges=edges,
-            seen_node_ids=seen_node_ids,
-            seen_edge_keys=seen_edge_keys,
-        )
-
-    return {"nodes": nodes, "edges": edges}
-
-
-def _emit_server(
-    *,
-    server_name: str,
-    spec: dict[str, Any],
-    file_nid: str,
-    file_stem: str,
-    source_file: str,
-    nodes: list[dict[str, Any]],
-    edges: list[dict[str, Any]],
-    seen_node_ids: set[str],
-    seen_edge_keys: set[tuple[str, str, str]],
-) -> None:
-    """Emit nodes/edges for one entry under ``mcpServers``."""
-    server_nid = _make_id(file_stem, "mcp_server", server_name)
-    _add_node(
-        nodes, seen_node_ids,
-        nid=server_nid,
-        label=server_name,
-        kind="mcp_server",
-        source_file=source_file,
-        line=1,  # JSON doesn't expose line numbers without a parser pass
-    )
-    _add_edge(
-        edges, seen_edge_keys,
-        source=file_nid,
-        target=server_nid,
-        relation="contains",
-        source_file=source_file,
-        line=1,
-    )
-
-    command = spec.get("command")
-    if isinstance(command, str) and command.strip():
-        cmd_label = command.strip()
-        cmd_nid = _make_id("mcp_command", cmd_label)
-        _add_node(
-            nodes, seen_node_ids,
-            nid=cmd_nid,
-            label=cmd_label,
-            kind="mcp_command",
-            source_file=source_file,
-            line=1,
-        )
-        _add_edge(
-            edges, seen_edge_keys,
-            source=server_nid,
-            target=cmd_nid,
-            relation="references",
-            source_file=source_file,
-            line=1,
-            context="command",
-        )
-
-    args = spec.get("args")
-    if isinstance(args, list):
-        package = _detect_package_from_args(args)
-        if package:
-            pkg_nid = _make_id("mcp_package", package)
-            _add_node(
-                nodes, seen_node_ids,
-                nid=pkg_nid,
-                label=package,
-                kind="mcp_package",
-                source_file=source_file,
-                line=1,
-            )
-            _add_edge(
-                edges, seen_edge_keys,
-                source=server_nid,
-                target=pkg_nid,
-                relation="references",
-                source_file=source_file,
-                line=1,
-                context="package",
-            )
-
-    env = spec.get("env")
-    if isinstance(env, dict):
-        # ONLY KEYS. Values may contain secrets and are never read here.
-        for env_name in env.keys():
-            if not isinstance(env_name, str) or not env_name:
-                continue
-            env_nid = _make_id("env_var", env_name)
-            _add_node(
-                nodes, seen_node_ids,
-                nid=env_nid,
-                label=env_name,
-                kind="env_var",
-                source_file=source_file,
-                line=1,
-            )
-            _add_edge(
-                edges, seen_edge_keys,
-                source=server_nid,
-                target=env_nid,
-                relation="requires_env",
-                source_file=source_file,
-                line=1,
-            )
-
-
-# ── Package detection from args ───────────────────────────────────────────────
-
-# Patterns observed in real MCP server configs:
-#   ["-y", "@modelcontextprotocol/server-filesystem", "/data"]   (npx)
-#   ["-y", "@org/pkg@1.2.3"]
-#   ["mcp-server-fetch"]                                          (uvx / python)
-#   ["mcp-server-time", "--local-timezone=UTC"]
-#   ["@scoped/some-mcp"]                                          (pnpx)
-#   ["mcp-server-fetch"]                                          (uvx direct)
-_NPM_PKG_RE = re.compile(r"^@[a-z0-9][a-z0-9._-]*/[a-z0-9][a-z0-9._-]*(?:@[\w.\-+]+)?$")
-_PY_MCP_PKG_RE = re.compile(r"^[a-z0-9][a-z0-9._-]*-mcp(?:-[a-z0-9._-]+)?$|^mcp-[a-z0-9][a-z0-9._-]*$")
-_ARG_FLAG_RE = re.compile(r"^-{1,2}\w")
-
-
-def _detect_package_from_args(args: list[Any]) -> str | None:
-    """Return the first arg that looks like an npm or pypi package id, else None.
-
-    Skips short flags (-y, --yes) and option arguments (--local-timezone=UTC).
-    """
-    for raw in args:
-        if not isinstance(raw, str):
-            continue
-        arg = raw.strip()
-        if not arg or _ARG_FLAG_RE.match(arg):
-            continue
-        if _NPM_PKG_RE.match(arg):
-            return _strip_version(arg)
-        if _PY_MCP_PKG_RE.match(arg):
-            return arg
-    return None
-
-
-def _strip_version(pkg: str) -> str:
-    """Drop the ``@version`` suffix from an npm package id, preserving the scope.
-
-    Scoped:   ``@scope/name`` or ``@scope/name@1.2.3`` — there are at most two
-              ``@`` chars; the second is the version separator.
-    Unscoped: ``name`` or ``name@1.2.3``.
-    """
-    if pkg.startswith("@"):
-        version_at = pkg.find("@", 1)
-        return pkg if version_at == -1 else pkg[:version_at]
-    version_at = pkg.find("@")
-    return pkg if version_at == -1 else pkg[:version_at]
-
-
-# ── Node / edge construction (Graphify schema) ────────────────────────────────
-
-
-def _add_node(
-    nodes: list[dict[str, Any]],
-    seen: set[str],
-    *,
-    nid: str,
-    label: str,
-    kind: str,
-    source_file: str,
-    line: int,
-) -> None:
-    """Append a node if not already present. ``kind`` is metadata, not file_type."""
-    if not nid or nid in seen:
-        return
-    seen.add(nid)
-    nodes.append({
-        "id": nid,
-        "label": sanitize_label(label),
-        "file_type": "code",
-        "source_file": source_file,
-        "source_location": f"L{line}",
-        "metadata": {"mcp_kind": kind},
-    })
-
-
-def _add_edge(
-    edges: list[dict[str, Any]],
-    seen: set[tuple[str, str, str]],
-    *,
-    source: str,
-    target: str,
-    relation: str,
-    source_file: str,
-    line: int,
-    context: str | None = None,
-) -> None:
-    """Append an edge if (source, target, relation) is not already present."""
-    if not source or not target or source == target:
-        return
-    key = (source, target, relation)
-    if key in seen:
-        return
-    seen.add(key)
-    edge: dict[str, Any] = {
-        "source": source,
-        "target": target,
-        "relation": relation,
-        "confidence": "EXTRACTED",
-        "confidence_score": 1.0,
-        "source_file": source_file,
-        "source_location": f"L{line}",
-        "weight": 1.0,
-    }
-    if context:
-        edge["context"] = context
-    edges.append(edge)
-
-
-# ── ID helpers (kept local; mirror extract.py shape) ──────────────────────────
-
-
-def _make_id(*parts: str) -> str:
-    """Build a stable node ID. Must match extract._make_id's normalisation rules."""
-    combined = "_".join(p.strip("_.") for p in parts if p)
-    combined = unicodedata.normalize("NFKC", combined)
-    cleaned = re.sub(r"[^\w]+", "_", combined, flags=re.UNICODE)
-    cleaned = re.sub(r"_+", "_", cleaned)
-    return cleaned.strip("_").casefold()
-
-
-def _file_stem(path: Path) -> str:
-    """Mirror extract._file_stem: include parent dir name to disambiguate."""
-    parent = path.parent.name
-    if parent and parent not in (".", ""):
-        return f"{parent}.{path.stem}"
-    return path.stem

package/skills/graphify/multigraph_compat.py

@@ -1,212 +0,0 @@
-"""Runtime compatibility probe for Graphify MultiDiGraph mode.
-
-Verifies that the current NetworkX runtime supports the behaviors a future
-opt-in --multigraph build will rely on. The probe is BEHAVIOR-based, not
-version-based — both NX 3.4.2 (Py 3.10 lane) and NX 3.6.1+ (Py 3.11+ lane)
-pass. The probe result is cached for the process lifetime via lru_cache.
-
-No call sites added yet; downstream multigraph PRs will gate on
-require_multigraph_capabilities() before enabling MDG mode.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-from functools import lru_cache
-import sys
-from typing import Any
-
-import networkx as nx
-from networkx.readwrite import json_graph
-
-
-@dataclass(frozen=True)
-class CapabilityCheck:
-    name: str
-    ok: bool
-    detail: str
-
-
-@dataclass(frozen=True)
-class MultigraphCapabilityResult:
-    python_version: str
-    networkx_version: str
-    checks: tuple[CapabilityCheck, ...]
-
-    @property
-    def ok(self) -> bool:
-        return all(check.ok for check in self.checks)
-
-    @property
-    def failed(self) -> tuple[CapabilityCheck, ...]:
-        return tuple(check for check in self.checks if not check.ok)
-
-    def error_message(self) -> str:
-        if self.ok:
-            return (
-                "Graphify MultiDiGraph capability probe passed "
-                f"(Python {self.python_version}, NetworkX {self.networkx_version})."
-            )
-        failed = "; ".join(f"{check.name}: {check.detail}" for check in self.failed)
-        return (
-            "error: --multigraph requires NetworkX keyed MultiDiGraph node-link "
-            "round-trip support. "
-            f"Detected Python {self.python_version}, NetworkX {self.networkx_version}. "
-            f"Failed capability check(s): {failed}. "
-            "Default simple graph mode remains available."
-        )
-
-
-def _check(name: str, func: Callable[[], bool | str]) -> CapabilityCheck:
-    try:
-        detail = func()
-    except Exception as exc:
-        return CapabilityCheck(name, False, f"{type(exc).__name__}: {exc}")
-    if detail is True:
-        return CapabilityCheck(name, True, "ok")
-    if isinstance(detail, str):
-        return CapabilityCheck(name, False, detail)
-    return CapabilityCheck(name, False, f"unexpected result {detail!r}")
-
-
-def _build_probe_graph() -> nx.MultiDiGraph:
-    graph = nx.MultiDiGraph()
-    graph.add_node("a", label="A")
-    graph.add_node("b", label="B")
-    graph.add_edge("a", "b", key="calls:a.py:L1", relation="calls", source_file="a.py")
-    graph.add_edge("a", "b", key="imports:a.py:L2", relation="imports", source_file="a.py")
-    return graph
-
-
-def _probe_keyed_parallel_edges() -> bool | str:
-    graph = _build_probe_graph()
-    if not graph.is_multigraph() or not graph.is_directed():
-        return f"probe graph type was {type(graph).__name__}"
-    if graph.number_of_edges("a", "b") != 2:
-        return f"expected 2 keyed parallel edges, got {graph.number_of_edges('a', 'b')}"
-    keys = set(graph["a"]["b"].keys())
-    expected = {"calls:a.py:L1", "imports:a.py:L2"}
-    if keys != expected:
-        return f"expected keys {sorted(expected)}, got {sorted(keys)}"
-    return True
-
-
-def _probe_node_link_round_trip() -> bool | str:
-    graph = _build_probe_graph()
-    data = json_graph.node_link_data(graph, edges="links")
-    if data.get("multigraph") is not True:
-        return f"serialized multigraph flag was {data.get('multigraph')!r}"
-    if data.get("directed") is not True:
-        return f"serialized directed flag was {data.get('directed')!r}"
-    links = data.get("links")
-    if not isinstance(links, list) or len(links) != 2:
-        length = 0 if not isinstance(links, list) else len(links)
-        return f"serialized links length was {length}"
-    serialized_keys: set[str] = set()
-    for edge in links:
-        if isinstance(edge, dict):
-            edge_key = edge.get("key")
-            if isinstance(edge_key, str):
-                serialized_keys.add(edge_key)
-    expected = {"calls:a.py:L1", "imports:a.py:L2"}
-    if serialized_keys != expected:
-        return f"serialized keys {sorted(serialized_keys)} did not match {sorted(expected)}"
-    loaded = json_graph.node_link_graph(data, edges="links")
-    if not isinstance(loaded, nx.MultiDiGraph):
-        return f"round-trip graph type was {type(loaded).__name__}"
-    if loaded.number_of_edges("a", "b") != 2:
-        return f"round-trip edge count was {loaded.number_of_edges('a', 'b')}"
-    loaded_keys = set(loaded["a"]["b"].keys())
-    if loaded_keys != expected:
-        return f"round-trip keys {sorted(loaded_keys)} did not match {sorted(expected)}"
-    return True
-
-
-def _probe_duplicate_key_overwrite_semantics() -> bool | str:
-    graph = nx.MultiDiGraph()
-    graph.add_edge("x", "y", key="same", marker="first")
-    graph.add_edge("x", "y", key="same", marker="second")
-    edges = list(graph.edges(keys=True, data=True))
-    if len(edges) != 1:
-        return f"expected one edge after duplicate-key add, got {len(edges)}"
-    if edges[0][3].get("marker") != "second":
-        return f"expected second attr overwrite, got {edges[0][3].get('marker')!r}"
-    return True
-
-
-def _probe_reserved_key_attr_rejected() -> bool | str:
-    """Verify the Python language guarantee that NetworkX add_edge inherits.
-
-    Python forbids passing the same keyword argument twice — once explicitly
-    and once via **kwargs. This probe confirms that protection still applies
-    to nx.MultiDiGraph.add_edge: a future loader that builds attrs from JSON
-    will be reliably protected from accidentally setting `key` via attrs while
-    also passing `key=` explicitly.
-
-    The probe always passes on any Python 3.x version. Its purpose is to
-    document the invariant explicitly in the probe suite so that if a future
-    Python version relaxes this rule (extremely unlikely), the probe surfaces
-    the regression.
-    """
-    graph = nx.MultiDiGraph()
-    attrs: dict[str, Any] = {"key": "attr-key", "relation": "calls"}
-    try:
-        graph.add_edge("a", "b", key="schema-key", **attrs)
-    except TypeError:
-        return True
-    return "add_edge accepted duplicate key keyword and attr; loader must not rely on this"
-
-
-def _probe_remove_edges_from_two_tuple_semantics() -> bool | str:
-    graph = nx.MultiDiGraph()
-    graph.add_edge("a", "b", key="one")
-    graph.add_edge("a", "b", key="two")
-    graph.remove_edges_from([("a", "b")])
-    remaining = graph.number_of_edges("a", "b")
-    if remaining != 1:
-        return f"expected one remaining edge after two-tuple removal, got {remaining}"
-    return True
-
-
-def _probe_to_undirected_preserves_multigraph_type() -> bool | str:
-    graph = _build_probe_graph()
-    undirected = graph.to_undirected()
-    undirected_view = graph.to_undirected(as_view=True)
-    if not isinstance(undirected, nx.MultiGraph):
-        return f"to_undirected() returned {type(undirected).__name__}"
-    if not isinstance(undirected_view, nx.MultiGraph):
-        return f"to_undirected(as_view=True) returned {type(undirected_view).__name__}"
-    return True
-
-
-@lru_cache(maxsize=1)
-def probe_multigraph_capabilities() -> MultigraphCapabilityResult:
-    checks = (
-        _check("keyed_parallel_edges", _probe_keyed_parallel_edges),
-        _check("node_link_edges_links_round_trip", _probe_node_link_round_trip),
-        _check("duplicate_key_overwrite_semantics", _probe_duplicate_key_overwrite_semantics),
-        _check("reserved_key_attr_rejected", _probe_reserved_key_attr_rejected),
-        _check(
-            "remove_edges_from_two_tuple_semantics",
-            _probe_remove_edges_from_two_tuple_semantics,
-        ),
-        _check(
-            "to_undirected_preserves_multigraph_type",
-            _probe_to_undirected_preserves_multigraph_type,
-        ),
-    )
-    return MultigraphCapabilityResult(
-        python_version=(
-            f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
-        ),
-        networkx_version=nx.__version__,
-        checks=checks,
-    )
-
-
-def require_multigraph_capabilities() -> MultigraphCapabilityResult:
-    result = probe_multigraph_capabilities()
-    if not result.ok:
-        raise RuntimeError(result.error_message())
-    return result