| from __future__ import annotations |
|
|
| import argparse |
| import sys |
| from pathlib import Path |
|
|
| from hydradeck.config import ( |
| UserConfig, |
| resolve_api_key, |
| resolve_base_url, |
| resolve_model, |
| resolve_pdf_compiler, |
| resolve_template, |
| save_config, |
| ) |
| from hydradeck.core.types import RunConfig |
| from hydradeck.pipeline import run |
| from hydradeck.resources_pack import build_resources_pack |
|
|
|
|
| def _build_parser() -> argparse.ArgumentParser: |
| p = argparse.ArgumentParser(prog="hydradeck") |
| sub = p.add_subparsers(dest="cmd", required=True) |
|
|
| runp = sub.add_parser("run", help="Run Grok deep research pipeline") |
| runp.add_argument("--topic", required=True, help="Research topic") |
| runp.add_argument("--out", required=True, help="Output directory or .zip") |
| runp.add_argument("--iterations", type=int, default=3, help="Persona iteration rounds") |
| runp.add_argument("--max-sources", type=int, default=10, help="Max sources to include") |
| runp.add_argument( |
| "--min-words", |
| type=int, |
| default=12000, |
| help="Target minimum words (guidance to model; markdown is primary)", |
| ) |
| runp.add_argument("--base-url", default=None, help="API base URL") |
| runp.add_argument("--model", default=None, help="Model name") |
| runp.add_argument( |
| "--keep-stage", |
| action="store_true", |
| help="If --out is a .zip, keep the staging directory on disk", |
| ) |
| runp.add_argument( |
| "--seed-url", |
| action="append", |
| default=None, |
| help="Seed URL to include as source (can be repeated)", |
| ) |
| runp.add_argument("--llm-timeout", type=float, default=180.0, help="LLM timeout seconds") |
| runp.add_argument("--mock", action="store_true", help="Use deterministic mock (no network)") |
| runp.add_argument("--verbose", action="store_true", help="Verbose logging") |
| runp.add_argument( |
| "--heartbeat", |
| action="store_true", |
| help="Emit periodic heartbeat during long network calls", |
| ) |
| runp.add_argument( |
| "--progress", |
| action="store_true", |
| help="Show a progress bar for generation stages", |
| ) |
| runp.add_argument( |
| "--request-budget", |
| type=float, |
| default=20.0, |
| help="Per-request timeout budget (seconds)", |
| ) |
| runp.add_argument( |
| "--verbatim", |
| action="store_true", |
| help="Write model-produced artifacts verbatim (no rendering/rewriting)", |
| ) |
| runp.add_argument( |
| "--no-archive-prompts", |
| action="store_true", |
| help="Do not archive prompts/requests in the output package", |
| ) |
| runp.add_argument( |
| "--quality-gate", |
| action="store_true", |
| help="Require passing third-party score before writing outputs", |
| ) |
| runp.add_argument( |
| "--min-quality", |
| type=float, |
| default=0.85, |
| help="Minimum quality score (0-1)", |
| ) |
| runp.add_argument( |
| "--quality-attempts", |
| type=int, |
| default=3, |
| help="Max regeneration attempts to meet quality gate", |
| ) |
| runp.add_argument( |
| "--archive-snapshots", |
| action="store_true", |
| help="Fetch and archive source page snapshots into resources/snapshots", |
| ) |
| runp.add_argument( |
| "--snapshot-timeout", |
| type=float, |
| default=25.0, |
| help="Per-URL snapshot fetch timeout (seconds)", |
| ) |
| runp.add_argument( |
| "--snapshot-total-timeout", |
| type=float, |
| default=60.0, |
| help="Total time budget for all snapshots (seconds)", |
| ) |
|
|
| prep = sub.add_parser( |
| "pre", |
| help="Generate a preset pre-research package (no API key required)", |
| ) |
| prep.add_argument("--preset", required=True, help="Preset name (e.g. rynnbrain)") |
| prep.add_argument("--out", required=True, help="Output directory or .zip") |
| prep.add_argument( |
| "--keep-stage", |
| action="store_true", |
| help="Keep staging directory when output is .zip", |
| ) |
| prep.add_argument( |
| "--no-fetch", |
| action="store_true", |
| help="Do not fetch and archive web snapshots", |
| ) |
|
|
| models_p = sub.add_parser("models", help="List available models") |
| models_p.add_argument( |
| "--base-url", |
| default=None, |
| help="API base URL", |
| ) |
|
|
| auto_p = sub.add_parser( |
| "auto", |
| help="Run autonomous deep research (verbatim + prompts + snapshots)", |
| ) |
| auto_p.add_argument("--topic", required=True, help="Research topic") |
| auto_p.add_argument("--out", required=True, help="Output directory or .zip") |
| auto_p.add_argument( |
| "--base-url", |
| default=None, |
| help="API base URL", |
| ) |
| auto_p.add_argument( |
| "--model", |
| default=None, |
| help="Fallback model name", |
| ) |
| auto_p.add_argument( |
| "--iterations", |
| type=int, |
| default=3, |
| help="Persona iteration rounds", |
| ) |
| auto_p.add_argument( |
| "--max-sources", |
| type=int, |
| default=12, |
| help="Max sources to include", |
| ) |
| auto_p.add_argument( |
| "--module-sources", |
| type=int, |
| default=5, |
| help="Sources per query module", |
| ) |
| auto_p.add_argument( |
| "--query-count", |
| type=int, |
| default=8, |
| help="Number of queries to generate (high recall)", |
| ) |
| auto_p.add_argument( |
| "--max-query-modules", |
| type=int, |
| default=2, |
| help="Max query modules to expand into sources", |
| ) |
| auto_p.add_argument( |
| "--sources-attempts", |
| type=int, |
| default=3, |
| help="Max attempts to obtain sources (must be <=3)", |
| ) |
| auto_p.add_argument( |
| "--facts-max-pages", |
| type=int, |
| default=6, |
| help="Max pages to pass into facts extraction", |
| ) |
| auto_p.add_argument( |
| "--facts-max-chars", |
| type=int, |
| default=8000, |
| help="Max chars per page passed into facts extraction", |
| ) |
| auto_p.add_argument( |
| "--facts-target", |
| type=int, |
| default=30, |
| help="Approximate number of facts to extract", |
| ) |
| auto_p.add_argument( |
| "--judge-max-chars", |
| type=int, |
| default=12000, |
| help="Max chars per artifact passed into judge", |
| ) |
| auto_p.add_argument( |
| "--max-runtime", |
| type=float, |
| default=240.0, |
| help="Max total runtime seconds before aborting", |
| ) |
| auto_p.add_argument( |
| "--llm-timeout", |
| type=float, |
| default=180.0, |
| help="LLM timeout seconds", |
| ) |
| auto_p.add_argument( |
| "--snapshot-timeout", |
| type=float, |
| default=25.0, |
| help="Per-URL snapshot fetch timeout (seconds)", |
| ) |
| auto_p.add_argument("--mock", action="store_true", help="Use deterministic mock") |
| auto_p.add_argument("--verbose", action="store_true", help="Verbose logging") |
| auto_p.add_argument( |
| "--heartbeat", |
| action="store_true", |
| help="Emit periodic heartbeat during long network calls", |
| ) |
| auto_p.add_argument( |
| "--progress", |
| action="store_true", |
| help="Show a progress bar for generation stages", |
| ) |
| auto_p.add_argument( |
| "--request-budget", |
| type=float, |
| default=20.0, |
| help="Per-request timeout budget (seconds)", |
| ) |
| auto_p.add_argument( |
| "--min-quality", |
| type=float, |
| default=0.85, |
| help="Minimum quality score (0-1)", |
| ) |
| auto_p.add_argument( |
| "--quality-attempts", |
| type=int, |
| default=3, |
| help="Max regeneration attempts to meet quality gate", |
| ) |
|
|
| cfg_p = sub.add_parser("config", help="Persist local config (base_url/model/api_key)") |
| cfg_p.add_argument("--base-url", default=None, help="API base URL") |
| cfg_p.add_argument("--model", default=None, help="Default model") |
| cfg_p.add_argument("--api-key", default=None, help="API key (stored locally)") |
| cfg_p.add_argument( |
| "--pdf-compiler", |
| default=None, |
| help="PDF compiler backend: latexonline or texlive", |
| ) |
| cfg_p.add_argument( |
| "--template", |
| default=None, |
| help="Template: iclr2026 or plain", |
| ) |
|
|
| res_p = sub.add_parser("resources", help="One-click resources pack (no seed required)") |
| res_p.add_argument("--topic", required=True, help="Research topic") |
| res_p.add_argument("--out", required=True, help="Output directory or .zip") |
| res_p.add_argument( |
| "--base-url", |
| default=None, |
| help="API base URL", |
| ) |
| res_p.add_argument( |
| "--model", |
| default=None, |
| help="Model name", |
| ) |
| res_p.add_argument( |
| "--pdf-compiler", |
| default=resolve_pdf_compiler("auto"), |
| help="PDF compiler: auto|latexonline|texlive", |
| ) |
| res_p.add_argument( |
| "--template", |
| default=resolve_template("pretty"), |
| help="Template: pretty|plain", |
| ) |
| res_p.add_argument("--max-sources", type=int, default=8, help="Max sources") |
| res_p.add_argument("--module-sources", type=int, default=3, help="Sources per module") |
| res_p.add_argument("--llm-timeout", type=float, default=35.0, help="LLM timeout") |
| res_p.add_argument("--snapshot-timeout", type=float, default=10.0, help="Snapshot timeout") |
| res_p.add_argument( |
| "--snapshot-total-timeout", |
| type=float, |
| default=60.0, |
| help="Total time budget for all snapshots", |
| ) |
| res_p.add_argument("--max-runtime", type=float, default=180.0, help="Max runtime") |
| res_p.add_argument("--request-budget", type=float, default=15.0, help="Per-request budget") |
| res_p.add_argument("--keep-stage", action="store_true", help="Keep staging directory") |
| res_p.add_argument("--heartbeat", action="store_true", help="Heartbeat") |
| res_p.add_argument("--progress", action="store_true", help="Progress bar") |
|
|
| wiz_p = sub.add_parser("wizard", help="Guided research (interactive)") |
| wiz_p.add_argument("--out", required=False, default=None, help="Output directory or .zip") |
| return p |
|
|
|
|
| def _prompt(prompt: str, default: str | None = None) -> str: |
| suffix = f" [{default}]" if default else "" |
| v = input(prompt + suffix + ": ").strip() |
| if not v and default is not None: |
| return default |
| return v |
|
|
|
|
| def _prompt_int(prompt: str, default: int) -> int: |
| v = _prompt(prompt, str(default)) |
| try: |
| return int(v) |
| except Exception: |
| return default |
|
|
|
|
| def _prompt_float(prompt: str, default: float) -> float: |
| v = _prompt(prompt, str(default)) |
| try: |
| return float(v) |
| except Exception: |
| return default |
|
|
|
|
| def main(argv: list[str] | None = None) -> int: |
| args = _build_parser().parse_args(argv) |
| if args.cmd == "run": |
| base_url = resolve_base_url(args.base_url) |
| model = resolve_model(args.model) |
| cfg = RunConfig( |
| topic=args.topic, |
| out=Path(args.out), |
| base_url=base_url, |
| api_key=resolve_api_key(), |
| model=model, |
| iterations=max(int(args.iterations), 1), |
| max_sources=max(int(args.max_sources), 1), |
| min_total_words=max(int(args.min_words), 1000), |
| use_mock=bool(args.mock), |
| verbose=bool(args.verbose or args.heartbeat), |
| progress=bool(args.progress), |
| llm_timeout_s=float(args.llm_timeout), |
| request_budget_s=float(args.request_budget), |
| keep_stage=bool(args.keep_stage), |
| verbatim=bool(args.verbatim), |
| archive_prompts=not bool(args.no_archive_prompts), |
| archive_snapshots=bool(args.archive_snapshots), |
| snapshot_timeout_s=float(args.snapshot_timeout), |
| snapshot_total_timeout_s=float(args.snapshot_total_timeout), |
| quality_gate=bool(args.quality_gate), |
| min_quality_score=float(args.min_quality), |
| max_quality_attempts=int(args.quality_attempts), |
| seed_urls=args.seed_url, |
| ) |
| run(cfg) |
| return 0 |
| if args.cmd == "pre": |
| from hydradeck.presets.rynnbrain import generate |
|
|
| if str(args.preset).strip().lower() != "rynnbrain": |
| print(f"Unknown preset: {args.preset}", file=sys.stderr) |
| return 2 |
| generate( |
| out=Path(args.out), |
| keep_stage=bool(args.keep_stage), |
| fetch=not bool(args.no_fetch), |
| ) |
| return 0 |
|
|
| if args.cmd == "models": |
| from hydradeck.clients import GrokClient |
|
|
| client = GrokClient( |
| base_url=resolve_base_url(str(args.base_url) if args.base_url else None), |
| api_key=resolve_api_key(), |
| model="grok-4", |
| ) |
| for mid in client.list_models(): |
| print(mid) |
| return 0 |
|
|
| if args.cmd == "auto": |
| base_url = resolve_base_url(args.base_url) |
| model = resolve_model(args.model) |
| cfg = RunConfig( |
| topic=args.topic, |
| out=Path(args.out), |
| base_url=base_url, |
| api_key=resolve_api_key(), |
| model=model, |
| iterations=max(int(args.iterations), 1), |
| max_sources=max(int(args.max_sources), 1), |
| module_sources=max(int(args.module_sources), 1), |
| query_count=max(int(args.query_count), 1), |
| max_query_modules=max(int(args.max_query_modules), 1), |
| sources_attempts=min(max(int(args.sources_attempts), 1), 3), |
| facts_max_pages=max(int(args.facts_max_pages), 1), |
| facts_max_chars_per_page=max(int(args.facts_max_chars), 1000), |
| facts_target=max(int(args.facts_target), 5), |
| judge_max_chars=max(int(args.judge_max_chars), 2000), |
| max_total_runtime_s=float(args.max_runtime), |
| min_total_words=12000, |
| use_mock=bool(args.mock), |
| verbose=bool(args.verbose or args.heartbeat), |
| progress=bool(args.progress), |
| llm_timeout_s=float(args.llm_timeout), |
| keep_stage=False, |
| verbatim=True, |
| archive_prompts=True, |
| archive_snapshots=True, |
| snapshot_timeout_s=float(args.snapshot_timeout), |
| auto=True, |
| auto_queries=True, |
| auto_models=True, |
| quality_gate=True, |
| min_quality_score=float(args.min_quality), |
| max_quality_attempts=int(args.quality_attempts), |
| seed_urls=None, |
| ) |
| run(cfg) |
| return 0 |
|
|
| if args.cmd == "config": |
| uc = UserConfig( |
| base_url=str(args.base_url) if args.base_url else None, |
| api_key=str(args.api_key) if args.api_key else None, |
| model=str(args.model) if args.model else None, |
| pdf_compiler=str(args.pdf_compiler) if args.pdf_compiler else None, |
| template=str(args.template) if args.template else None, |
| ) |
| p = save_config(uc) |
| print(str(p)) |
| return 0 |
|
|
| if args.cmd == "resources": |
| base_url = resolve_base_url(args.base_url) |
| model = resolve_model(args.model) |
| cfg = RunConfig( |
| topic=args.topic, |
| out=Path(args.out), |
| base_url=base_url, |
| api_key=resolve_api_key(), |
| model=model, |
| pdf_compiler=str(args.pdf_compiler), |
| template=str(args.template), |
| max_sources=max(int(args.max_sources), 1), |
| module_sources=max(int(args.module_sources), 1), |
| use_mock=False, |
| verbose=bool(args.heartbeat), |
| progress=bool(args.progress), |
| llm_timeout_s=float(args.llm_timeout), |
| snapshot_timeout_s=float(args.snapshot_timeout), |
| max_total_runtime_s=float(args.max_runtime), |
| request_budget_s=float(args.request_budget), |
| keep_stage=bool(args.keep_stage), |
| ) |
| build_resources_pack(cfg) |
| return 0 |
|
|
| if args.cmd == "wizard": |
| topic = _prompt("Topic", "RynnBrain") |
| out = args.out or _prompt("Output path (.zip)", "hydradeck/out/pre.zip") |
| base_url = _prompt("Base URL (from config if empty)", "") |
| model = _prompt("Model (from config if empty)", "") |
| max_sources = _prompt_int("Max sources", 8) |
| module_sources = _prompt_int("Sources per module", 3) |
| llm_timeout = _prompt_float("LLM timeout (s)", 35.0) |
| snapshot_timeout = _prompt_float("Snapshot timeout (s)", 10.0) |
| max_runtime = _prompt_float("Max runtime (s)", 300.0) |
| request_budget = _prompt_float("Per-request budget (s)", 20.0) |
| pdf_compiler = _prompt("PDF compiler (auto|latexonline|texlive)", "auto") |
| template = _prompt("Template (iclr2026|plain)", "iclr2026") |
|
|
| cfg = RunConfig( |
| topic=topic, |
| out=Path(out), |
| base_url=resolve_base_url(base_url or None), |
| api_key=resolve_api_key(), |
| model=resolve_model(model or None), |
| pdf_compiler=pdf_compiler, |
| template=template, |
| max_sources=max(max_sources, 1), |
| module_sources=max(module_sources, 1), |
| use_mock=False, |
| verbose=True, |
| progress=True, |
| llm_timeout_s=llm_timeout, |
| snapshot_timeout_s=snapshot_timeout, |
| max_total_runtime_s=max_runtime, |
| request_budget_s=request_budget, |
| keep_stage=False, |
| ) |
| build_resources_pack(cfg) |
| print(out) |
| return 0 |
|
|
| print(f"Unknown command: {args.cmd}", file=sys.stderr) |
| return 2 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
