bmad-plus 0.7.4 → 0.8.0

package/osint-agent-package/skills/bmad-osint-investigate/osint/scripts/jina.py

@@ -1,71 +1,71 @@
-#!/usr/bin/env python3
-"""Jina AI — read URLs, search, deep search. Stdlib only."""
-
-import json
-import os
-import sys
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from _http import https_request, get_key, get_workspace
-
-
-def init():
-    workspace, _, _ = get_workspace()
-    return get_key("JINA_API_KEY",
-                   file_fallback=os.path.join(workspace, "scripts", "jina-api-key.txt"),
-                   help_url="https://jina.ai/api-key")
-
-
-def read_url(token, url):
-    """URL → clean markdown."""
-    status, _, data = https_request("GET", f"https://r.jina.ai/{url}",
-                                     headers={"Authorization": f"Bearer {token}",
-                                              "Accept": "application/json"})
-    print(data[:5000])
-
-
-def search(token, query):
-    """Web search → markdown results."""
-    from urllib.parse import quote
-    status, _, data = https_request("GET", f"https://s.jina.ai/{quote(query)}",
-                                     headers={"Authorization": f"Bearer {token}",
-                                              "Accept": "application/json"})
-    print(data[:5000])
-
-
-def deepsearch(token, query):
-    """Deep research with AI reasoning."""
-    import json as j
-    status, _, data = https_request("POST", "https://deepsearch.jina.ai",
-                                     headers={"Authorization": f"Bearer {token}",
-                                              "Content-Type": "application/json",
-                                              "Accept": "application/json"},
-                                     body=j.dumps({"query": query}),
-                                     timeout=300)
-    print(data[:5000])
-
-
-def main():
-    if len(sys.argv) < 3:
-        print("Usage: jina.py read|search|deepsearch <arg>")
-        print()
-        print("  read <url>       - any URL → clean markdown")
-        print("  search <query>   - web search → markdown (10 results)")
-        print("  deepsearch <q>   - deep research with AI reasoning")
-        sys.exit(1)
-    token = init()
-    cmd = sys.argv[1]
-    arg = " ".join(sys.argv[2:])
-    if cmd == "read":
-        read_url(token, arg)
-    elif cmd == "search":
-        search(token, arg)
-    elif cmd == "deepsearch":
-        deepsearch(token, arg)
-    else:
-        print(f"Unknown: {cmd} (use read|search|deepsearch)", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""Jina AI — read URLs, search, deep search. Stdlib only."""
+
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _http import https_request, get_key, get_workspace
+
+
+def init():
+    workspace, _, _ = get_workspace()
+    return get_key("JINA_API_KEY",
+                   file_fallback=os.path.join(workspace, "scripts", "jina-api-key.txt"),
+                   help_url="https://jina.ai/api-key")
+
+
+def read_url(token, url):
+    """URL → clean markdown."""
+    status, _, data = https_request("GET", f"https://r.jina.ai/{url}",
+                                     headers={"Authorization": f"Bearer {token}",
+                                              "Accept": "application/json"})
+    print(data[:5000])
+
+
+def search(token, query):
+    """Web search → markdown results."""
+    from urllib.parse import quote
+    status, _, data = https_request("GET", f"https://s.jina.ai/{quote(query)}",
+                                     headers={"Authorization": f"Bearer {token}",
+                                              "Accept": "application/json"})
+    print(data[:5000])
+
+
+def deepsearch(token, query):
+    """Deep research with AI reasoning."""
+    import json as j
+    status, _, data = https_request("POST", "https://deepsearch.jina.ai",
+                                     headers={"Authorization": f"Bearer {token}",
+                                              "Content-Type": "application/json",
+                                              "Accept": "application/json"},
+                                     body=j.dumps({"query": query}),
+                                     timeout=300)
+    print(data[:5000])
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: jina.py read|search|deepsearch <arg>")
+        print()
+        print("  read <url>       - any URL → clean markdown")
+        print("  search <query>   - web search → markdown (10 results)")
+        print("  deepsearch <q>   - deep research with AI reasoning")
+        sys.exit(1)
+    token = init()
+    cmd = sys.argv[1]
+    arg = " ".join(sys.argv[2:])
+    if cmd == "read":
+        read_url(token, arg)
+    elif cmd == "search":
+        search(token, arg)
+    elif cmd == "deepsearch":
+        deepsearch(token, arg)
+    else:
+        print(f"Unknown: {cmd} (use read|search|deepsearch)", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/osint-agent-package/skills/bmad-osint-investigate/osint/scripts/mcp-client.py

@@ -1,136 +1,136 @@
-#!/usr/bin/env python3
-"""Lightweight MCP client for Streamable HTTP/SSE transport.
-
-Usage:
-    python3 mcp-client.py <mcp_url> --list-tools
-    python3 mcp-client.py <mcp_url> <tool_name> '<json_args>'
-"""
-
-import json
-import sys
-import http.client
-from urllib.parse import urlparse, urlencode
-
-
-def mcp_request(url: str, method: str, params: dict | None = None, 
-                req_id: int = 1, session_id: str | None = None) -> tuple[dict, str | None]:
-    """Send MCP JSON-RPC request and parse SSE response. Returns (result, session_id)."""
-    parsed = urlparse(url)
-    
-    payload = {
-        "jsonrpc": "2.0",
-        "id": req_id,
-        "method": method,
-    }
-    if params:
-        payload["params"] = params
-
-    data = json.dumps(payload).encode()
-    
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json, text/event-stream",
-    }
-    if session_id:
-        headers["Mcp-Session-Id"] = session_id
-    
-    conn = http.client.HTTPSConnection(parsed.hostname, timeout=120)
-    path = parsed.path
-    if parsed.query:
-        path += "?" + parsed.query
-    
-    conn.request("POST", path, body=data, headers=headers)
-    resp = conn.getresponse()
-    
-    # Get session ID from response headers
-    new_session_id = resp.getheader("Mcp-Session-Id") or session_id
-    
-    body = resp.read().decode()
-    conn.close()
-    
-    if resp.status >= 400:
-        return {"error": f"HTTP {resp.status}: {body[:200]}"}, new_session_id
-    
-    # Parse SSE: look for data: lines
-    for line in body.split("\n"):
-        if line.startswith("data: "):
-            try:
-                return json.loads(line[6:]), new_session_id
-            except json.JSONDecodeError:
-                continue
-
-    # Try direct JSON
-    try:
-        return json.loads(body), new_session_id
-    except json.JSONDecodeError:
-        return {"raw": body[:500]}, new_session_id
-
-
-def init_and_call(url: str, method: str, params: dict | None = None) -> dict:
-    """Initialize session then make a call."""
-    # Step 1: Initialize
-    init_result, session_id = mcp_request(url, "initialize", {
-        "protocolVersion": "2024-11-05",
-        "capabilities": {},
-        "clientInfo": {"name": "osint-skill", "version": "3.1"},
-    }, req_id=1)
-    
-    if "error" in init_result:
-        return init_result
-    
-    # Step 2: Send initialized notification (optional but polite)
-    # Step 3: Make actual call
-    result, _ = mcp_request(url, method, params, req_id=2, session_id=session_id)
-    return result
-
-
-def list_tools(url: str) -> list:
-    """List available tools on MCP server."""
-    result = init_and_call(url, "tools/list")
-    tools = result.get("result", {}).get("tools", [])
-    return tools
-
-
-def call_tool(url: str, tool_name: str, arguments: dict) -> dict:
-    """Call a specific tool on MCP server."""
-    result = init_and_call(url, "tools/call", {
-        "name": tool_name,
-        "arguments": arguments,
-    })
-    return result
-
-
-def main():
-    if len(sys.argv) < 3:
-        print(__doc__)
-        sys.exit(1)
-
-    url = sys.argv[1]
-
-    if sys.argv[2] == "--list-tools":
-        tools = list_tools(url)
-        if not tools:
-            print("No tools found or error occurred")
-            return
-        for t in tools:
-            desc = t.get("description", "")[:100]
-            print(f"  {t['name']}: {desc}")
-        return
-
-    tool_name = sys.argv[2]
-    args = json.loads(sys.argv[3]) if len(sys.argv) > 3 else {}
-
-    result = call_tool(url, tool_name, args)
-
-    # Extract content from MCP response
-    content = result.get("result", {}).get("content", [])
-    if content:
-        for item in content:
-            if item.get("type") == "text":
-                print(item["text"])
-    else:
-        print(json.dumps(result, indent=2, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""Lightweight MCP client for Streamable HTTP/SSE transport.
+
+Usage:
+    python3 mcp-client.py <mcp_url> --list-tools
+    python3 mcp-client.py <mcp_url> <tool_name> '<json_args>'
+"""
+
+import json
+import sys
+import http.client
+from urllib.parse import urlparse, urlencode
+
+
+def mcp_request(url: str, method: str, params: dict | None = None, 
+                req_id: int = 1, session_id: str | None = None) -> tuple[dict, str | None]:
+    """Send MCP JSON-RPC request and parse SSE response. Returns (result, session_id)."""
+    parsed = urlparse(url)
+    
+    payload = {
+        "jsonrpc": "2.0",
+        "id": req_id,
+        "method": method,
+    }
+    if params:
+        payload["params"] = params
+
+    data = json.dumps(payload).encode()
+    
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+    }
+    if session_id:
+        headers["Mcp-Session-Id"] = session_id
+    
+    conn = http.client.HTTPSConnection(parsed.hostname, timeout=120)
+    path = parsed.path
+    if parsed.query:
+        path += "?" + parsed.query
+    
+    conn.request("POST", path, body=data, headers=headers)
+    resp = conn.getresponse()
+    
+    # Get session ID from response headers
+    new_session_id = resp.getheader("Mcp-Session-Id") or session_id
+    
+    body = resp.read().decode()
+    conn.close()
+    
+    if resp.status >= 400:
+        return {"error": f"HTTP {resp.status}: {body[:200]}"}, new_session_id
+    
+    # Parse SSE: look for data: lines
+    for line in body.split("\n"):
+        if line.startswith("data: "):
+            try:
+                return json.loads(line[6:]), new_session_id
+            except json.JSONDecodeError:
+                continue
+
+    # Try direct JSON
+    try:
+        return json.loads(body), new_session_id
+    except json.JSONDecodeError:
+        return {"raw": body[:500]}, new_session_id
+
+
+def init_and_call(url: str, method: str, params: dict | None = None) -> dict:
+    """Initialize session then make a call."""
+    # Step 1: Initialize
+    init_result, session_id = mcp_request(url, "initialize", {
+        "protocolVersion": "2024-11-05",
+        "capabilities": {},
+        "clientInfo": {"name": "osint-skill", "version": "3.1"},
+    }, req_id=1)
+    
+    if "error" in init_result:
+        return init_result
+    
+    # Step 2: Send initialized notification (optional but polite)
+    # Step 3: Make actual call
+    result, _ = mcp_request(url, method, params, req_id=2, session_id=session_id)
+    return result
+
+
+def list_tools(url: str) -> list:
+    """List available tools on MCP server."""
+    result = init_and_call(url, "tools/list")
+    tools = result.get("result", {}).get("tools", [])
+    return tools
+
+
+def call_tool(url: str, tool_name: str, arguments: dict) -> dict:
+    """Call a specific tool on MCP server."""
+    result = init_and_call(url, "tools/call", {
+        "name": tool_name,
+        "arguments": arguments,
+    })
+    return result
+
+
+def main():
+    if len(sys.argv) < 3:
+        print(__doc__)
+        sys.exit(1)
+
+    url = sys.argv[1]
+
+    if sys.argv[2] == "--list-tools":
+        tools = list_tools(url)
+        if not tools:
+            print("No tools found or error occurred")
+            return
+        for t in tools:
+            desc = t.get("description", "")[:100]
+            print(f"  {t['name']}: {desc}")
+        return
+
+    tool_name = sys.argv[2]
+    args = json.loads(sys.argv[3]) if len(sys.argv) > 3 else {}
+
+    result = call_tool(url, tool_name, args)
+
+    # Extract content from MCP response
+    content = result.get("result", {}).get("content", [])
+    if content:
+        for item in content:
+            if item.get("type") == "text":
+                print(item["text"])
+    else:
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

package/osint-agent-package/skills/bmad-osint-investigate/osint/scripts/parallel.py

@@ -1,85 +1,85 @@
-#!/usr/bin/env python3
-"""Parallel AI — search, extract, task. Stdlib only."""
-
-import json
-import os
-import sys
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from _http import api_post, https_request, get_key, get_workspace
-
-BASE = "https://api.parallel.ai/v1beta"
-BETA_HEADER = "parallel-beta"
-BETA_VALUE = "search-extract-2025-10-10"
-
-
-def init():
-    workspace, _, _ = get_workspace()
-    return get_key("PARALLEL_API_KEY",
-                   file_fallback=os.path.join(workspace, "scripts", "parallel-api-key.txt"),
-                   help_url="https://platform.parallel.ai")
-
-
-def search(token, query):
-    """AI-powered web search with LLM-optimized excerpts."""
-    data = api_post(f"{BASE}/search", {
-        "objective": query,
-        "search_queries": [query],
-        "max_results": 10,
-        "excerpts": {"max_chars_per_result": 5000},
-    }, headers={
-        "x-api-key": token,
-        BETA_HEADER: BETA_VALUE,
-    })
-    if data:
-        print(json.dumps(data, indent=2, ensure_ascii=False)[:5000])
-
-
-def extract(token, url):
-    """URL → clean markdown (JS-heavy, PDF)."""
-    data = api_post(f"{BASE}/extract", {
-        "url": url,
-        "full_content": True,
-    }, headers={
-        "x-api-key": token,
-        BETA_HEADER: BETA_VALUE,
-    })
-    if data:
-        print(json.dumps(data, indent=2, ensure_ascii=False)[:5000])
-
-
-def task(token, task_text):
-    """Complex research task with structured output."""
-    data = api_post(f"{BASE}/task", {
-        "task": task_text,
-    }, headers={
-        "x-api-key": token,
-    })
-    if data:
-        print(json.dumps(data, indent=2, ensure_ascii=False)[:5000])
-
-
-def main():
-    if len(sys.argv) < 3:
-        print("Usage: parallel.py search|extract|task <arg>")
-        print()
-        print("  search <query>   - AI-powered web search")
-        print("  extract <url>    - URL → clean markdown")
-        print("  task <task>       - Complex research task")
-        sys.exit(1)
-    token = init()
-    cmd = sys.argv[1]
-    arg = " ".join(sys.argv[2:])
-    if cmd == "search":
-        search(token, arg)
-    elif cmd == "extract":
-        extract(token, arg)
-    elif cmd == "task":
-        task(token, arg)
-    else:
-        print(f"Unknown: {cmd} (use search|extract|task)", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""Parallel AI — search, extract, task. Stdlib only."""
+
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _http import api_post, https_request, get_key, get_workspace
+
+BASE = "https://api.parallel.ai/v1beta"
+BETA_HEADER = "parallel-beta"
+BETA_VALUE = "search-extract-2025-10-10"
+
+
+def init():
+    workspace, _, _ = get_workspace()
+    return get_key("PARALLEL_API_KEY",
+                   file_fallback=os.path.join(workspace, "scripts", "parallel-api-key.txt"),
+                   help_url="https://platform.parallel.ai")
+
+
+def search(token, query):
+    """AI-powered web search with LLM-optimized excerpts."""
+    data = api_post(f"{BASE}/search", {
+        "objective": query,
+        "search_queries": [query],
+        "max_results": 10,
+        "excerpts": {"max_chars_per_result": 5000},
+    }, headers={
+        "x-api-key": token,
+        BETA_HEADER: BETA_VALUE,
+    })
+    if data:
+        print(json.dumps(data, indent=2, ensure_ascii=False)[:5000])
+
+
+def extract(token, url):
+    """URL → clean markdown (JS-heavy, PDF)."""
+    data = api_post(f"{BASE}/extract", {
+        "url": url,
+        "full_content": True,
+    }, headers={
+        "x-api-key": token,
+        BETA_HEADER: BETA_VALUE,
+    })
+    if data:
+        print(json.dumps(data, indent=2, ensure_ascii=False)[:5000])
+
+
+def task(token, task_text):
+    """Complex research task with structured output."""
+    data = api_post(f"{BASE}/task", {
+        "task": task_text,
+    }, headers={
+        "x-api-key": token,
+    })
+    if data:
+        print(json.dumps(data, indent=2, ensure_ascii=False)[:5000])
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: parallel.py search|extract|task <arg>")
+        print()
+        print("  search <query>   - AI-powered web search")
+        print("  extract <url>    - URL → clean markdown")
+        print("  task <task>       - Complex research task")
+        sys.exit(1)
+    token = init()
+    cmd = sys.argv[1]
+    arg = " ".join(sys.argv[2:])
+    if cmd == "search":
+        search(token, arg)
+    elif cmd == "extract":
+        extract(token, arg)
+    elif cmd == "task":
+        task(token, arg)
+    else:
+        print(f"Unknown: {cmd} (use search|extract|task)", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()