bmad-plus 0.8.0 → 0.9.1

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/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()

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

@@ -1,102 +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()
+#!/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

@@ -1,72 +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()
+#!/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()