bmad-plus 0.1.0

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

@@ -0,0 +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()

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

@@ -0,0 +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()

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

@@ -0,0 +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()

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

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Perplexity API — search + sonar + deep research. Stdlib only."""
+
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _http import api_post, get_key, truncate
+
+API_KEY = None
+
+
+def init():
+    global API_KEY
+    API_KEY = get_key("PERPLEXITY_API_KEY", help_url="https://perplexity.ai/settings/api")
+
+
+def search(query):
+    """Search API — ranked web results."""
+    data = api_post("https://api.perplexity.ai/search",
+                     {"query": [query]},
+                     headers={"Authorization": f"Bearer {API_KEY}"})
+    if not data:
+        return
+    if "results" in data:
+        for r in data["results"][:10]:
+            print(f'🔗 {r.get("title", "")}')
+            print(f'   {r.get("url", "")}')
+            print(f'   {truncate(r.get("snippet", ""), 200)}')
+            print()
+    elif "error" in data:
+        print(f'ERROR: {json.dumps(data["error"])}', file=sys.stderr)
+    else:
+        print(json.dumps(data, indent=2)[:2000])
+
+
+def sonar(query):
+    """Sonar API — AI answer with citations."""
+    data = api_post("https://api.perplexity.ai/chat/completions",
+                     {"model": "sonar",
+                      "messages": [{"role": "user", "content": query}]},
+                     headers={"Authorization": f"Bearer {API_KEY}"})
+    if not data:
+        return
+    if "choices" in data:
+        msg = data["choices"][0]["message"]
+        print(msg.get("content", ""))
+        cits = data.get("citations", msg.get("citations", []))
+        if cits:
+            print("\n--- Sources ---")
+            for i, c in enumerate(cits[:10], 1):
+                print(f"{i}. {c if isinstance(c, str) else c.get('url', c)}")
+    elif "error" in data:
+        print(f'ERROR: {json.dumps(data["error"])}', file=sys.stderr)
+    else:
+        print(json.dumps(data, indent=2)[:2000])
+
+
+def deep(query):
+    """Deep Research via sonar-deep-research."""
+    data = api_post("https://api.perplexity.ai/chat/completions",
+                     {"model": "sonar-deep-research",
+                      "messages": [{"role": "user", "content": query}]},
+                     headers={"Authorization": f"Bearer {API_KEY}"},
+                     timeout=300)
+    if not data:
+        return
+    if "choices" in data:
+        msg = data["choices"][0]["message"]
+        print(msg.get("content", ""))
+        cits = data.get("citations", msg.get("citations", []))
+        if cits:
+            print("\n--- Sources ---")
+            for i, c in enumerate(cits[:15], 1):
+                print(f"{i}. {c if isinstance(c, str) else c.get('url', c)}")
+    elif "error" in data:
+        print(f'ERROR: {json.dumps(data["error"])}', file=sys.stderr)
+    else:
+        print(json.dumps(data, indent=2)[:2000])
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: perplexity.py search|sonar|deep <query>")
+        sys.exit(1)
+    init()
+    cmd = sys.argv[1]
+    query = " ".join(sys.argv[2:])
+    if cmd == "search":
+        search(query)
+    elif cmd == "sonar":
+        sonar(query)
+    elif cmd == "deep":
+        deep(query)
+    else:
+        print(f"Unknown command: {cmd} (use search|sonar|deep)", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Tavily API — AI-optimized search for agents. Stdlib only."""
+
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _http import api_post, get_key, truncate
+
+
+def init():
+    return get_key("TAVILY_API_KEY", help_url="https://app.tavily.com/home")
+
+
+def search(api_key, query, depth="basic"):
+    """Tavily search — basic ($0.005) or advanced (deep)."""
+    data = api_post("https://api.tavily.com/search", {
+        "api_key": api_key,
+        "query": query,
+        "search_depth": depth,
+        "max_results": 10,
+        "include_answer": True,
+        "include_raw_content": False,
+    })
+    if not data:
+        return
+    if data.get("answer"):
+        print(f'💡 {data["answer"]}\n')
+    for r in data.get("results", [])[:10]:
+        print(f'🔗 {r.get("title", "")}')
+        print(f'   {r.get("url", "")}')
+        print(f'   {truncate(r.get("content", ""), 300 if depth == "advanced" else 200)}')
+        score = r.get("score", "")
+        if score:
+            print(f"   relevance: {score:.2f}")
+        print()
+
+
+def extract(api_key, url):
+    """Extract content from a URL."""
+    data = api_post("https://api.tavily.com/extract", {
+        "api_key": api_key,
+        "urls": [url],
+    })
+    if not data:
+        return
+    for r in data.get("results", []):
+        print(f'📄 {r.get("url", "")}')
+        print(r.get("raw_content", r.get("content", ""))[:3000])
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: tavily.py search|extract|deep <query>")
+        sys.exit(1)
+    api_key = init()
+    cmd = sys.argv[1]
+    query = " ".join(sys.argv[2:])
+    if cmd == "search":
+        search(api_key, query, "basic")
+    elif cmd == "deep":
+        search(api_key, query, "advanced")
+    elif cmd == "extract":
+        extract(api_key, query)
+    else:
+        print(f"Unknown: {cmd} (use search|extract|deep)", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""OSINT First Volley + Merge — parallel search across all engines, then deduplicate.
+
+Replaces: first-volley.sh + merge-volley.sh
+Uses concurrent.futures for parallel execution (stdlib).
+
+Usage:
+  python volley.py search "Full Name" ["context keywords"]
+  python volley.py merge /tmp/osint-<timestamp>
+"""
+
+import concurrent.futures
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _http import get_workspace
+
+
+def run_script(scripts_dir, script_name, cmd, query, output_file):
+    """Run a Python OSINT script and save output to file."""
+    script_path = os.path.join(scripts_dir, script_name)
+    if not os.path.isfile(script_path):
+        return
+    try:
+        result = subprocess.run(
+            [sys.executable, script_path, cmd, query],
+            capture_output=True, text=True, timeout=60,
+            env=os.environ.copy()
+        )
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(result.stdout or "")
+        if result.stderr:
+            print(f"  ⚠️  {script_name}: {result.stderr[:200]}", file=sys.stderr)
+    except subprocess.TimeoutExpired:
+        print(f"  ⏱️  {script_name}: timeout", file=sys.stderr)
+    except Exception as e:
+        print(f"  ❌ {script_name}: {e}", file=sys.stderr)
+
+
+def first_volley(name, context=""):
+    """Launch parallel searches across all available engines."""
+    workspace, skill_dir, scripts_dir = get_workspace()
+    query = f"{name} {context}".strip()
+    timestamp = int(time.time())
+    outdir = os.path.join(os.environ.get("TEMP", "/tmp"), f"osint-{timestamp}")
+    os.makedirs(outdir, exist_ok=True)
+
+    print(f"🔍 First Volley: {query}")
+    print(f"   Output: {outdir}")
+    print()
+
+    # Build list of searches to run
+    searches = []
+
+    # Jina — general + social
+    if os.environ.get("JINA_API_KEY") or os.path.isfile(
+            os.path.join(workspace, "scripts", "jina-api-key.txt")):
+        searches.append(("jina.py", "search", query,
+                          os.path.join(outdir, "jina-general.json")))
+        searches.append(("jina.py", "search",
+                          f"{name} instagram linkedin facebook telegram",
+                          os.path.join(outdir, "jina-social.json")))
+
+    # Parallel — general + social
+    if os.environ.get("PARALLEL_API_KEY") or os.path.isfile(
+            os.path.join(workspace, "scripts", "parallel-api-key.txt")):
+        searches.append(("parallel.py", "search", query,
+                          os.path.join(outdir, "parallel-general.json")))
+        searches.append(("parallel.py", "search",
+                          f"{name} instagram linkedin telegram facebook profile",
+                          os.path.join(outdir, "parallel-social.json")))
+
+    # Tavily
+    if os.environ.get("TAVILY_API_KEY"):
+        searches.append(("tavily.py", "search", query,
+                          os.path.join(outdir, "tavily-general.json")))
+
+    # Exa
+    if os.environ.get("EXA_API_KEY"):
+        searches.append(("exa.py", "people", name,
+                          os.path.join(outdir, "exa-people.json")))
+
+    # Perplexity
+    if os.environ.get("PERPLEXITY_API_KEY"):
+        searches.append(("perplexity.py", "sonar", query,
+                          os.path.join(outdir, "perplexity-sonar.json")))
+
+    if not searches:
+        print("❌ No API keys found. Set at least one search API key.")
+        print("   Run: python diagnose.py")
+        sys.exit(1)
+
+    print(f"Launching {len(searches)} parallel searches...")
+
+    # Execute in parallel
+    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+        futures = []
+        for script, cmd, q, outfile in searches:
+            print(f"  → {script} {cmd}")
+            futures.append(executor.submit(run_script, scripts_dir, script, cmd, q, outfile))
+        concurrent.futures.wait(futures, timeout=90)
+
+    print()
+    print(f"✅ All searches complete. Results in {outdir}")
+
+    # List result files
+    for f in os.listdir(outdir):
+        fpath = os.path.join(outdir, f)
+        size = os.path.getsize(fpath)
+        print(f"  {f} ({size:,} bytes)")
+    print()
+    print(f"Run: python volley.py merge {outdir}")
+    return outdir
+
+
+def merge_volley(outdir):
+    """Merge and deduplicate first-volley results."""
+    if not os.path.isdir(outdir):
+        print(f"Error: {outdir} not found")
+        sys.exit(1)
+
+    print(f"=== MERGE: {outdir} ===")
+    print()
+
+    # Extract all URLs from result files
+    all_urls = set()
+    for fname in os.listdir(outdir):
+        fpath = os.path.join(outdir, fname)
+        if not os.path.isfile(fpath):
+            continue
+        try:
+            with open(fpath, "r", encoding="utf-8") as f:
+                content = f.read()
+            urls = re.findall(r'https?://[^\s"\'<>]+', content)
+            all_urls.update(urls)
+        except Exception:
+            continue
+
+    if not all_urls:
+        print("⚠️  No URLs found in results.")
+        sys.exit(0)
+
+    print(f"📊 Total unique URLs: {len(all_urls)}")
+    print()
+
+    # Group by platform
+    platforms = {
+        "🔗 LinkedIn": lambda u: "linkedin.com" in u.lower(),
+        "📸 Instagram": lambda u: "instagram.com" in u.lower(),
+        "📘 Facebook": lambda u: "facebook.com" in u.lower(),
+        "✈️ Telegram": lambda u: "t.me" in u.lower(),
+        "🐦 Twitter/X": lambda u: "twitter.com" in u.lower() or "x.com" in u.lower(),
+        "📺 VK": lambda u: "vk.com" in u.lower(),
+    }
+
+    categorized = set()
+    for label, matcher in platforms.items():
+        matches = [u for u in all_urls if matcher(u)]
+        print(f"{label}:")
+        if matches:
+            for u in list(matches)[:10]:
+                print(f"  {u}")
+            categorized.update(matches)
+        else:
+            print("  (none)")
+        print()
+
+    # Other
+    other = [u for u in all_urls if u not in categorized]
+    print("📰 Media/Other:")
+    for u in other[:20]:
+        print(f"  {u}")
+    print()
+
+    # Save merged
+    merged_file = os.path.join(outdir, "merged-urls.txt")
+    with open(merged_file, "w", encoding="utf-8") as f:
+        f.write("\n".join(sorted(all_urls)))
+    print(f"✅ Saved to {merged_file}")
+    print("=== END MERGE ===")
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage:")
+        print('  python volley.py search "Full Name" ["context"]')
+        print("  python volley.py merge /tmp/osint-<timestamp>")
+        sys.exit(1)
+
+    cmd = sys.argv[1]
+    if cmd == "search":
+        name = sys.argv[2]
+        context = sys.argv[3] if len(sys.argv) > 3 else ""
+        first_volley(name, context)
+    elif cmd == "merge":
+        merge_volley(sys.argv[2])
+    else:
+        print(f"Unknown: {cmd} (use search|merge)", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/osint-agent-package/skills/bmad-osint-investigator/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: bmad-osint-investigator
+description: "OSINT Intelligence Analyst agent — systematic intelligence gathering on individuals. From a name or handle to a scored dossier with psychoprofile, career map, and confidence grades. 55+ Apify actors, 7 search APIs."
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+<agent-activation CRITICAL="TRUE">
+1. LOAD the FULL agent file from {project-root}/_bmad/bmm/agents/osint-investigator.md
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. FOLLOW every step in the <activation> section precisely
+4. DISPLAY the welcome/greeting as instructed
+5. PRESENT the numbered menu
+6. WAIT for user input before proceeding
+</agent-activation>