deepparallel 0.2.0__py3-none-any.whl

deepparallel/cli.py

@@ -0,0 +1,569 @@
+#!/usr/bin/env python3
+"""DeepParallel CLI.
+
+Commands:
+    deepparallel                 interactive agent chat (default)
+    deepparallel chat            interactive agent chat (explicit)
+    deepparallel run "prompt"    one-shot; answer to stdout
+    deepparallel tools           list available agent tools
+    deepparallel info            model + backend status
+    deepparallel models          list registered model
+    deepparallel doctor          diagnose config + reachability
+
+Flags --no-tools (plain chat, no tools) and --yes (auto-approve tool actions)
+apply to chat and run.
+"""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import replace
+from pathlib import Path
+
+import click
+import httpx
+from dotenv import load_dotenv
+from rich import box
+from rich.table import Table
+
+from deepparallel import __version__, branding
+from deepparallel.agent import (
+    guardian_review,
+    run_agent,
+    verdict_exit_code,
+    verdict_severity,
+)
+from deepparallel.backend import Backend, backend_for_deployment, resolve_backend
+from deepparallel.branding import console
+from deepparallel.config import (
+    Settings,
+    _bool_env,
+    load_model_spec,
+    load_system_prompt,
+    missing_required,
+    resolve_settings,
+)
+from deepparallel import licensing
+from deepparallel.fusion import (
+    EscalationBackend,
+    ReasonAnswerBackend,
+    deep_query,
+    dual_query,
+)
+from deepparallel.renderer import PlainRenderer, Renderer, RichRenderer
+from deepparallel.tools import get_registry
+
+
+def _build_messages(history: list[tuple[str, str]], system: str, user_msg: str) -> list[dict]:
+    msgs: list[dict] = [{"role": "system", "content": system}]
+    for role, content in history:
+        msgs.append({"role": role, "content": content})
+    msgs.append({"role": "user", "content": user_msg})
+    return msgs
+
+
+def _apply_flags(settings: Settings, no_tools: bool, assume_yes: bool) -> Settings:
+    if no_tools:
+        settings = replace(settings, tools_enabled=False)
+    if assume_yes:
+        settings = replace(settings, auto_approve=True)
+    return settings
+
+
+def _effective_backend(base: Backend, settings: Settings, mode: str) -> Backend:
+    """Wrap the base backend in a fusion strategy for the given mode.
+
+    Fusion is a paid (Pro+) feature; on Free it degrades to the single-model
+    backend with a one-time upgrade nudge.
+    """
+    if mode not in ("reason", "escalate"):
+        return base
+    ok, msg = licensing.check_feature("fusion")
+    if not ok:
+        branding.info(msg)
+        return base
+    reasoner = backend_for_deployment(settings, settings.reasoner_deployment)
+    if mode == "reason":
+        return ReasonAnswerBackend(base, reasoner)
+    return EscalationBackend(base, reasoner)
+
+
+def _wrap_fusion(backend: Backend, settings: Settings) -> Backend:
+    """Wrap per settings.fusion_mode (used by the non-interactive paths)."""
+    return _effective_backend(backend, settings, settings.fusion_mode)
+
+
+def _run_deep(settings: Settings, messages: list[dict]) -> None:
+    """Heavy multi-model fan-out + judge, one-shot. Chains are shown with
+    generic labels (no raw model names) per the brand rule. Paid (Pro+)."""
+    ok, msg = licensing.check_feature("deep")
+    if not ok:
+        branding.error(msg)
+        sys.exit(2)
+    chains = [
+        (f"candidate-{i + 1}", backend_for_deployment(settings, dep))
+        for i, dep in enumerate(settings.parallel_deployments)
+    ]
+    judge = backend_for_deployment(settings, settings.judge_deployment)
+
+    def on_event(name: str, content: str) -> None:
+        sys.stderr.write(f"> {name}: {content[:80]}\n")
+        sys.stderr.flush()
+
+    try:
+        result = deep_query(
+            messages, chains, judge, settings.temperature, settings.max_tokens, on_event
+        )
+    except Exception as e:  # noqa: BLE001 - surface as friendly message
+        branding.error(_translate_error(e))
+        sys.exit(1)
+    ag = result.get("agreement") or {}
+    if ag.get("level") and ag["level"] != "n/a":
+        sys.stderr.write(
+            f"consensus: {ag['level']} ({ag.get('score')}) [agreement, not correctness]\n"
+        )
+        if ag["level"] == "low":
+            sys.stderr.write("models diverged - candidates:\n")
+            for c in result.get("chains", []):
+                sys.stderr.write(f"  {c['name']}: {c['content'][:120]}\n")
+        sys.stderr.flush()
+    sys.stdout.write(result["answer"].rstrip("\n") + "\n")
+
+
+def _run_dual(settings: Settings, messages: list[dict], dual: str, synth: bool) -> None:
+    ok, msg = licensing.check_feature("dual")
+    if not ok:
+        branding.error(msg)
+        sys.exit(2)
+    names = [s.strip() for s in dual.split(",") if s.strip()] if dual else []
+    if len(names) >= 2:
+        la, ra, lname, rname = names[0], names[1], names[0], names[1]
+    else:
+        la, ra, lname, rname = (
+            settings.deployment,
+            settings.reasoner_deployment,
+            "primary",
+            "reasoner",
+        )
+    left = (lname, backend_for_deployment(settings, la))
+    right = (rname, backend_for_deployment(settings, ra))
+    judge = backend_for_deployment(settings, settings.judge_deployment) if synth else None
+    try:
+        out = dual_query(messages, left, right, settings.temperature, settings.max_tokens, judge)
+    except Exception as e:  # noqa: BLE001 - surface as friendly message
+        branding.error(_translate_error(e))
+        sys.exit(1)
+    sys.stdout.write(f"## {out['left']['name']}\n{out['left']['content']}\n\n")
+    sys.stdout.write(f"## {out['right']['name']}\n{out['right']['content']}\n")
+    if out["synthesis"]:
+        sys.stdout.write(f"\n## synthesis\n{out['synthesis']}\n")
+
+
+def _build_guardian(settings: Settings) -> Backend | None:
+    """A second model that reviews edits before they apply (interactive only).
+
+    Guardian is a paid (Pro+) feature; disabled on Free.
+    """
+    if not settings.guardian_enabled:
+        return None
+    ok, msg = licensing.check_feature("guardian")
+    if not ok:
+        branding.info(msg)
+        return None
+    return backend_for_deployment(settings, settings.guardian_deployment)
+
+
+def _make_renderer(*, force_plain: bool, assume_yes: bool = False) -> Renderer:
+    plain = force_plain or _bool_env("DEEPPARALLEL_PLAIN", False) or not sys.stdout.isatty()
+    if plain:
+        return PlainRenderer(assume_yes=assume_yes)
+    return RichRenderer()
+
+
+def _require_ready(settings: Settings) -> Backend:
+    missing = missing_required(settings)
+    if missing:
+        branding.error(f"missing required env: {', '.join(missing)} (backend={settings.backend})")
+        sys.exit(1)
+    return resolve_backend(settings)
+
+
+def _translate_error(e: Exception) -> str:
+    if isinstance(e, httpx.HTTPStatusError):
+        code = e.response.status_code
+        if code == 401:
+            return "authentication failed (401) - check the API key."
+        if code == 404:
+            return "model endpoint not found (404) - check the backend configuration."
+        return f"backend returned HTTP {code}."
+    return f"{e.__class__.__name__}: {e}"
+
+
+def _print_info(settings: Settings) -> None:
+    spec = load_model_spec()
+    table = Table(box=box.SIMPLE_HEAVY, show_header=False, pad_edge=False)
+    table.add_column("k", style="grey50")
+    table.add_column("v", style="white")
+    table.add_row("model", spec.label)
+    table.add_row("backend", settings.backend)
+    table.add_row("context", str(spec.context_window))
+    table.add_row("license", f"{spec.license} · {spec.license_url}")
+    console.print(table)
+
+
+def _stream_once(backend: Backend, settings: Settings, messages: list[dict]) -> None:
+    """Plain-chat one-shot (no tools): stream tokens to stdout."""
+    try:
+        for channel, text in backend.stream_chat(
+            messages, settings.temperature, settings.max_tokens
+        ):
+            if channel == "thinking" and not settings.show_thinking:
+                continue
+            sys.stdout.write(text)
+            sys.stdout.flush()
+        sys.stdout.write("\n")
+    except Exception as e:  # noqa: BLE001 - surface as friendly message
+        branding.error(_translate_error(e))
+        sys.exit(1)
+
+
+def _stream_repl(backend: Backend, settings: Settings) -> None:
+    """Plain-chat interactive loop (no tools)."""
+    system = load_system_prompt()
+    history: list[tuple[str, str]] = []
+    while True:
+        try:
+            user_msg = console.input(branding.user_prefix() + "› ").strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print()
+            break
+        if not user_msg:
+            continue
+        if user_msg in {"/quit", "/exit", ":q"}:
+            break
+        if user_msg == "/help":
+            branding.info("/quit · /reset · /info · anything else is a prompt")
+            continue
+        if user_msg == "/reset":
+            history.clear()
+            branding.info("conversation cleared.")
+            continue
+        if user_msg == "/info":
+            _print_info(settings)
+            continue
+
+        messages = _build_messages(history, system, user_msg)
+        console.print(branding.model_prefix() + "›", end=" ")
+        reply: list[str] = []
+        try:
+            for channel, text in backend.stream_chat(
+                messages, settings.temperature, settings.max_tokens
+            ):
+                if channel == "thinking":
+                    if settings.show_thinking:
+                        branding.thinking(text)
+                    continue
+                console.print(text, end="", soft_wrap=True, highlight=False)
+                reply.append(text)
+            console.print()
+        except Exception as e:  # noqa: BLE001 - surface as friendly message
+            console.print()
+            branding.error(_translate_error(e))
+            continue
+
+        history.append(("user", user_msg))
+        history.append(("assistant", "".join(reply)))
+
+    branding.attribution_footer()
+
+
+_DIAL = {"/fast": "off", "/fuse": "reason", "/escalate": "escalate"}
+
+
+def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> None:
+    """Interactive agentic loop: tools enabled, conversation persists. The dial
+    (/fast //fuse //escalate //deep) swaps the active fusion mode live."""
+    registry = get_registry()
+    guardian = _build_guardian(settings)
+    system = load_system_prompt()
+    messages: list[dict] = [{"role": "system", "content": system}]
+    mode = settings.fusion_mode if settings.fusion_mode in ("reason", "escalate") else "off"
+    deep_next = False
+    while True:
+        tag = f"[{mode}] " if mode != "off" else ""
+        try:
+            user_msg = console.input(f"{tag}{branding.user_prefix()}› ").strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print()
+            break
+        if not user_msg:
+            continue
+        if user_msg in {"/quit", "/exit", ":q"}:
+            break
+        if user_msg == "/help":
+            branding.info(
+                "/quit · /reset · /info · /tools · /fast //fuse //escalate //deep · prompt"
+            )
+            continue
+        if user_msg == "/reset":
+            messages = [{"role": "system", "content": system}]
+            branding.info("conversation cleared.")
+            continue
+        if user_msg == "/info":
+            _print_info(settings)
+            continue
+        if user_msg in _DIAL:
+            mode = _DIAL[user_msg]
+            branding.info(f"mode: {mode}")
+            continue
+        if user_msg == "/deep":
+            deep_next = True
+            branding.info("next prompt runs as a multi-model deep query")
+            continue
+
+        messages.append({"role": "user", "content": user_msg})
+        if deep_next:
+            deep_next = False
+            _run_deep(settings, list(messages))
+            continue
+        try:
+            run_agent(
+                _effective_backend(backend, settings, mode),
+                registry,
+                messages,
+                settings,
+                renderer,
+                interactive=True,
+                auto_approve=settings.auto_approve,
+                stream=True,
+                guardian=guardian,
+            )
+            if mode in ("reason", "escalate"):
+                branding.info("reasoned by CroweLM Reason · answered by DeepParallel")
+        except Exception as e:  # noqa: BLE001 - surface as friendly message
+            renderer.error(_translate_error(e))
+
+    branding.attribution_footer()
+
+
+def _chat_loop(settings: Settings) -> None:
+    backend = _require_ready(settings)
+    ok, msg = backend.check()
+    if settings.tools_enabled:
+        renderer = _make_renderer(force_plain=False, assume_yes=settings.auto_approve)
+        renderer.welcome(
+            msg,
+            version=__version__,
+            tool_count=len(get_registry().list_all()),
+            fusion_modes=("reason", "escalate", "deep", "dual"),
+        )
+        if not ok:
+            renderer.error(msg)
+            sys.exit(1)
+        _agent_repl(backend, settings, renderer)  # raw backend; dial re-wraps live
+    else:
+        if not ok:
+            branding.welcome(backend_label=msg)
+            branding.error(msg)
+            sys.exit(1)
+        branding.welcome(backend_label=msg)
+        _stream_repl(_wrap_fusion(backend, settings), settings)
+
+
+@click.group(
+    invoke_without_command=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.version_option(__version__, prog_name="deepparallel")
+@click.option("--temperature", "-t", default=None, type=float, help="Sampling temperature.")
+@click.pass_context
+def main(ctx: click.Context, temperature: float | None) -> None:
+    """DeepParallel - a focused agentic CLI for the DeepParallel model."""
+    load_dotenv()
+    ctx.ensure_object(dict)
+    settings = resolve_settings()
+    if temperature is not None:
+        settings = replace(settings, temperature=temperature)
+    ctx.obj["settings"] = settings
+    if ctx.invoked_subcommand is None:
+        _chat_loop(settings)
+
+
+@main.command()
+@click.option("--no-tools", is_flag=True, help="Disable tools (plain chat).")
+@click.option("--yes", "-y", "assume_yes", is_flag=True, help="Auto-approve tool actions.")
+@click.option(
+    "--fuse",
+    type=click.Choice(["reason", "escalate", "off"]),
+    default=None,
+    help="Stack a reasoner with the answerer.",
+)
+@click.pass_context
+def chat(ctx: click.Context, no_tools: bool, assume_yes: bool, fuse: str | None) -> None:
+    """Start an interactive chat session."""
+    settings = _apply_flags(ctx.obj["settings"], no_tools, assume_yes)
+    if fuse is not None:
+        settings = replace(settings, fusion_mode=fuse)
+    _chat_loop(settings)
+
+
+@main.command()
+@click.option("--no-tools", is_flag=True, help="Disable tools (plain chat).")
+@click.option("--yes", "-y", "assume_yes", is_flag=True, help="Auto-approve tool actions.")
+@click.option(
+    "--fuse",
+    type=click.Choice(["reason", "escalate", "off"]),
+    default=None,
+    help="Stack a reasoner with the answerer.",
+)
+@click.option("--deep", is_flag=True, help="Heavy multi-model fan-out + judge (slow).")
+@click.option(
+    "--dual",
+    default=None,
+    help="Compare two deployments 'A,B' (default: primary vs reasoner).",
+)
+@click.option("--synth", is_flag=True, help="With --dual, also synthesize a merged answer.")
+@click.argument("prompt", nargs=-1, required=True)
+@click.pass_context
+def run(
+    ctx: click.Context,
+    no_tools: bool,
+    assume_yes: bool,
+    fuse: str | None,
+    deep: bool,
+    dual: str | None,
+    synth: bool,
+    prompt: tuple[str, ...],
+) -> None:
+    """Run a single prompt; the answer goes to stdout."""
+    settings = _apply_flags(ctx.obj["settings"], no_tools, assume_yes)
+    if fuse is not None:
+        settings = replace(settings, fusion_mode=fuse)
+    backend = _require_ready(settings)
+    system = load_system_prompt()
+    messages = _build_messages([], system, " ".join(prompt))
+    if deep:
+        _run_deep(settings, messages)
+        return
+    if dual is not None:
+        _run_dual(settings, messages, dual, synth)
+        return
+    backend = _wrap_fusion(backend, settings)
+    if not settings.tools_enabled:
+        _stream_once(backend, settings, messages)
+        return
+    renderer = PlainRenderer(assume_yes=settings.auto_approve)
+    try:
+        run_agent(
+            backend,
+            get_registry(),
+            messages,
+            settings,
+            renderer,
+            interactive=False,
+            auto_approve=settings.auto_approve,
+        )
+    except Exception as e:  # noqa: BLE001 - surface as friendly message
+        branding.error(_translate_error(e))
+        sys.exit(1)
+
+
+@main.command()
+@click.option("--diff", "as_diff", is_flag=True, help="Read a unified diff from stdin.")
+@click.argument("path", required=False)
+@click.pass_context
+def review(ctx: click.Context, as_diff: bool, path: str | None) -> None:
+    """Independent cross-model review of a code change (the Guardian, as a gate).
+
+    Reviews a file (PATH) or a unified diff (--diff, from stdin) with a second
+    model and prints a verdict. Exit code: 0 safe, 1 risky, 2 bug - so it can
+    gate a commit or PR. Paid (Pro+).
+    """
+    settings: Settings = ctx.obj["settings"]
+    ok, msg = licensing.check_feature("review")
+    if not ok:
+        branding.error(msg)
+        sys.exit(3)
+    if as_diff:
+        content = sys.stdin.read()
+    elif path:
+        try:
+            content = Path(path).expanduser().read_text(encoding="utf-8")
+        except OSError as e:
+            branding.error(f"cannot read {path}: {e}")
+            sys.exit(3)
+    else:
+        branding.error("provide a PATH or --diff (with a diff on stdin)")
+        sys.exit(3)
+    _require_ready(settings)  # validates creds / exits if missing
+    guardian = backend_for_deployment(settings, settings.guardian_deployment)
+    verdict = guardian_review(guardian, content[:8000])
+    severity = verdict_severity(verdict)
+    glyph = {"safe": branding.CHECK, "risky": "!", "bug": branding.CROSS}.get(severity, "?")
+    console.print(f"[bold]{glyph} {severity.upper()}[/] {verdict or '(no verdict)'}")
+    sys.exit(verdict_exit_code(verdict))
+
+
+@main.command(name="tools")
+def tools_cmd() -> None:
+    """List the agent tools available to DeepParallel."""
+    table = Table(box=box.SIMPLE_HEAVY)
+    table.add_column("tool", style="bold")
+    table.add_column("danger")
+    table.add_column("description")
+    for m in get_registry().list_all():
+        table.add_row(m.name, "!" if m.dangerous else "", m.description.splitlines()[0])
+    console.print(table)
+
+
+@main.command()
+@click.pass_context
+def info(ctx: click.Context) -> None:
+    """Show model and backend status."""
+    settings: Settings = ctx.obj["settings"]
+    _print_info(settings)
+    missing = missing_required(settings)
+    if missing:
+        console.print(f"[bold red]config incomplete[/] · missing {', '.join(missing)}")
+    else:
+        ok, msg = resolve_backend(settings).check()
+        console.print(
+            f"[bright_green]backend ok[/] · {msg}" if ok else f"[bold red]backend down[/] · {msg}"
+        )
+    branding.attribution_footer()
+
+
+@main.command()
+def models() -> None:
+    """List registered models (single-model CLI)."""
+    spec = load_model_spec()
+    table = Table(box=box.SIMPLE_HEAVY)
+    table.add_column("name", style="bold")
+    table.add_column("label")
+    table.add_column("family")
+    table.add_row(spec.name, spec.label, spec.base_family)
+    console.print(table)
+    branding.attribution_footer()
+
+
+@main.command()
+@click.pass_context
+def doctor(ctx: click.Context) -> None:
+    """Diagnose configuration and backend reachability."""
+    settings: Settings = ctx.obj["settings"]
+    console.print(f"[bold]backend[/]: {settings.backend}")
+    missing = missing_required(settings)
+    if missing:
+        branding.error(f"missing env: {', '.join(missing)}")
+        sys.exit(1)
+    console.print("[bright_green]env ok[/]")
+    ok, msg = resolve_backend(settings).check()
+    if ok:
+        console.print(f"[bright_green]reachable[/] · {msg}")
+    else:
+        branding.error(msg)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()