@heretek-ai/epistemic-swarm 0.2.2 → 0.3.0

package/config/mcp_launcher.py

@@ -36,144 +36,55 @@ def run_zero_key_mcp_server(service: str):
     """Run lightweight JSON-RPC MCP server handling search and fetch without API keys."""
     from skills.epistemic_search.scripts.search import search_duckduckgo
     from skills.epistemic_search.scripts.fetch import fetch_and_cache
+    from runner.mcp_protocol import StdioJsonRpcServer, ToolSpec
 
-    def send_response(response: Dict[str, Any]):
-        out = json.dumps(response)
-        sys.stdout.write(f"Content-Length: {len(out)}\r\n\r\n{out}")
-        sys.stdout.flush()
-
-    def send_json(response: Dict[str, Any]):
-        # Direct newline JSON-RPC for stdio transports
-        sys.stdout.write(json.dumps(response) + "\n")
-        sys.stdout.flush()
-
-    while True:
-        try:
-            line = sys.stdin.readline()
-            if not line:
-                break
-            line = line.strip()
-            if not line:
-                continue
-
-            # Check if line is Content-Length header or raw JSON
-            if line.startswith("Content-Length:"):
-                length = int(line.split(":")[1].strip())
-                # Read blank line
-                sys.stdin.readline()
-                body = sys.stdin.read(length)
-                req = json.loads(body)
-                use_headers = True
-            else:
-                req = json.loads(line)
-                use_headers = False
-
-            req_id = req.get("id")
-            method = req.get("method")
-            params = req.get("params", {})
-
-            if method == "initialize":
-                res = {
-                    "jsonrpc": "2.0",
-                    "id": req_id,
-                    "result": {
-                        "protocolVersion": "2024-11-05",
-                        "serverInfo": {
-                            "name": f"epistemic-{service}-fallback",
-                            "version": "0.2.1"
-                        },
-                        "capabilities": {
-                            "tools": {}
-                        }
-                    }
-                }
-            elif method == "tools/list":
-                if service == "brave-search":
-                    tools = [
-                        {
-                            "name": "brave_web_search",
-                            "description": "Web search with DuckDuckGo fallback (zero API key required). Returns verifiable search results with titles, URLs, and snippets.",
-                            "inputSchema": {
-                                "type": "object",
-                                "properties": {
-                                    "query": {"type": "string", "description": "The search query terms"},
-                                    "count": {"type": "number", "description": "Number of results (1-20)", "default": 10}
-                                },
-                                "required": ["query"]
-                            }
-                        }
-                    ]
-                elif service == "firecrawl":
-                    tools = [
-                        {
-                            "name": "firecrawl_scrape",
-                            "description": "Scrape and extract clean markdown with automatic content-addressed SHA-256 caching into .research/sources/.",
-                            "inputSchema": {
-                                "type": "object",
-                                "properties": {
-                                    "url": {"type": "string", "description": "URL to scrape and cache"}
-                                },
-                                "required": ["url"]
-                            }
-                        }
-                    ]
-                else:
-                    tools = []
-
-                res = {
-                    "jsonrpc": "2.0",
-                    "id": req_id,
-                    "result": {"tools": tools}
-                }
-            elif method == "tools/call":
-                tool_name = params.get("name")
-                args = params.get("arguments", {})
-
-                if tool_name in ("brave_web_search", "search"):
-                    q = args.get("query", "")
-                    count = args.get("count", 10)
-                    results = search_duckduckgo(query=q, max_results=count)
-                    text_out = json.dumps(results, indent=2)
-                    res = {
-                        "jsonrpc": "2.0",
-                        "id": req_id,
-                        "result": {
-                            "content": [{"type": "text", "text": text_out}]
-                        }
-                    }
-                elif tool_name in ("firecrawl_scrape", "scrape", "fetch"):
-                    target_url = args.get("url", "")
-                    content = fetch_and_cache(url=target_url)
-                    res = {
-                        "jsonrpc": "2.0",
-                        "id": req_id,
-                        "result": {
-                            "content": [{"type": "text", "text": content}]
-                        }
-                    }
-                else:
-                    res = {
-                        "jsonrpc": "2.0",
-                        "id": req_id,
-                        "error": {"code": -32601, "message": f"Tool {tool_name} not found"}
-                    }
-            elif method == "notifications/initialized":
-                continue
-            else:
-                res = {
-                    "jsonrpc": "2.0",
-                    "id": req_id,
-                    "error": {"code": -32601, "message": f"Method {method} not handled"}
-                }
-
-            if use_headers:
-                send_response(res)
-            else:
-                send_json(res)
-
-        except Exception as e:
-            sys.stderr.write(f"[mcp-launcher] Error handling request: {e}\n")
-            break
+    tools = []
+    if service == "brave-search":
+        def handle_brave_search(args: Dict[str, Any]) -> str:
+            results = search_duckduckgo(
+                query=args.get("query", ""), max_results=args.get("count", 10)
+            )
+            return json.dumps(results, indent=2)
+
+        tools.append(ToolSpec(
+            name="brave_web_search",
+            description="Web search with DuckDuckGo fallback (zero API key required). Returns verifiable search results with titles, URLs, and snippets.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "The search query terms"},
+                    "count": {"type": "number", "description": "Number of results (1-20)", "default": 10},
+                },
+                "required": ["query"],
+            },
+            handler=handle_brave_search,
+            aliases=("search",),
+        ))
+    elif service == "firecrawl":
+        def handle_firecrawl_scrape(args: Dict[str, Any]) -> str:
+            return fetch_and_cache(url=args.get("url", ""))
+
+        tools.append(ToolSpec(
+            name="firecrawl_scrape",
+            description="Scrape and extract clean markdown with automatic content-addressed SHA-256 caching into .research/sources/.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "url": {"type": "string", "description": "URL to scrape and cache"},
+                },
+                "required": ["url"],
+            },
+            handler=handle_firecrawl_scrape,
+            aliases=("scrape", "fetch"),
+        ))
+
+    server = StdioJsonRpcServer(
+        server_name=f"epistemic-{service}-fallback",
+        version="0.2.1",
+        tools=tools,
+        log_prefix="[mcp-launcher]",
+    )
+    server.serve_forever()
 
 def main():
     service = sys.argv[1] if len(sys.argv) > 1 else "brave-search"

package/config/opencode-snippet.json

@@ -1,9 +1,45 @@
 {
   "$schema": "https://opencode.ai/config.json",
+  "mcp": {
+    "iumbtems": {
+      "type": "local",
+      "command": ["python3", "<IUMBTEMS_ROOT>/runner/mcp_server.py"],
+      "enabled": true
+    }
+  },
   "plugin": [
-    "@heretek-ai/epistemic-swarm"
+    [
+      "@heretek-ai/epistemic-swarm",
+      {
+        "search_engine": "duckduckgo",
+        "max_iterations": 2,
+        "mode": "research"
+      }
+    ]
   ],
   "agent": {
+    "code-auditor": {
+      "description": "IUMBTEMS Codebase Auditor: Dialectic architecture mapping and vulnerability red-teaming with line-level proof.",
+      "tools": {
+        "read": true,
+        "write": true,
+        "grep": true,
+        "glob": true,
+        "iumbtems_code_audit": true,
+        "iumbtems_config": true
+      }
+    },
+    "oss-scout": {
+      "description": "IUMBTEMS Open Source Scout: Discovers mature OSS packages, audits copyleft licensing, and generates clean-room blueprints.",
+      "tools": {
+        "read": true,
+        "write": true,
+        "grep": true,
+        "glob": true,
+        "iumbtems_oss_scout": true,
+        "iumbtems_config": true
+      }
+    },
     "alpha-thesis": {
       "description": "IUMBTEMS Proponent Agent: Gathers corroborating primary sources, benchmark results, and empirical proofs.",
       "tools": {
@@ -13,7 +49,9 @@
         "grep": true,
         "glob": true,
         "task": true,
-        "iumbtems_verify_quote": true
+        "iumbtems_swarm_research": true,
+        "iumbtems_verify_quote": true,
+        "iumbtems_config": true
       }
     },
     "beta-redteam": {
@@ -25,6 +63,7 @@
         "grep": true,
         "glob": true,
         "task": true,
+        "iumbtems_swarm_research": true,
         "iumbtems_verify_quote": true
       }
     },
@@ -37,12 +76,28 @@
         "glob": true,
         "iumbtems_verify_quote": true
       }
+    },
+    "brainstormer": {
+      "description": "IUMBTEMS Lateral Brainstormer: divergent what-if features, paradigm inversions, falsifiable spikes (never bug fixes).",
+      "tools": {
+        "read": true,
+        "write": true,
+        "grep": true,
+        "glob": true,
+        "iumbtems_brainstorm": true,
+        "iumbtems_config": true
+      }
     }
   },
   "skills": {
     "paths": [
       "./skills/grilling",
-      "./skills/research-cache"
+      "./skills/research_cache",
+      "./skills/epistemic_search",
+      "./skills/swarm_config",
+      "./skills/code_audit",
+      "./skills/oss_scout",
+      "./skills/brainstorming"
     ]
   }
 }

package/config/searxng_mcp.py

@@ -11,6 +11,15 @@ import urllib.request
 import urllib.parse
 from typing import Dict, Any, List
 
+# Add parent dir to path so the shared protocol module resolves when this
+# script is launched directly as `python3 config/searxng_mcp.py`.
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from runner.mcp_protocol import StdioJsonRpcServer, ToolSpec  # noqa: E402
+
 SEARXNG_URL = os.environ.get("SEARXNG_URL", "http://localhost:8080")
 
 def search_searxng(query: str, categories: str = "general", max_results: int = 10) -> List[Dict[str, Any]]:
@@ -23,7 +32,7 @@ def search_searxng(query: str, categories: str = "general", max_results: int = 1
     }
     url = f"{SEARXNG_URL.rstrip('/')}/search?{urllib.parse.urlencode(params)}"
     req = urllib.request.Request(url, headers={"User-Agent": "EpistemicSwarm/1.0"})
-    
+
     try:
         with urllib.request.urlopen(req, timeout=10) as resp:
             data = json.loads(resp.read().decode("utf-8"))
@@ -41,93 +50,43 @@ def search_searxng(query: str, categories: str = "general", max_results: int = 1
         return [{"error": f"Failed to query SearXNG at {SEARXNG_URL}: {str(e)}"}]
 
 
-def handle_json_rpc(line: str):
-    """Minimal JSON-RPC 2.0 loop for MCP protocol."""
-    try:
-        msg = json.loads(line)
-    except Exception:
-        return
-
-    msg_id = msg.get("id")
-    method = msg.get("method")
+def build_server() -> StdioJsonRpcServer:
+    def handle_searxng_search(args: Dict[str, Any]) -> str:
+        res = search_searxng(
+            query=args.get("query", ""),
+            categories=args.get("categories", "general"),
+            max_results=args.get("max_results", 10),
+        )
+        return json.dumps(res, indent=2)
 
-    if method == "initialize":
-        response = {
-            "jsonrpc": "2.0",
-            "id": msg_id,
-            "result": {
-                "protocolVersion": "2024-11-05",
-                "capabilities": {
-                    "tools": {}
+    return StdioJsonRpcServer(
+        server_name="searxng-mcp",
+        version="1.0.0",
+        tools=[
+            ToolSpec(
+                name="searxng_search",
+                description="Execute an unbiased multi-engine metasearch via SearXNG.",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "query": {"type": "string", "description": "Search query"},
+                        "categories": {
+                            "type": "string",
+                            "description": "Categories (general, science, it)",
+                            "default": "general"
+                        },
+                        "max_results": {"type": "integer", "default": 10}
+                    },
+                    "required": ["query"]
                 },
-                "serverInfo": {
-                    "name": "searxng-mcp",
-                    "version": "1.0.0"
-                }
-            }
-        }
-        sys.stdout.write(json.dumps(response) + "\n")
-        sys.stdout.flush()
-
-    elif method == "tools/list":
-        response = {
-            "jsonrpc": "2.0",
-            "id": msg_id,
-            "result": {
-                "tools": [
-                    {
-                        "name": "searxng_search",
-                        "description": "Execute an unbiased multi-engine metasearch via SearXNG.",
-                        "inputSchema": {
-                            "type": "object",
-                            "properties": {
-                                "query": {"type": "string", "description": "Search query"},
-                                "categories": {
-                                    "type": "string",
-                                    "description": "Categories (general, science, it)",
-                                    "default": "general"
-                                },
-                                "max_results": {"type": "integer", "default": 10}
-                            },
-                            "required": ["query"]
-                        }
-                    }
-                ]
-            }
-        }
-        sys.stdout.write(json.dumps(response) + "\n")
-        sys.stdout.flush()
-
-    elif method == "tools/call":
-        params = msg.get("params", {})
-        tool_name = params.get("name")
-        args = params.get("arguments", {})
-
-        if tool_name == "searxng_search":
-            query = args.get("query", "")
-            cat = args.get("categories", "general")
-            limit = args.get("max_results", 10)
-            res = search_searxng(query, categories=cat, max_results=limit)
-            response = {
-                "jsonrpc": "2.0",
-                "id": msg_id,
-                "result": {
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": json.dumps(res, indent=2)
-                        }
-                    ]
-                }
-            }
-            sys.stdout.write(json.dumps(response) + "\n")
-            sys.stdout.flush()
+                handler=handle_searxng_search,
+            )
+        ],
+    )
 
 
 def main():
-    for line in sys.stdin:
-        if line.strip():
-            handle_json_rpc(line.strip())
+    build_server().serve_forever()
 
 if __name__ == "__main__":
     main()