deepparallel 0.5.7__tar.gz → 0.7.0__tar.gz

{deepparallel-0.5.7 → deepparallel-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.7
+Version: 0.7.0
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0
@@ -16,6 +16,7 @@ Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: tree-sitter>=0.25.0
 Requires-Dist: tree-sitter-language-pack>=1.8.0
 Requires-Dist: cryptography>=42.0.0
+Requires-Dist: textual>=0.52.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: ruff>=0.6.0; extra == "dev"

{deepparallel-0.5.7 → deepparallel-0.7.0}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.5.7"
+__version__ = "0.7.0"

{deepparallel-0.5.7 → deepparallel-0.7.0}/deepparallel/agent.py

@@ -255,16 +255,29 @@ def _supply_chain_note(name: str, args: dict) -> str | None:
     return None
 
 
-def _approved(name, args, interactive, auto_approve, renderer, guardian=None) -> bool:
+def _approved(name, args, interactive, auto_approve, renderer, guardian=None, mesh_fn=None) -> bool:
     forced = name in _GATED_PATH_TOOLS and _outside_cwd(args)
     sc_note = _supply_chain_note(name, args) if name in _EDIT_TOOLS else None
-    # A hallucinated dependency overrides auto-approve: always surface it.
-    if auto_approve and not forced and not sc_note:
+    # The verification mesh reviews every edit. A BUG verdict blocks the action
+    # and overrides auto-approve, exactly like a hallucinated dependency does.
+    mesh_result = None
+    if mesh_fn is not None and name in _EDIT_TOOLS:
+        try:
+            mesh_result = mesh_fn(_guardian_review_content(name, args))
+        except Exception:  # noqa: BLE001 - the gate is best-effort, never fatal
+            mesh_result = None
+    blocked = bool(mesh_result and mesh_result.get("severity") == "bug")
+    # A hallucinated dependency or a BUG verdict overrides auto-approve.
+    if auto_approve and not forced and not sc_note and not blocked:
         return True
     if not interactive:
         return False
     title, detail = _describe(name, args)
-    if guardian is not None and name in _EDIT_TOOLS:
+    if mesh_result is not None:
+        from deepparallel.mesh import format_panel
+
+        detail = f"{detail}\n\nVerification mesh:\n{format_panel(mesh_result)}"
+    elif guardian is not None and name in _EDIT_TOOLS:
         verdict = _guardian_verdict(guardian, name, args)
         if verdict:
             detail = f"{detail}\n\nGuardian: {verdict}"
@@ -307,6 +320,7 @@ def run_agent(
     max_steps: int | None = None,
     stream: bool = False,
     guardian=None,
+    mesh_fn=None,
     on_event=None,
 ) -> str:
     steps = max_steps if max_steps is not None else settings.max_steps
@@ -346,7 +360,7 @@ def run_agent(
             elif "__parse_error__" in args:
                 result = json.dumps({"error": "invalid JSON arguments"})
             elif meta.dangerous and not _approved(
-                name, args, interactive, auto_approve, renderer, guardian
+                name, args, interactive, auto_approve, renderer, guardian, mesh_fn
             ):
                 result = json.dumps({"error": "denied by user"})
             else:

{deepparallel-0.5.7 → deepparallel-0.7.0}/deepparallel/branding.py

@@ -173,6 +173,86 @@ def info(msg: str) -> None:
     console.print(f"[{DIM}]{msg}[/]")
 
 
+def upgrade_card(feature: str, current_tier: str, needed_tier: str, unlocks: str, url: str) -> None:
+    body = Text()
+    body.append(f"{feature} ", style=f"bold {DP_ACCENT}")
+    body.append("is a ", style="white")
+    body.append(needed_tier, style=f"bold {CROWE_ACCENT}")
+    body.append(" feature. You are on ", style="white")
+    body.append(f"{current_tier}", style=AMBER_HEX)
+    body.append(".\n\n", style="white")
+    body.append("Unlocks  ", style=DIM)
+    body.append(f"{unlocks}\n\n", style="white")
+    body.append(f"{ARROW} ", style=CROWE_ACCENT)
+    body.append("dp upgrade", style=f"bold {CROWE_ACCENT}")
+    body.append(f"   {url}", style=DIM)
+    console.print(
+        _gutter(
+            Panel(
+                body,
+                title=Text(f"{MARK} Upgrade to {needed_tier}", style=DP_ACCENT),
+                title_align="left",
+                border_style=AMBER_HEX,
+                box=box.ROUNDED,
+            )
+        )
+    )
+
+
+def license_panel(
+    title: str,
+    header_lines: list[tuple[str, str]],
+    rows: list[tuple[bool, str]],
+    footer_lines: list[str] | None = None,
+) -> None:
+    body = Text()
+    for label, value in header_lines:
+        body.append(f"{label:<9}", style=DIM)
+        body.append(f"{value}\n", style="white")
+    if rows:
+        body.append("\n")
+    for unlocked, desc in rows:
+        if unlocked:
+            body.append(f"{CHECK} ", style=GREEN_HEX)
+            body.append(f"{desc}\n", style="white")
+        else:
+            body.append(f"{CROSS} ", style=RED_HEX)
+            body.append(f"{desc}\n", style=DIM)
+    if footer_lines:
+        body.append("\n")
+        for line in footer_lines:
+            body.append(f"{line}\n", style=DIM)
+    console.print(
+        _gutter(
+            Panel(
+                body,
+                title=Text(f"{MARK} {title}", style=DP_ACCENT),
+                title_align="left",
+                border_style=DP_ACCENT,
+                box=box.ROUNDED,
+            )
+        )
+    )
+
+
+def first_run_banner() -> None:
+    body = Text()
+    body.append("You're on ", style=DIM)
+    body.append("Free", style=f"bold {AMBER_HEX}")
+    body.append(". Unlock Guardian, fusion, and the ", style=DIM)
+    body.append("--deep", style="white")
+    body.append(" council: ", style=DIM)
+    body.append("dp upgrade", style=f"bold {CROWE_ACCENT}")
+    console.print(_gutter(Panel(body, border_style=DP_ACCENT, box=box.ROUNDED)))
+
+
+def upgrade_link(url: str, opened: bool) -> None:
+    if opened:
+        console.print(f"[{DIM}]Opening your browser to DeepParallel pricing:[/] {url}")
+    else:
+        console.print(f"[{DIM}]Upgrade at[/] {url}")
+
+
 def error(msg: str) -> None:
     console.print(f"[bold red]error[/] {msg}")
 

{deepparallel-0.5.7 → deepparallel-0.7.0}/deepparallel/cli.py

@@ -58,6 +58,27 @@ from deepparallel.cockpit import Cockpit
 from deepparallel.cockpit_observe import make_observer
 
 
+_soft_cards_shown: set[str] = set()
+
+
+def require_feature(feature: str, *, hard: bool, exit_code: int = 3) -> bool:
+    have = licensing.resolve_tier()
+    if licensing.check_feature(feature, have)[0]:
+        return True
+    if hard or feature not in _soft_cards_shown:
+        branding.upgrade_card(
+            feature,
+            have.label,
+            licensing.feature_tier(feature).label,
+            licensing.feature_unlocks(feature),
+            licensing.upgrade_url(),
+        )
+    if hard:
+        sys.exit(exit_code)
+    _soft_cards_shown.add(feature)
+    return False
+
+
 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:
@@ -82,9 +103,7 @@ def _effective_backend(base: Backend, settings: Settings, mode: str) -> Backend:
     """
     if mode not in ("reason", "escalate"):
         return base
-    ok, msg = licensing.check_feature("fusion")
-    if not ok:
-        branding.info(msg)
+    if not require_feature("fusion", hard=False):
         return base
     reasoner = backend_for_deployment(settings, settings.reasoner_deployment)
     if mode == "reason":
@@ -100,10 +119,7 @@ def _wrap_fusion(backend: Backend, settings: Settings) -> Backend:
 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)
+    require_feature("deep", hard=True, exit_code=2)
     chains = [
         (f"candidate-{i + 1}", backend_for_deployment(settings, dep))
         for i, dep in enumerate(settings.parallel_deployments)
@@ -135,10 +151,7 @@ def _run_deep(settings: Settings, messages: list[dict]) -> None:
 
 
 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)
+    require_feature("dual", hard=True, exit_code=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]
@@ -170,13 +183,26 @@ def _build_guardian(settings: Settings) -> Backend | None:
     """
     if not settings.guardian_enabled:
         return None
-    ok, msg = licensing.check_feature("guardian")
-    if not ok:
-        branding.info(msg)
+    if not require_feature("guardian", hard=False):
         return None
     return backend_for_deployment(settings, settings.guardian_deployment)
 
 
+def _build_mesh(settings: Settings):
+    """The verification mesh: a parallel reviewer panel that gates every edit.
+
+    Supersedes the single guardian when available. Paid (Pro+) feature; returns
+    a callable ``mesh_fn(content) -> result`` or None on Free / when disabled.
+    """
+    if not settings.guardian_enabled:
+        return None
+    if not licensing.check_feature("mesh")[0]:
+        return None
+    from deepparallel import mesh
+
+    return lambda content: mesh.mesh_review(settings, content)
+
+
 def _system_prompt() -> str:
     """System prompt with the long-term memory index injected (recall tier 1)."""
     return load_system_prompt() + memory.index_block()
@@ -293,7 +319,8 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
     """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)
+    mesh_fn = _build_mesh(settings)
+    guardian = None if mesh_fn else _build_guardian(settings)
     system = _system_prompt()
     messages: list[dict] = [{"role": "system", "content": system}]
     mode = settings.fusion_mode if settings.fusion_mode in ("reason", "escalate") else "off"
@@ -385,6 +412,7 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
                 auto_approve=auto,
                 stream=True,
                 guardian=guardian,
+                mesh_fn=mesh_fn,
                 on_event=observer if cockpit_on else None,
             )
             if mode in ("reason", "escalate"):
@@ -421,6 +449,33 @@ def _chat_loop(settings: Settings) -> None:
         _stream_repl(_wrap_fusion(backend, settings), settings)
 
 
+_LICENSE_COMMANDS = {"activate", "deactivate", "upgrade", "account", "whoami"}
+
+
+def _is_interactive() -> bool:
+    return sys.stdout.isatty() and not _bool_env("DEEPPARALLEL_PLAIN", False)
+
+
+def _first_run_marker() -> Path:
+    return licensing.license_file_path().parent / ".first_run_shown"
+
+
+def _maybe_first_run_nudge() -> None:
+    if not _is_interactive():
+        return
+    if licensing.resolve_tier() is not licensing.Tier.FREE:
+        return
+    marker = _first_run_marker()
+    if marker.exists():
+        return
+    try:
+        marker.parent.mkdir(parents=True, exist_ok=True)
+        marker.write_text("shown\n")
+    except OSError:
+        pass
+    branding.first_run_banner()
+
+
 @click.group(
     invoke_without_command=True,
     context_settings={"help_option_names": ["-h", "--help"]},
@@ -441,6 +496,8 @@ def main(ctx: click.Context, temperature: float | None, assume_yes: bool) -> Non
     if assume_yes:
         settings = replace(settings, auto_approve=True)
     ctx.obj["settings"] = settings
+    if ctx.invoked_subcommand not in _LICENSE_COMMANDS:
+        _maybe_first_run_nudge()
     if ctx.invoked_subcommand is None:
         _chat_loop(settings)
 
@@ -463,6 +520,14 @@ def chat(ctx: click.Context, no_tools: bool, assume_yes: bool, fuse: str | None)
     _chat_loop(settings)
 
 
+@main.command()
+def tui() -> None:
+    """Launch the DeepParallel TUI (persistent multi-panel terminal interface)."""
+    from deepparallel.tui.app import run_tui
+
+    run_tui()
+
+
 @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.")
@@ -518,6 +583,7 @@ def run(
             renderer,
             interactive=False,
             auto_approve=settings.auto_approve,
+            mesh_fn=_build_mesh(settings),
         )
     except Exception as e:  # noqa: BLE001 - surface as friendly message
         branding.error(_translate_error(e))
@@ -598,10 +664,7 @@ def review(ctx: click.Context, as_diff: bool, path: str | None) -> None:
     """
     settings: Settings = ctx.obj["settings"]
     if not settings.byok:
-        ok, msg = licensing.check_feature("review")
-        if not ok:
-            branding.error(msg)
-            sys.exit(3)
+        require_feature("review", hard=True, exit_code=3)
     if as_diff:
         content = sys.stdin.read()
     elif path:
@@ -614,10 +677,25 @@ def review(ctx: click.Context, as_diff: bool, path: str | None) -> None:
         branding.error("provide a PATH or --diff (with a diff on stdin)")
         sys.exit(3)
     _require_ready(settings)  # validates creds / exits if missing
+    glyphs = {"safe": branding.CHECK, "risky": "!", "bug": branding.CROSS}
+    mesh_ok, _ = licensing.check_feature("mesh")
+    if mesh_ok and settings.guardian_enabled:
+        # Pro: the full verification mesh, one independent reviewer per lens.
+        from deepparallel import mesh as _mesh
+
+        result = _mesh.mesh_review(settings, content)
+        for r in result["lenses"]:
+            g = glyphs.get(r["severity"], "?")
+            console.print(f"  {g} [dim]{r['label']}[/] {r['verdict'] or '(no verdict)'}")
+        verdict = result["verdict"]
+        glyph = glyphs.get(result["severity"], "?")
+        console.print(f"[bold]{glyph} {result['severity'].upper()}[/] {verdict or '(no verdict)'}")
+        sys.exit(verdict_exit_code(verdict))
+    # Free / BYOK: a single independent reviewer.
     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, "?")
+    glyph = glyphs.get(severity, "?")
     console.print(f"[bold]{glyph} {severity.upper()}[/] {verdict or '(no verdict)'}")
     sys.exit(verdict_exit_code(verdict))
 
@@ -648,10 +726,7 @@ def audit(ctx: click.Context, path: str) -> None:
     seen) in source files and manifests. Exit code: 0 clean, 2 if a likely
     hallucinated dependency is found - so it can gate a commit or PR. Paid (Pro+).
     """
-    ok, msg = licensing.check_feature("audit")
-    if not ok:
-        branding.error(msg)
-        sys.exit(3)
+    require_feature("audit", hard=True, exit_code=3)
     try:
         content = Path(path).expanduser().read_text(encoding="utf-8")
     except OSError as e:
@@ -726,6 +801,47 @@ def research_conduit() -> None:
     )
 
 
+@research.command("compound-discovery")
+@click.option("--target", default="EGFR", help="Biological target (gene symbol).")
+@click.option(
+    "--compounds",
+    default="erlotinib,gefitinib,osimertinib",
+    help="Comma-separated compound names.",
+)
+@click.option("--dry-run", is_flag=True, help="Print the MCP tool call manifest.")
+@click.option("--output", default=None, help="Output report path (Markdown + JSON).")
+def research_compound_discovery(
+    target: str, compounds: str, dry_run: bool, output: str | None
+) -> None:
+    """PubChem compound discovery workflow across 10 stages.
+
+    Generates a full intelligence report: target assays, compound profiling,
+    bioactivity, safety, interactions, 3D structure, cross-references, and
+    analog discovery. Uses PubChem MCP tools when available; --dry-run prints
+    the tool call manifest without executing.
+    """
+    from deepparallel.research.compound_discovery import (
+        generate_markdown_report,
+        run_dry_run,
+        run_workflow,
+    )
+
+    compound_list = [c.strip() for c in compounds.split(",")]
+    if dry_run:
+        console.print(run_dry_run(target, compound_list))
+        return
+    result = run_workflow(target, compound_list)
+    report = generate_markdown_report(result)
+    print(report)
+    if output:
+        path = Path(output)
+        path.write_text(report)
+        json_path = path.with_suffix(".json")
+        json_path.write_text(result.to_json())
+        branding.info(f"Report written to {path}")
+        branding.info(f"JSON data written to {json_path}")
+
+
 @main.command(name="tools")
 def tools_cmd() -> None:
     """List the agent tools available to DeepParallel."""
@@ -787,5 +903,105 @@ def doctor(ctx: click.Context) -> None:
         sys.exit(1)
 
 
+def _format_exp(payload: dict) -> str:
+    exp = int(payload.get("exp") or 0)
+    if not exp:
+        return "no expiry"
+    import datetime
+
+    return datetime.datetime.fromtimestamp(exp).strftime("%Y-%m-%d")
+
+
+def _show_account(settings: Settings) -> None:
+    source, payload = licensing.active_license()
+    tier = licensing.resolve_tier()
+    if source == "env":
+        src_label = "DEEPPARALLEL_LICENSE env var"
+    elif source == "file":
+        src_label = str(licensing.license_file_path())
+    else:
+        src_label = "none"
+    if source != "none" and payload is None:
+        src_label += " (invalid or expired)"
+    header = [("Tier", tier.label), ("Source", src_label)]
+    if payload and payload.get("email"):
+        header.append(("Account", str(payload["email"])))
+    if payload:
+        header.append(("Expires", _format_exp(payload)))
+    rows = [(unlocked, desc) for _f, desc, _need, unlocked in licensing.features_matrix(tier)]
+    footer = None
+    if tier is licensing.Tier.FREE:
+        footer = ["Unlock Guardian, fusion, and the --deep council: dp upgrade"]
+    branding.license_panel("DeepParallel account", header, rows, footer)
+
+
+@main.command()
+@click.argument("key", required=True)
+@click.pass_context
+def activate(ctx: click.Context, key: str) -> None:
+    payload = licensing.verify_token(key.strip())
+    if not payload:
+        branding.error(
+            "that license key is invalid or expired. Copy it exactly from your "
+            "purchase email, or run dp upgrade to buy one."
+        )
+        sys.exit(2)
+    tier = licensing.tier_from_payload(payload)
+    try:
+        path = licensing.write_license(key)
+    except OSError as e:
+        branding.error(f"could not write the license file: {e}")
+        sys.exit(1)
+    header = [("Tier", tier.label)]
+    if payload.get("email"):
+        header.append(("Account", str(payload["email"])))
+    header.append(("Expires", _format_exp(payload)))
+    header.append(("License", str(path)))
+    rows = [(unlocked, desc) for _f, desc, _need, unlocked in licensing.features_matrix(tier)]
+    branding.license_panel("License activated", header, rows)
+
+
+@main.command()
+@click.pass_context
+def account(ctx: click.Context) -> None:
+    _show_account(ctx.obj["settings"])
+
+
+@main.command()
+@click.pass_context
+def whoami(ctx: click.Context) -> None:
+    _show_account(ctx.obj["settings"])
+
+
+@main.command()
+@click.option("--yes", "-y", "assume_yes", is_flag=True, help="Skip the confirmation prompt.")
+@click.pass_context
+def deactivate(ctx: click.Context, assume_yes: bool) -> None:
+    path = licensing.license_file_path()
+    if not path.exists():
+        branding.info("no stored license; already on Free.")
+        return
+    if not assume_yes and not click.confirm(f"Remove the license at {path} and revert to Free?"):
+        branding.info("kept the current license.")
+        return
+    if licensing.remove_license():
+        branding.info("license removed; you are now on Free.")
+    else:
+        branding.error("could not remove the license file.")
+        sys.exit(1)
+
+
+@main.command()
+def upgrade() -> None:
+    import webbrowser
+
+    url = licensing.upgrade_url()
+    try:
+        opened = bool(webbrowser.open(url))
+    except Exception:
+        opened = False
+    branding.upgrade_link(url, opened)
+
+
 if __name__ == "__main__":
     main()