trishul-mcp 0.1.0__tar.gz

trishul_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: trishul-mcp
+Version: 0.1.0
+Summary: Trishul: Deterministic repository-scale code intelligence Model Context Protocol (MCP) server.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pydantic>=2.0.0
+
+# trishul-mcp
+
+Deterministic, repository-scale semantic code intelligence Model Context Protocol (MCP) server for AI coding agents (Claude Code, Cursor, Windsurf).
+
+## Overview
+
+`trishul-mcp` connects AI coding assistants directly to a persistent, topological code intelligence graph. Instead of burning your model's context window re-reading thousands of raw files or guessing caller hierarchies with naive regex, Trishul provides deterministic answers with verified certainty:
+
+- **Callers (`get_callers`)**: Who directly or indirectly invokes a symbol?
+- **Blast Radius (`get_blast` / `get_impact`)**: What breaks upstream if this function or interface changes?
+- **Execution Paths (`get_path`)**: What is the optimal, deterministic call path between Symbol A and Symbol B?
+- **Dependency Hubs (`get_dependency_hubs`)**: What are the critical architectural bottlenecks and chokepoints?
+
+## Installation
+
+```bash
+pip install trishul-mcp
+```
+*(Or install via `pip install llmgraph-in`)*
+
+## MCP Client Configuration
+
+Add to your `claude_desktop_config.json`, Cursor MCP settings, or Windsurf configuration:
+
+```json
+{
+  "mcpServers": {
+    "trishul": {
+      "command": "trishul-mcp",
+      "env": {
+        "TRISHUL_API_KEY": "llmg_live_...",
+        "TRISHUL_API_URL": "https://api.llmgraph.in/v1"
+      }
+    }
+  }
+}
+```
+
+*Note: `LLMGRAPH_API_KEY` and `LLMGRAPH_API_URL` are also supported for backward compatibility.*
+
+## License
+
+Apache-2.0. Developed by Brainfoods Studio.

trishul_mcp-0.1.0/README.md

@@ -0,0 +1,43 @@
+# trishul-mcp
+
+Deterministic, repository-scale semantic code intelligence Model Context Protocol (MCP) server for AI coding agents (Claude Code, Cursor, Windsurf).
+
+## Overview
+
+`trishul-mcp` connects AI coding assistants directly to a persistent, topological code intelligence graph. Instead of burning your model's context window re-reading thousands of raw files or guessing caller hierarchies with naive regex, Trishul provides deterministic answers with verified certainty:
+
+- **Callers (`get_callers`)**: Who directly or indirectly invokes a symbol?
+- **Blast Radius (`get_blast` / `get_impact`)**: What breaks upstream if this function or interface changes?
+- **Execution Paths (`get_path`)**: What is the optimal, deterministic call path between Symbol A and Symbol B?
+- **Dependency Hubs (`get_dependency_hubs`)**: What are the critical architectural bottlenecks and chokepoints?
+
+## Installation
+
+```bash
+pip install trishul-mcp
+```
+*(Or install via `pip install llmgraph-in`)*
+
+## MCP Client Configuration
+
+Add to your `claude_desktop_config.json`, Cursor MCP settings, or Windsurf configuration:
+
+```json
+{
+  "mcpServers": {
+    "trishul": {
+      "command": "trishul-mcp",
+      "env": {
+        "TRISHUL_API_KEY": "llmg_live_...",
+        "TRISHUL_API_URL": "https://api.llmgraph.in/v1"
+      }
+    }
+  }
+}
+```
+
+*Note: `LLMGRAPH_API_KEY` and `LLMGRAPH_API_URL` are also supported for backward compatibility.*
+
+## License
+
+Apache-2.0. Developed by Brainfoods Studio.

trishul_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "trishul-mcp"
+version = "0.1.0"
+description = "Trishul: Deterministic repository-scale code intelligence Model Context Protocol (MCP) server."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp>=1.0.0",
+    "httpx>=0.25.0",
+    "pydantic>=2.0.0",
+]
+
+[project.scripts]
+trishul-mcp = "trishul_mcp.server:main"
+trishul = "trishul_mcp.server:main"
+llmgraph-in = "trishul_mcp.server:main"
+llmgraph-mcp = "trishul_mcp.server:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

trishul_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

trishul_mcp-0.1.0/src/llmgraph_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Backward-compatible wrapper for trishul-mcp."""
+from trishul_mcp import __version__
+from trishul_mcp import *

trishul_mcp-0.1.0/src/llmgraph_mcp/client.py

@@ -0,0 +1,2 @@
+"""Backward-compatible wrapper for trishul_mcp.client."""
+from trishul_mcp.client import *

trishul_mcp-0.1.0/src/llmgraph_mcp/config.py

@@ -0,0 +1,2 @@
+"""Backward-compatible wrapper for trishul_mcp.config."""
+from trishul_mcp.config import *

trishul_mcp-0.1.0/src/llmgraph_mcp/errors.py

@@ -0,0 +1,2 @@
+"""Backward-compatible wrapper for trishul_mcp.errors."""
+from trishul_mcp.errors import *

trishul_mcp-0.1.0/src/llmgraph_mcp/schemas.py

@@ -0,0 +1,2 @@
+"""Backward-compatible wrapper for trishul_mcp.schemas."""
+from trishul_mcp.schemas import *

trishul_mcp-0.1.0/src/llmgraph_mcp/server.py

@@ -0,0 +1,6 @@
+"""Backward-compatible wrapper for trishul_mcp.server."""
+from trishul_mcp.server import *
+from trishul_mcp.server import main
+
+if __name__ == "__main__":
+    main()

trishul_mcp-0.1.0/src/trishul_mcp/__init__.py

@@ -0,0 +1,2 @@
+"""trishul-mcp: Deterministic repository-scale code intelligence MCP server."""
+__version__ = "0.1.0"

trishul_mcp-0.1.0/src/trishul_mcp/client.py

@@ -0,0 +1,145 @@
+"""Remote HTTP client for communicating with the Trishul / LLMGRAPH hosted API."""
+from typing import Any
+import httpx
+
+from .config import ClientConfig, config
+from .errors import (
+    AuthenticationError,
+    AuthorizationError,
+    TrishulClientError,
+    RateLimitError,
+    ResourceNotFoundError,
+    ServerError,
+)
+
+class TrishulRemoteClient:
+    """Lightweight HTTP client communicating with the remote code intelligence service."""
+
+    def __init__(self, client_config: ClientConfig | None = None):
+        self.cfg = client_config or config
+        self._headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "trishul-mcp/0.1.0",
+            "X-LLMGraph-Client": "mcp",
+        }
+        if self.cfg.api_key:
+            self._headers["Authorization"] = f"Bearer {self.cfg.api_key}"
+
+    def _handle_response(self, response: httpx.Response) -> dict[str, Any]:
+        if response.status_code == 200:
+            return response.json()
+        elif response.status_code == 401:
+            raise AuthenticationError("AUTH_REQUIRED", "API key (TRISHUL_API_KEY / LLMGRAPH_API_KEY) missing, invalid, or revoked.")
+        elif response.status_code == 403:
+            raise AuthorizationError("FORBIDDEN", "Access denied for this repository.")
+        elif response.status_code == 404:
+            raise ResourceNotFoundError("NOT_FOUND", "Requested repository or symbol not found.")
+        elif response.status_code == 429:
+            err_data = response.json() if response.content else {}
+            msg = err_data.get("error", {}).get("message", "Request quota or rate limit exceeded.")
+            code = err_data.get("error", {}).get("code", "RATE_LIMITED")
+            raise RateLimitError(code, msg)
+        else:
+            try:
+                err_data = response.json()
+                msg = err_data.get("error", {}).get("message", f"Remote error ({response.status_code})")
+                code = err_data.get("error", {}).get("code", "SERVER_ERROR")
+                raise ServerError(code, msg)
+            except Exception as e:
+                if isinstance(e, ServerError):
+                    raise
+                raise ServerError("SERVER_ERROR", f"Remote error (status {response.status_code})")
+
+    # --- Repository Lifecycle Operations ---
+
+    def connect_repository(self, repo_url: str) -> dict[str, Any]:
+        """Connects a repository using locally configured Git credentials without model visibility."""
+        url = f"{self.cfg.api_url}/repositories/connect"
+        payload = {"repository_url": repo_url, "git_credential": self.cfg.github_token}
+        with httpx.Client(timeout=180.0) as client:
+            resp = client.post(url, json=payload, headers=self._headers)
+            return self._handle_response(resp)
+
+    def sync_repository(self, repo_id: str) -> dict[str, Any]:
+        """Syncs an existing repository incrementally using local credentials."""
+        url = f"{self.cfg.api_url}/repositories/sync"
+        payload = {"repository_id": repo_id, "git_credential": self.cfg.github_token}
+        with httpx.Client(timeout=180.0) as client:
+            resp = client.post(url, json=payload, headers=self._headers)
+            return self._handle_response(resp)
+
+    def repository_status(self, repo_id: str) -> dict[str, Any]:
+        """Checks status of an indexed repository."""
+        url = f"{self.cfg.api_url}/repositories/status"
+        payload = {"repository_id": repo_id}
+        with httpx.Client(timeout=self.cfg.timeout_sec) as client:
+            resp = client.post(url, json=payload, headers=self._headers)
+            return self._handle_response(resp)
+
+    def list_repositories(self) -> dict[str, Any]:
+        """Lists all indexed repositories owned by the API key."""
+        url = f"{self.cfg.api_url}/repositories/list"
+        with httpx.Client(timeout=self.cfg.timeout_sec) as client:
+            resp = client.get(url, headers=self._headers)
+            return self._handle_response(resp)
+
+    def delete_repository(self, repo_id: str) -> dict[str, Any]:
+        """Deletes a repository and releases quota."""
+        url = f"{self.cfg.api_url}/repositories/delete"
+        payload = {"repository_id": repo_id}
+        with httpx.Client(timeout=self.cfg.timeout_sec) as client:
+            resp = client.post(url, json=payload, headers=self._headers)
+            return self._handle_response(resp)
+
+    # --- Semantic Traversal Queries ---
+
+    def search_symbols(self, repo_id: str, query: str, limit: int = 10) -> dict[str, Any]:
+        url = f"{self.cfg.api_url}/symbols/search"
+        payload = {"repository_id": repo_id, "query": query, "limit": limit}
+        with httpx.Client(timeout=self.cfg.timeout_sec) as client:
+            resp = client.post(url, json=payload, headers=self._headers)
+            return self._handle_response(resp)
+
+    def get_callers(self, repo_id: str, symbol: str, min_confidence: float | None = None) -> dict[str, Any]:
+        url = f"{self.cfg.api_url}/callers"
+        payload = {"repository_id": repo_id, "symbol": symbol}
+        if min_confidence is not None:
+            payload["min_confidence"] = min_confidence
+        with httpx.Client(timeout=self.cfg.timeout_sec) as client:
+            resp = client.post(url, json=payload, headers=self._headers)
+            return self._handle_response(resp)
+
+    def get_impact(self, repo_id: str, symbol: str, depth: int = 3, min_confidence: float | None = None) -> dict[str, Any]:
+        url = f"{self.cfg.api_url}/impact"
+        payload = {"repository_id": repo_id, "symbol": symbol, "depth": depth}
+        if min_confidence is not None:
+            payload["min_confidence"] = min_confidence
+        with httpx.Client(timeout=self.cfg.timeout_sec) as client:
+            resp = client.post(url, json=payload, headers=self._headers)
+            return self._handle_response(resp)
+
+    def get_blast(self, repo_id: str, symbol: str, depth: int = 3, min_confidence: float | None = None) -> dict[str, Any]:
+        url = f"{self.cfg.api_url}/blast"
+        payload = {"repository_id": repo_id, "symbol": symbol, "depth": depth}
+        if min_confidence is not None:
+            payload["min_confidence"] = min_confidence
+        with httpx.Client(timeout=self.cfg.timeout_sec) as client:
+            resp = client.post(url, json=payload, headers=self._headers)
+            return self._handle_response(resp)
+
+    def get_path(self, repo_id: str, source: str, target: str) -> dict[str, Any]:
+        url = f"{self.cfg.api_url}/path"
+        payload = {"repository_id": repo_id, "source": source, "target": target}
+        with httpx.Client(timeout=self.cfg.timeout_sec) as client:
+            resp = client.post(url, json=payload, headers=self._headers)
+            return self._handle_response(resp)
+
+    def get_dependency_hubs(self, repo_id: str, source: str, target: str) -> dict[str, Any]:
+        url = f"{self.cfg.api_url}/chokepoints"
+        payload = {"repository_id": repo_id, "source": source, "target": target}
+        with httpx.Client(timeout=self.cfg.timeout_sec) as client:
+            resp = client.post(url, json=payload, headers=self._headers)
+            return self._handle_response(resp)
+
+# Backward-compatible alias
+LLMGraphRemoteClient = TrishulRemoteClient

trishul_mcp-0.1.0/src/trishul_mcp/config.py

@@ -0,0 +1,14 @@
+"""Client configuration and environment variable bindings for Trishul / LLMGraph MCP."""
+import os
+from dataclasses import dataclass
+
+@dataclass
+class ClientConfig:
+    # Primary: TRISHUL_*, Fallback: LLMGRAPH_*
+    api_url: str = os.getenv("TRISHUL_API_URL") or os.getenv("LLMGRAPH_API_URL") or "https://api.llmgraph.in/v1"
+    api_key: str | None = os.getenv("TRISHUL_API_KEY") or os.getenv("LLMGRAPH_API_KEY")
+    github_token: str | None = os.getenv("TRISHUL_GITHUB_TOKEN") or os.getenv("LLMGRAPH_GITHUB_TOKEN")
+    timeout_sec: float = float(os.getenv("TRISHUL_TIMEOUT_SEC") or os.getenv("LLMGRAPH_TIMEOUT_SEC") or "30.0")
+    max_retries: int = int(os.getenv("TRISHUL_MAX_RETRIES") or os.getenv("LLMGRAPH_MAX_RETRIES") or "3")
+
+config = ClientConfig()

trishul_mcp-0.1.0/src/trishul_mcp/errors.py

@@ -0,0 +1,28 @@
+"""Standard public error types for the remote Trishul / LLMGRAPH MCP client."""
+from typing import Any
+
+class TrishulClientError(Exception):
+    """Base exception for Trishul MCP client errors."""
+    def __init__(self, code: str, message: str, details: dict[str, Any] | None = None):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.details = details or {}
+
+# Backward-compatible alias
+LLMGraphClientError = TrishulClientError
+
+class AuthenticationError(TrishulClientError):
+    """Raised when the API key is missing, invalid, or expired."""
+
+class AuthorizationError(TrishulClientError):
+    """Raised when the account lacks permissions for the requested repository."""
+
+class ResourceNotFoundError(TrishulClientError):
+    """Raised when a symbol, file, or repository is not found."""
+
+class RateLimitError(TrishulClientError):
+    """Raised when the request quota or rate limit is exceeded."""
+
+class ServerError(TrishulClientError):
+    """Raised when the remote service encounters an error."""

trishul_mcp-0.1.0/src/trishul_mcp/schemas.py

@@ -0,0 +1,56 @@
+"""Public request and response schemas for Trishul / LLMGRAPH API endpoints."""
+from typing import Any
+from pydantic import BaseModel, Field
+
+class SymbolMatch(BaseModel):
+    symbol_id: str
+    name: str
+    qualified_name: str
+    kind: str
+    file_path: str
+    line: int
+
+class SearchResponse(BaseModel):
+    matches: list[SymbolMatch] = Field(default_factory=list)
+    did_you_mean: list[str] = Field(default_factory=list)
+
+class AffectedCaller(BaseModel):
+    symbol_id: str
+    qualified_name: str
+    file_path: str
+    line: int
+    distance: int
+    path_confidence: float
+    confidence_tier: str
+    call_path: str
+
+class BlastResponse(BaseModel):
+    root_symbol: SymbolMatch
+    total_affected_count: int
+    affected_callers: list[AffectedCaller] = Field(default_factory=list)
+
+class PathNode(BaseModel):
+    qualified_name: str
+    file_path: str
+    line: int
+
+class PathResponse(BaseModel):
+    source: str
+    target: str
+    hops: int
+    cumulative_confidence: float
+    weakest_link_tier: str
+    path_nodes: list[PathNode] = Field(default_factory=list)
+    path_display: str
+
+class ChokepointSymbol(BaseModel):
+    symbol_id: str
+    qualified_name: str
+    file_path: str
+    line: int
+    is_mandatory_bottleneck: bool = True
+
+class ChokepointsResponse(BaseModel):
+    source: str
+    target: str
+    chokepoints: list[ChokepointSymbol] = Field(default_factory=list)

trishul_mcp-0.1.0/src/trishul_mcp/server.py

@@ -0,0 +1,97 @@
+"""FastMCP server entry point for Trishul MCP server."""
+import json
+import sys
+from typing import Any
+try:
+    from mcp.server.fastmcp import FastMCP
+except (ImportError, ModuleNotFoundError):
+    from mcp.server.mcpserver import MCPServer as FastMCP
+
+from .client import TrishulRemoteClient
+from .config import config
+from .errors import TrishulClientError
+
+mcp = FastMCP("trishul")
+remote_client = TrishulRemoteClient(config)
+
+def _safe_call(fn, *args, **kwargs) -> str:
+    try:
+        res = fn(*args, **kwargs)
+        return json.dumps(res, indent=2)
+    except TrishulClientError as e:
+        return json.dumps({"status": "error", "error": {"code": e.code, "message": e.message, "details": e.details}}, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "error": {"code": "CLIENT_ERROR", "message": "Failed to communicate with Trishul code intelligence service."}}, indent=2)
+
+# --- Repository Lifecycle Tools ---
+
+@mcp.tool()
+def connect_repository(repository_url: str) -> str:
+    """Connect and index a GitHub repository using hosted static code intelligence.
+    Credentials (if any) are loaded automatically from the local MCP environment.
+    Returns an opaque repository_id to use for all subsequent graph queries."""
+    return _safe_call(remote_client.connect_repository, repo_url=repository_url)
+
+@mcp.tool()
+def sync_repository(repository_id: str) -> str:
+    """Incrementally re-sync an existing repository to ingest latest code changes.
+    Maintains stable symbol identities and updates call relationships."""
+    return _safe_call(remote_client.sync_repository, repo_id=repository_id)
+
+@mcp.tool()
+def repository_status(repository_id: str) -> str:
+    """Check the status, symbol count, edge count, and last sync timestamp for a repository."""
+    return _safe_call(remote_client.repository_status, repo_id=repository_id)
+
+@mcp.tool()
+def list_repositories() -> str:
+    """List all indexed repositories owned by your API key with their status and symbol counts."""
+    return _safe_call(remote_client.list_repositories)
+
+@mcp.tool()
+def delete_repository(repository_id: str) -> str:
+    """Delete an indexed repository graph and release repository quota."""
+    return _safe_call(remote_client.delete_repository, repo_id=repository_id)
+
+# --- Semantic Traversal Query Tools ---
+
+@mcp.tool()
+def search_symbols(repository_id: str, query: str, limit: int = 10) -> str:
+    """Search for code symbols across the indexed repository graph by name or qualified identifier."""
+    return _safe_call(remote_client.search_symbols, repo_id=repository_id, query=query, limit=limit)
+
+@mcp.tool()
+def get_callers(repository_id: str, symbol: str, min_confidence: float | None = None) -> str:
+    """Get direct callers of a specific symbol with certainty tiers and relationship classifications."""
+    return _safe_call(remote_client.get_callers, repo_id=repository_id, symbol=symbol, min_confidence=min_confidence)
+
+@mcp.tool()
+def get_impact(repository_id: str, symbol: str, depth: int = 3, min_confidence: float | None = None) -> str:
+    """Compute the reverse change impact of all upstream callers affected if a target symbol changes."""
+    return _safe_call(remote_client.get_impact, repo_id=repository_id, symbol=symbol, depth=depth, min_confidence=min_confidence)
+
+@mcp.tool()
+def get_blast(repository_id: str, symbol: str, depth: int = 3, min_confidence: float | None = None) -> str:
+    """Compute the reverse blast radius of all upstream callers affected if a target symbol changes."""
+    return _safe_call(remote_client.get_blast, repo_id=repository_id, symbol=symbol, depth=depth, min_confidence=min_confidence)
+
+@mcp.tool()
+def get_path(repository_id: str, source: str, target: str) -> str:
+    """Find the single optimal execution path between two symbols using weighted certainty routing."""
+    return _safe_call(remote_client.get_path, repo_id=repository_id, source=source, target=target)
+
+@mcp.tool()
+def get_dependency_hubs(repository_id: str, source: str, target: str) -> str:
+    """Find critical dependency junction symbols between source and target."""
+    return _safe_call(remote_client.get_dependency_hubs, repo_id=repository_id, source=source, target=target)
+
+def main():
+    transport = "stdio"
+    if "--transport" in sys.argv:
+        idx = sys.argv.index("--transport")
+        if idx + 1 < len(sys.argv):
+            transport = sys.argv[idx + 1]
+    mcp.run(transport=transport)
+
+if __name__ == "__main__":
+    main()

trishul_mcp-0.1.0/src/trishul_mcp.egg-info/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: trishul-mcp
+Version: 0.1.0
+Summary: Trishul: Deterministic repository-scale code intelligence Model Context Protocol (MCP) server.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pydantic>=2.0.0
+
+# trishul-mcp
+
+Deterministic, repository-scale semantic code intelligence Model Context Protocol (MCP) server for AI coding agents (Claude Code, Cursor, Windsurf).
+
+## Overview
+
+`trishul-mcp` connects AI coding assistants directly to a persistent, topological code intelligence graph. Instead of burning your model's context window re-reading thousands of raw files or guessing caller hierarchies with naive regex, Trishul provides deterministic answers with verified certainty:
+
+- **Callers (`get_callers`)**: Who directly or indirectly invokes a symbol?
+- **Blast Radius (`get_blast` / `get_impact`)**: What breaks upstream if this function or interface changes?
+- **Execution Paths (`get_path`)**: What is the optimal, deterministic call path between Symbol A and Symbol B?
+- **Dependency Hubs (`get_dependency_hubs`)**: What are the critical architectural bottlenecks and chokepoints?
+
+## Installation
+
+```bash
+pip install trishul-mcp
+```
+*(Or install via `pip install llmgraph-in`)*
+
+## MCP Client Configuration
+
+Add to your `claude_desktop_config.json`, Cursor MCP settings, or Windsurf configuration:
+
+```json
+{
+  "mcpServers": {
+    "trishul": {
+      "command": "trishul-mcp",
+      "env": {
+        "TRISHUL_API_KEY": "llmg_live_...",
+        "TRISHUL_API_URL": "https://api.llmgraph.in/v1"
+      }
+    }
+  }
+}
+```
+
+*Note: `LLMGRAPH_API_KEY` and `LLMGRAPH_API_URL` are also supported for backward compatibility.*
+
+## License
+
+Apache-2.0. Developed by Brainfoods Studio.

trishul_mcp-0.1.0/src/trishul_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.md
+pyproject.toml
+src/llmgraph_mcp/__init__.py
+src/llmgraph_mcp/client.py
+src/llmgraph_mcp/config.py
+src/llmgraph_mcp/errors.py
+src/llmgraph_mcp/schemas.py
+src/llmgraph_mcp/server.py
+src/trishul_mcp/__init__.py
+src/trishul_mcp/client.py
+src/trishul_mcp/config.py
+src/trishul_mcp/errors.py
+src/trishul_mcp/schemas.py
+src/trishul_mcp/server.py
+src/trishul_mcp.egg-info/PKG-INFO
+src/trishul_mcp.egg-info/SOURCES.txt
+src/trishul_mcp.egg-info/dependency_links.txt
+src/trishul_mcp.egg-info/entry_points.txt
+src/trishul_mcp.egg-info/requires.txt
+src/trishul_mcp.egg-info/top_level.txt
+tests/test_package_boundary.py

trishul_mcp-0.1.0/src/trishul_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

trishul_mcp-0.1.0/src/trishul_mcp.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+llmgraph-in = trishul_mcp.server:main
+llmgraph-mcp = trishul_mcp.server:main
+trishul = trishul_mcp.server:main
+trishul-mcp = trishul_mcp.server:main

trishul_mcp-0.1.0/src/trishul_mcp.egg-info/requires.txt

@@ -0,0 +1,3 @@
+mcp>=1.0.0
+httpx>=0.25.0
+pydantic>=2.0.0

trishul_mcp-0.1.0/src/trishul_mcp.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+llmgraph_mcp
+trishul_mcp

trishul_mcp-0.1.0/tests/test_package_boundary.py

@@ -0,0 +1,74 @@
+"""Crown-jewel leakage and package boundary verification tests for llmgraph-mcp."""
+from pathlib import Path
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+PROHIBITED_TERMS = [
+    "CallResolver",
+    "ResolutionEvidence",
+    "SELF_METHOD_UNIQUE",
+    "SUPER_MRO_EXACT",
+    "POLYMORPHIC_RECEIVER_SET",
+    "STATIC_RECEIVER_TYPE_EXACT",
+    "blast_symbol_id",
+    "find_shortest_path",
+    "find_top_k_paths",
+    "find_chokepoints",
+    "graph.py",
+    "docs/private",
+    "validation/",
+]
+
+def test_package_contains_no_crown_jewel_terms():
+    """Verifies that no file in the distributable client package references proprietary engine internals."""
+    leaks = []
+    scanned_files = 0
+
+    for path in REPO_ROOT.rglob("*"):
+        if path.is_file() and not any(p in path.parts for p in [".git", ".pytest_cache", "__pycache__", ".venv"]):
+            scanned_files += 1
+            text = path.read_text(encoding="utf-8", errors="replace")
+            # Exclude this test file itself from term search
+            if path.name == "test_package_boundary.py":
+                continue
+            for term in PROHIBITED_TERMS:
+                if term in text:
+                    leaks.append(f"Leakage detected in {path.relative_to(REPO_ROOT)}: contains '{term}'")
+
+    assert scanned_files > 0, "No files scanned."
+    assert not leaks, f"Crown-jewel leakage detected:\n" + "\n".join(leaks)
+
+def test_pyproject_contains_no_internal_dependencies():
+    """Verifies that pyproject.toml does not depend on internal proprietary packages or Oroboros."""
+    pyproject = REPO_ROOT / "pyproject.toml"
+    assert pyproject.exists()
+    content = pyproject.read_text(encoding="utf-8")
+    assert "oroboros" not in content.lower(), "pyproject.toml directly references Oroboros repository."
+    assert "graph" not in content.lower() or "llmgraph" in content.lower(), "Unsanitized internal dependency in pyproject.toml"
+
+def test_client_imports_are_pure_http():
+    """Verifies that client files only import safe standard HTTP libraries."""
+    import sys
+    sys.path.insert(0, str(REPO_ROOT / "src"))
+    from trishul_mcp import client as t_client, server as t_server
+    from llmgraph_mcp import client, config, errors, schemas, server
+    assert hasattr(t_server, "connect_repository")
+    assert hasattr(t_server, "search_symbols")
+    assert hasattr(t_server, "get_callers")
+    assert hasattr(t_server, "get_impact")
+    assert hasattr(t_server, "get_blast")
+    assert hasattr(t_server, "get_path")
+    assert hasattr(t_server, "get_dependency_hubs")
+    assert hasattr(t_client, "TrishulRemoteClient")
+    assert hasattr(server, "connect_repository")
+    assert hasattr(server, "search_symbols")
+    assert hasattr(server, "get_callers")
+    assert hasattr(server, "get_impact")
+    assert hasattr(server, "get_blast")
+    assert hasattr(server, "get_path")
+    assert hasattr(server, "get_dependency_hubs")
+    assert hasattr(client, "LLMGraphRemoteClient")
+    assert hasattr(client.LLMGraphRemoteClient, "get_impact")
+    assert hasattr(client.LLMGraphRemoteClient, "get_dependency_hubs")
+    assert hasattr(client.LLMGraphRemoteClient, "get_blast")