deepparallel 0.6.0__tar.gz → 0.7.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.6.0
+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.6.0 → deepparallel-0.7.0}/deepparallel/__init__.py

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

{deepparallel-0.6.0 → 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.6.0 → 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,9 +183,7 @@ 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)
 
@@ -185,8 +196,7 @@ def _build_mesh(settings: Settings):
     """
     if not settings.guardian_enabled:
         return None
-    ok, _ = licensing.check_feature("mesh")
-    if not ok:
+    if not licensing.check_feature("mesh")[0]:
         return None
     from deepparallel import mesh
 
@@ -439,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"]},
@@ -459,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)
 
@@ -481,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.")
@@ -617,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:
@@ -682,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:
@@ -760,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."""
@@ -821,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()

{deepparallel-0.6.0 → deepparallel-0.7.0}/deepparallel/licensing.py

@@ -24,12 +24,9 @@ import time
 from enum import IntEnum
 from pathlib import Path
 
-# Issuer public key (Ed25519, raw, base64). The matching private key is the
-# issuance secret and is never shipped.
 _EMBEDDED_PUBKEY = "BdxSRIB5F2K2bXf7c0UqsR6jC/cSRMSxojpzRpTCUQg="
 
-# Paid features -> minimum tier required.
-_FEATURE_TIER: dict[str, "Tier"] = {}
+DEFAULT_PRICING_URL = "https://deepparallel.dev/pricing"
 
 
 class Tier(IntEnum):
@@ -42,12 +39,24 @@ class Tier(IntEnum):
         return {0: "Free", 1: "Pro", 2: "Team"}[int(self)]
 
 
+FEATURE_INFO: dict[str, tuple["Tier", str]] = {
+    "fusion": (Tier.PRO, "Reasoner-plus-answerer fusion (//fuse, //escalate)"),
+    "deep": (Tier.PRO, "The --deep multi-model council with a judge"),
+    "dual": (Tier.PRO, "Side-by-side dual-model compare (--dual)"),
+    "guardian": (Tier.PRO, "Guardian edit review before changes apply"),
+    "mesh": (Tier.PRO, "Verification mesh: a parallel reviewer panel per edit"),
+    "review": (Tier.PRO, "Hosted cross-model code review gate (dp review)"),
+    "audit": (Tier.PRO, "Supply-chain audit gate for hallucinated deps (dp audit)"),
+}
+
+_FEATURE_TIER: dict[str, "Tier"] = {name: tier for name, (tier, _desc) in FEATURE_INFO.items()}
+
+
 def _b64url_decode(s: str) -> bytes:
     return base64.urlsafe_b64decode(s + "=" * (-len(s) % 4))
 
 
 def verify_token(token: str, pubkey_b64: str | None = None) -> dict | None:
-    """Return the payload dict if the token is validly signed and unexpired."""
     if not token or "." not in token:
         return None
     try:
@@ -58,7 +67,7 @@ def verify_token(token: str, pubkey_b64: str | None = None) -> dict | None:
     try:
         pub = Ed25519PublicKey.from_public_bytes(_b64url_decode(pubkey_b64 or _EMBEDDED_PUBKEY))
         pub.verify(_b64url_decode(sig), body.encode())
-    except Exception:  # noqa: BLE001 - any failure (bad sig/key/encoding) = invalid
+    except Exception:
         return None
     try:
         payload = json.loads(_b64url_decode(body))
@@ -71,11 +80,6 @@ def verify_token(token: str, pubkey_b64: str | None = None) -> dict | None:
 
 
 def sign_token(payload: dict, private_key_b64: str) -> str:
-    """Sign a license payload into a `body.signature` token (issuer-side).
-
-    Requires the private issuance key; verify_token() checks it with the public
-    key. Used by the license-issuer (Stripe webhook) and the admin CLI.
-    """
     from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
 
     priv = Ed25519PrivateKey.from_private_bytes(_b64url_decode_std(private_key_b64))
@@ -85,35 +89,39 @@ def sign_token(payload: dict, private_key_b64: str) -> str:
 
 
 def _b64url_decode_std(s: str) -> bytes:
-    """Decode standard OR url-safe base64 (keys are emitted as standard b64)."""
     s = s.strip()
     pad = "=" * (-len(s) % 4)
     try:
         return base64.b64decode(s + pad)
-    except Exception:  # noqa: BLE001
+    except Exception:
         return base64.urlsafe_b64decode(s + pad)
 
 
-def _license_file_token() -> str | None:
-    path = Path(
+def license_file_path() -> Path:
+    return Path(
         os.environ.get("DEEPPARALLEL_LICENSE_FILE", "~/.config/deepparallel/license")
     ).expanduser()
+
+
+def _license_file_token() -> str | None:
     try:
-        return path.read_text().strip() or None
+        return license_file_path().read_text().strip() or None
     except OSError:
         return None
 
 
+def tier_from_payload(payload: dict | None) -> Tier:
+    if not payload:
+        return Tier.FREE
+    name = str(payload.get("tier", "")).upper()
+    return Tier[name] if name in Tier.__members__ else Tier.FREE
+
+
 def resolve_tier() -> Tier:
-    """Resolve the active tier from the license env var or file. FREE on absence/failure."""
     token = os.environ.get("DEEPPARALLEL_LICENSE") or _license_file_token()
     if not token:
         return Tier.FREE
-    payload = verify_token(token)
-    if not payload:
-        return Tier.FREE
-    name = str(payload.get("tier", "")).upper()
-    return getattr(Tier, name, Tier.FREE) if name in Tier.__members__ else Tier.FREE
+    return tier_from_payload(verify_token(token))
 
 
 def tier_allows(have: Tier, need: Tier) -> bool:
@@ -121,12 +129,69 @@ def tier_allows(have: Tier, need: Tier) -> bool:
 
 
 def check_feature(feature: str, have: Tier | None = None) -> tuple[bool, str]:
-    """Return (allowed, message). Paid features need PRO+; message nudges upgrade."""
     have = resolve_tier() if have is None else have
     need = _FEATURE_TIER.get(feature, Tier.PRO)
     if tier_allows(have, need):
         return True, ""
     return False, (
         f"{feature} requires DeepParallel {need.label} (you are on {have.label}). "
-        f"Upgrade at https://deepparallel.dev/pricing"
+        f"Upgrade at {upgrade_url()}"
     )
+
+
+def feature_tier(feature: str) -> Tier:
+    return _FEATURE_TIER.get(feature, Tier.PRO)
+
+
+def feature_unlocks(feature: str) -> str:
+    info = FEATURE_INFO.get(feature)
+    return info[1] if info else feature
+
+
+def features_matrix(have: Tier | None = None) -> list[tuple[str, str, Tier, bool]]:
+    have = resolve_tier() if have is None else have
+    return [
+        (feature, desc, need, tier_allows(have, need))
+        for feature, (need, desc) in FEATURE_INFO.items()
+    ]
+
+
+def upgrade_url() -> str:
+    return (
+        os.environ.get("DEEPPARALLEL_CHECKOUT_URL")
+        or os.environ.get("DEEPPARALLEL_PRICING_URL")
+        or DEFAULT_PRICING_URL
+    )
+
+
+def write_license(token: str) -> Path:
+    path = license_file_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        os.chmod(path.parent, 0o700)
+    except OSError:
+        pass
+    path.write_text(token.strip() + "\n")
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+    return path
+
+
+def remove_license() -> bool:
+    try:
+        license_file_path().unlink()
+        return True
+    except (FileNotFoundError, OSError):
+        return False
+
+
+def active_license() -> tuple[str, dict | None]:
+    env_token = os.environ.get("DEEPPARALLEL_LICENSE")
+    if env_token:
+        return "env", verify_token(env_token)
+    file_token = _license_file_token()
+    if file_token:
+        return "file", verify_token(file_token)
+    return "none", None