pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/cli/plugin.py

@@ -0,0 +1,351 @@
+"""CLI commands for plugin management."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from pythinker_code.plugin import PluginError
+
+cli = typer.Typer(help="Manage plugins.")
+
+
+def _parse_git_url(target: str) -> tuple[str, str | None, str | None]:
+    """Parse a git URL into (clone_url, subpath, branch).
+
+    Splits .git URLs at the .git boundary. For GitHub/GitLab short URLs,
+    treats the first two path segments as owner/repo and the rest as subpath.
+    Strips ``tree/{branch}/`` or ``-/tree/{branch}/`` prefixes from
+    browser-copied URLs and returns the branch name.
+    """
+    # Path 1: URL contains .git followed by / or end-of-string
+    idx = target.find(".git/")
+    if idx == -1 and target.endswith(".git"):
+        return target, None, None
+    if idx != -1:
+        clone_url = target[: idx + 4]  # up to and including ".git"
+        rest = target[idx + 5 :]  # after ".git/"
+        subpath = rest.strip("/") or None
+        return clone_url, subpath, None
+
+    # Path 2: GitHub/GitLab short URL (no .git)
+    from urllib.parse import urlparse
+
+    parsed = urlparse(target)
+    segments = [s for s in parsed.path.split("/") if s]
+    if len(segments) < 2:
+        return target, None, None
+
+    owner_repo = "/".join(segments[:2])
+    clone_url = f"{parsed.scheme}://{parsed.netloc}/{owner_repo}"
+    rest_segments = segments[2:]
+
+    # GitLab uses /-/tree/{branch}/, strip leading "-"
+    if rest_segments and rest_segments[0] == "-":
+        rest_segments = rest_segments[1:]
+
+    # Strip tree/{branch}/ prefix and extract branch
+    branch: str | None = None
+    if len(rest_segments) >= 2 and rest_segments[0] == "tree":
+        branch = rest_segments[1]
+        rest_segments = rest_segments[2:]
+
+    subpath = "/".join(rest_segments) or None
+    return clone_url, subpath, branch
+
+
+def _extract_zip_to_plugin(zip_path: Path, tmp: Path) -> tuple[Path, Path]:
+    """Extract zip_path into tmp and locate the plugin directory.
+
+    Returns ``(plugin_dir, tmp)`` for cleanup by the caller. Rejects zip
+    members whose paths escape ``tmp``. Searches the extraction root and
+    one level deep for ``plugin.json``.
+    """
+    import shutil
+    import zipfile
+
+    try:
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            for member in zf.namelist():
+                member_path = (tmp / member).resolve()
+                if not member_path.is_relative_to(tmp.resolve()):
+                    shutil.rmtree(tmp, ignore_errors=True)
+                    typer.echo(f"Error: zip contains unsafe path: {member}", err=True)
+                    raise typer.Exit(1)
+            zf.extractall(tmp)
+    except zipfile.BadZipFile as exc:
+        shutil.rmtree(tmp, ignore_errors=True)
+        typer.echo(f"Error: invalid zip archive: {exc}", err=True)
+        raise typer.Exit(1) from exc
+
+    for candidate in [tmp] + sorted(tmp.iterdir()):
+        if candidate.is_dir() and (candidate / "plugin.json").exists():
+            return candidate, tmp
+    dirs = [d for d in tmp.iterdir() if d.is_dir() and not d.name.startswith("_")]
+    if len(dirs) == 1 and (dirs[0] / "plugin.json").exists():
+        return dirs[0], tmp
+
+    shutil.rmtree(tmp, ignore_errors=True)
+    typer.echo("Error: No plugin.json found in zip", err=True)
+    raise typer.Exit(1)
+
+
+def _resolve_source(target: str) -> tuple[Path, Path | None]:
+    """Resolve plugin source to (local_dir, tmp_to_cleanup).
+
+    Returns the source directory and an optional temp directory that
+    the caller must clean up after use.
+    """
+    import shutil
+    import tempfile
+    from urllib.parse import urlparse
+
+    # HTTP(S) URL pointing to a .zip — download then extract.
+    # Checked before the git-URL branch so GitHub/GitLab archive links
+    # like .../archive/refs/heads/main.zip take this path.
+    parsed = urlparse(target)
+    if parsed.scheme in ("http", "https") and parsed.path.lower().endswith(".zip"):
+        import httpx
+
+        tmp = Path(tempfile.mkdtemp(prefix="pythinker-plugin-"))
+        zip_path = tmp / "_download.zip"
+        typer.echo(f"Downloading {target}...")
+        try:
+            with httpx.stream("GET", target, follow_redirects=True, timeout=60.0) as resp:
+                resp.raise_for_status()
+                with zip_path.open("wb") as f:
+                    for chunk in resp.iter_bytes():
+                        f.write(chunk)
+        except httpx.HTTPError as exc:
+            shutil.rmtree(tmp, ignore_errors=True)
+            typer.echo(f"Error: download failed: {exc}", err=True)
+            raise typer.Exit(1) from exc
+
+        return _extract_zip_to_plugin(zip_path, tmp)
+
+    # Git URL
+    if target.startswith(("https://", "git@", "http://")) and (
+        ".git/" in target
+        or target.endswith(".git")
+        or "github.com/" in target
+        or "gitlab.com/" in target
+    ):
+        import subprocess
+
+        clone_url, subpath, branch = _parse_git_url(target)
+
+        tmp = Path(tempfile.mkdtemp(prefix="pythinker-plugin-"))
+        typer.echo(f"Cloning {clone_url}...")
+        clone_cmd = ["git", "clone", "--depth", "1"]
+        if branch:
+            clone_cmd += ["--branch", branch]
+        clone_cmd += [clone_url, str(tmp / "repo")]
+        result = subprocess.run(
+            clone_cmd,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+        if result.returncode != 0:
+            shutil.rmtree(tmp, ignore_errors=True)
+            typer.echo(
+                f"Error: git clone failed: {result.stderr.strip()}",
+                err=True,
+            )
+            raise typer.Exit(1)
+
+        repo_root = tmp / "repo"
+
+        if subpath:
+            source = (repo_root / subpath).resolve()
+            if not source.is_relative_to(repo_root.resolve()):
+                shutil.rmtree(tmp, ignore_errors=True)
+                typer.echo(
+                    f"Error: subpath escapes repository: {subpath}",
+                    err=True,
+                )
+                raise typer.Exit(1)
+            if not source.is_dir():
+                shutil.rmtree(tmp, ignore_errors=True)
+                typer.echo(
+                    f"Error: subpath '{subpath}' not found in repository",
+                    err=True,
+                )
+                raise typer.Exit(1)
+            if not (source / "plugin.json").exists():
+                shutil.rmtree(tmp, ignore_errors=True)
+                typer.echo(
+                    f"Error: no plugin.json in '{subpath}'",
+                    err=True,
+                )
+                raise typer.Exit(1)
+            return source, tmp
+
+        # No subpath — check root first
+        if (repo_root / "plugin.json").exists():
+            return repo_root, tmp
+
+        # Scan one level for available plugins
+        available = sorted(
+            d.name for d in repo_root.iterdir() if d.is_dir() and (d / "plugin.json").exists()
+        )
+        if available:
+            names = "\n".join(f"  - {n}" for n in available)
+            typer.echo(
+                f"Error: No plugin.json at repository root. "
+                f"Available plugins:\n{names}\n"
+                f"Use: pythinker plugin install <url>/<plugin-name>",
+                err=True,
+            )
+        else:
+            typer.echo(
+                "Error: No plugin.json found in repository",
+                err=True,
+            )
+        shutil.rmtree(tmp, ignore_errors=True)
+        raise typer.Exit(1)
+
+    p = Path(target).expanduser().resolve()
+
+    # Zip file
+    if p.is_file() and p.suffix == ".zip":
+        tmp = Path(tempfile.mkdtemp(prefix="pythinker-plugin-"))
+        typer.echo(f"Extracting {p.name}...")
+        return _extract_zip_to_plugin(p, tmp)
+
+    # Local directory
+    if p.is_dir():
+        return p, None
+
+    typer.echo(
+        f"Error: {target} is not a directory, zip file, zip URL, or git URL",
+        err=True,
+    )
+    raise typer.Exit(1)
+
+
+@cli.command("install")
+def install_cmd(
+    target: Annotated[
+        str,
+        typer.Argument(help="Plugin source: directory, .zip file, .zip URL, or git URL"),
+    ],
+) -> None:
+    """Install a plugin and inject host configuration."""
+    import shutil
+
+    from pythinker_code.config import load_config
+    from pythinker_code.constant import VERSION
+    from pythinker_code.plugin.manager import get_plugins_dir, install_plugin
+
+    source, tmp_dir = _resolve_source(target)
+
+    try:
+        config = load_config()
+
+        from pythinker_code.auth.oauth import OAuthManager
+        from pythinker_code.llm import augment_provider_with_env_vars
+        from pythinker_code.plugin.manager import collect_host_values
+
+        # Apply env var overrides (install runs outside normal startup)
+        if config.default_model and config.default_model in config.models:
+            model = config.models[config.default_model]
+            if model.provider in config.providers:
+                augment_provider_with_env_vars(
+                    config.providers[model.provider], model, provider_key=model.provider
+                )
+
+        oauth = OAuthManager(config)
+        host_values = collect_host_values(config, oauth)
+
+        if not host_values.get("api_key"):
+            typer.echo(
+                "Warning: No LLM provider configured. "
+                "Plugins requiring API key injection will fail. "
+                "Run 'pythinker login' or configure a provider first.",
+                err=True,
+            )
+
+        spec = install_plugin(
+            source=source,
+            plugins_dir=get_plugins_dir(),
+            host_values=host_values,
+            host_name="pythinker-code",
+            host_version=VERSION,
+        )
+    except PluginError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+    finally:
+        # Clean up temp directory from zip/git extraction
+        if tmp_dir is not None:
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+
+    typer.echo(f"Installed plugin '{spec.name}' v{spec.version}")
+    if spec.runtime:
+        typer.echo(f"  runtime: host={spec.runtime.host}, version={spec.runtime.host_version}")
+
+
+@cli.command("list")
+def list_cmd() -> None:
+    """List installed plugins."""
+    from pythinker_code.plugin.manager import get_plugins_dir, list_plugins
+
+    plugins = list_plugins(get_plugins_dir())
+    if not plugins:
+        typer.echo("No plugins installed.")
+        return
+
+    for p in plugins:
+        status = "installed" if p.runtime else "not configured"
+        typer.echo(f"  {p.name} v{p.version} ({status})")
+
+
+@cli.command("remove")
+def remove_cmd(
+    name: Annotated[str, typer.Argument(help="Plugin name to remove")],
+) -> None:
+    """Remove an installed plugin."""
+    from pythinker_code.plugin.manager import get_plugins_dir, remove_plugin
+
+    try:
+        remove_plugin(name, get_plugins_dir())
+    except PluginError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+
+    typer.echo(f"Removed plugin '{name}'")
+
+
+@cli.command("info")
+def info_cmd(
+    name: Annotated[str, typer.Argument(help="Plugin name")],
+) -> None:
+    """Show plugin details."""
+    from pythinker_code.plugin import parse_plugin_json
+    from pythinker_code.plugin.manager import get_plugins_dir
+
+    plugin_json = get_plugins_dir() / name / "plugin.json"
+    if not plugin_json.exists():
+        typer.echo(f"Error: Plugin '{name}' not found", err=True)
+        raise typer.Exit(1)
+
+    try:
+        spec = parse_plugin_json(plugin_json)
+    except PluginError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+
+    typer.echo(f"Name:        {spec.name}")
+    typer.echo(f"Version:     {spec.version}")
+    typer.echo(f"Description: {spec.description or '(none)'}")
+    typer.echo(f"Config file: {spec.config_file or '(none)'}")
+    if spec.inject:
+        typer.echo(f"Inject:      {', '.join(f'{k} <- {v}' for k, v in spec.inject.items())}")
+    if spec.runtime:
+        typer.echo(f"Runtime:     host={spec.runtime.host}, version={spec.runtime.host_version}")
+    else:
+        typer.echo("Runtime:     (not installed via host)")

pythinker_code/cli/review.py

@@ -0,0 +1,74 @@
+"""`pythinker review` — delegates to pythinker-review with active-model wiring."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Any, cast
+
+from pydantic import SecretStr
+from pythinker_review.cli import review as upstream_review
+from pythinker_review.llm.protocol import ReviewLLM
+
+cli = upstream_review.app
+
+
+@dataclass(slots=True)
+class PythinkerActiveLLM:
+    """Bridge pythinker-core's configured provider to the ReviewLLM protocol."""
+
+    chat_provider: Any
+    model_display_name: str
+
+    async def complete_json(self, *, system: str, user: str, timeout_s: float) -> str:
+        from pythinker_core import generate
+        from pythinker_core.message import Message
+        from pythinker_core.tooling.empty import EmptyToolset
+
+        result = await asyncio.wait_for(
+            generate(
+                self.chat_provider,
+                system,
+                EmptyToolset().tools,
+                [Message(role="user", content=user)],
+            ),
+            timeout=timeout_s,
+        )
+        return result.message.extract_text()
+
+
+def build_active_llm(*, model_name: str | None = None) -> ReviewLLM | None:
+    """Build a ReviewLLM from the current Pythinker config, returning None when unset."""
+    from pythinker_code.auth.oauth import OAuthManager
+    from pythinker_code.config import LLMModel, LLMProvider, load_config
+    from pythinker_code.llm import augment_provider_with_env_vars, create_llm, model_display_name
+
+    config = load_config()
+    selected = model_name or config.default_model
+    if selected and selected in config.models:
+        model = config.models[selected].model_copy(deep=True)
+        provider = config.providers[model.provider].model_copy(deep=True)
+    else:
+        model = LLMModel(provider="", model="", max_context_size=100_000)
+        provider = LLMProvider(type="pythinker", base_url="", api_key=SecretStr(""))
+    augment_provider_with_env_vars(provider, model, provider_key=model.provider)
+    llm = create_llm(
+        provider,
+        model,
+        thinking=config.default_thinking,
+        session_id=None,
+        oauth=OAuthManager(config),
+    )
+    if llm is None:
+        return None
+    display = model_display_name(model.model, model)
+    return PythinkerActiveLLM(
+        chat_provider=cast(Any, llm.chat_provider), model_display_name=display
+    )
+
+
+def _resolve_llm_with_active_model() -> ReviewLLM | None:
+    return build_active_llm()
+
+
+upstream_review.set_llm_resolver(_resolve_llm_with_active_model)

pythinker_code/cli/secscan.py

@@ -0,0 +1,11 @@
+"""`pythinker secscan` — active-model wrapper for pythinker-secscan."""
+
+from __future__ import annotations
+
+from pythinker_review.cli import secscan as upstream_secscan
+
+# Importing review installs the active-model resolver used by secscan.
+from pythinker_code.cli import review as review_wrapper
+
+_REVIEW_CLI = review_wrapper.cli
+cli = upstream_secscan.app

pythinker_code/cli/security_scan.py

@@ -0,0 +1,35 @@
+"""`pythinker security-scan` — active-model wrapper for Python-native Pythinker Security Scan."""
+
+from __future__ import annotations
+
+import os
+
+import typer
+from pythinker_review.cli import security_scan as upstream_security_scan
+from pythinker_review.llm.fake import FakeReviewLLM
+from pythinker_review.llm.protocol import ReviewLLM
+
+# Importing review installs the active-model resolver shared by review/secscan.
+from pythinker_code.cli import review as review_wrapper
+
+_REVIEW_CLI = review_wrapper.cli
+cli = upstream_security_scan.app
+
+
+def _resolve_security_scan_llm() -> ReviewLLM:
+    adapter = review_wrapper.build_active_llm()
+    if adapter is not None:
+        return adapter
+    fake = os.environ.get("PYTHINKER_REVIEW_FAKE_LLM_RESPONSES")
+    if fake is not None:
+        return FakeReviewLLM(scripted=fake.split("\0") if fake else ["[]"])
+    typer.secho(
+        "No active model configured. Set PYTHINKER_REVIEW_FAKE_LLM_RESPONSES for tests, "
+        "or configure a Pythinker model before running `pythinker security-scan`.",
+        fg=typer.colors.RED,
+        err=True,
+    )
+    raise typer.Exit(code=3)
+
+
+upstream_security_scan.__dict__["_resolve_llm"] = _resolve_security_scan_llm

pythinker_code/cli/toad.py

@@ -0,0 +1,74 @@
+import importlib.util
+import shlex
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+
+
+def _default_acp_command() -> list[str]:
+    argv0 = sys.argv[0]
+    if argv0:
+        resolved = shutil.which(argv0)
+        resolved_path = Path(resolved).expanduser() if resolved else Path(argv0).expanduser()
+        if (
+            resolved_path.exists()
+            and resolved_path.suffix != ".py"
+            and not resolved_path.name.startswith(("python", "pypy"))
+        ):
+            return [str(resolved_path), "acp"]
+
+    return [sys.executable, "-m", "pythinker_code.cli", "acp"]
+
+
+def _default_toad_command() -> list[str]:
+    if sys.version_info < (3, 14):
+        typer.echo("`pythinker term` requires Python 3.14+ because Toad requires it.", err=True)
+        raise typer.Exit(code=1)
+    if importlib.util.find_spec("toad") is None:
+        typer.echo(
+            "Toad dependency is missing. Install pythinker-code with Python 3.14+ "
+            "to use `pythinker term`.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+    return [sys.executable, "-m", "toad.cli"]
+
+
+def _extract_project_dir(extra_args: list[str]) -> Path | None:
+    work_dir: str | None = None
+    idx = 0
+    while idx < len(extra_args):
+        arg = extra_args[idx]
+        if arg in ("--work-dir", "-w"):
+            if idx + 1 < len(extra_args):
+                work_dir = extra_args[idx + 1]
+                idx += 2
+                continue
+        elif arg.startswith("--work-dir=") or arg.startswith("-w="):
+            work_dir = arg.split("=", 1)[1]
+        elif arg.startswith("-w") and len(arg) > 2:
+            work_dir = arg[2:]
+        idx += 1
+
+    if not work_dir:
+        return None
+
+    return Path(work_dir).expanduser().resolve()
+
+
+def run_term(ctx: typer.Context) -> None:
+    extra_args = list(ctx.args)
+    acp_args = _default_acp_command()
+    acp_command = shlex.join(acp_args)
+    toad_parts = _default_toad_command()
+    args = [*toad_parts, "acp", acp_command]
+    project_dir = _extract_project_dir(extra_args)
+    if project_dir is not None:
+        args.append(str(project_dir))
+
+    result = subprocess.run(args)
+    if result.returncode != 0:
+        raise typer.Exit(code=result.returncode)

pythinker_code/cli/update.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+cli = typer.Typer(help="Check for and install Pythinker CLI updates.")
+
+
+@cli.callback(invoke_without_command=True)
+def update(
+    check_only: Annotated[
+        bool,
+        typer.Option(
+            "--check",
+            help="Only check whether an update is available; don't install.",
+        ),
+    ] = False,
+):
+    """Check for and install Pythinker CLI updates."""
+    from pythinker_code.ui.shell.update import UpdateResult, do_update
+
+    result = asyncio.run(do_update(print=True, check_only=check_only))
+    if result in (UpdateResult.FAILED, UpdateResult.UNSUPPORTED):
+        raise typer.Exit(1)

pythinker_code/cli/vis.py

@@ -0,0 +1,38 @@
+"""Vis command for Pythinker Agent Tracing Visualizer."""
+
+from typing import Annotated
+
+import typer
+
+cli = typer.Typer(help="Run Pythinker Agent Tracing Visualizer.")
+
+
+@cli.callback(invoke_without_command=True)
+def vis(
+    ctx: typer.Context,
+    host: Annotated[
+        str | None,
+        typer.Option("--host", "-h", help="Bind to specific IP address"),
+    ] = None,
+    network: Annotated[
+        bool,
+        typer.Option("--network", "-n", help="Enable network access (bind to 0.0.0.0)"),
+    ] = False,
+    port: Annotated[int, typer.Option("--port", "-p", help="Port to bind to")] = 5495,
+    open_browser: Annotated[
+        bool, typer.Option("--open/--no-open", help="Open browser automatically")
+    ] = True,
+    reload: Annotated[bool, typer.Option("--reload", help="Enable auto-reload")] = False,
+):
+    """Launch the agent tracing visualizer."""
+    from pythinker_code.vis.app import run_vis_server
+
+    # Determine bind address (same logic as pythinker web)
+    if host:
+        bind_host = host
+    elif network:
+        bind_host = "0.0.0.0"
+    else:
+        bind_host = "127.0.0.1"
+
+    run_vis_server(host=bind_host, port=port, open_browser=open_browser, reload=reload)

pythinker_code/cli/web.py

@@ -0,0 +1,80 @@
+"""Web UI command for Pythinker CLI."""
+
+from typing import Annotated
+
+import typer
+
+cli = typer.Typer(help="Run Pythinker CLI web interface.")
+
+
+@cli.callback(invoke_without_command=True)
+def web(
+    ctx: typer.Context,
+    host: Annotated[
+        str | None,
+        typer.Option("--host", "-h", help="Bind to specific IP address"),
+    ] = None,
+    network: Annotated[
+        bool,
+        typer.Option("--network", "-n", help="Enable network access (bind to 0.0.0.0)"),
+    ] = False,
+    port: Annotated[int, typer.Option("--port", "-p", help="Port to bind to")] = 5494,
+    reload: Annotated[bool, typer.Option("--reload", help="Enable auto-reload")] = False,
+    open_browser: Annotated[
+        bool, typer.Option("--open/--no-open", help="Open browser automatically")
+    ] = True,
+    auth_token: Annotated[
+        str | None,
+        typer.Option("--auth-token", help="Bearer token for API authentication."),
+    ] = None,
+    allowed_origins: Annotated[
+        str | None,
+        typer.Option(
+            "--allowed-origins",
+            help="Comma-separated list of allowed Origin values.",
+        ),
+    ] = None,
+    dangerously_omit_auth: Annotated[
+        bool,
+        typer.Option(
+            "--dangerously-omit-auth",
+            help="Disable auth checks (dangerous in public networks).",
+        ),
+    ] = False,
+    restrict_sensitive_apis: Annotated[
+        bool | None,
+        typer.Option(
+            "--restrict-sensitive-apis/--no-restrict-sensitive-apis",
+            help="Disable sensitive APIs (config write, open-in, file access limits).",
+        ),
+    ] = None,
+    lan_only: Annotated[
+        bool,
+        typer.Option(
+            "--lan-only/--public",
+            help="Only allow access from local network (default) or allow public access.",
+        ),
+    ] = True,
+):
+    """Run Pythinker CLI web interface."""
+    from pythinker_code.web.app import run_web_server
+
+    # Determine bind address
+    if host:
+        bind_host = host
+    elif network:
+        bind_host = "0.0.0.0"
+    else:
+        bind_host = "127.0.0.1"
+
+    run_web_server(
+        host=bind_host,
+        port=port,
+        reload=reload,
+        open_browser=open_browser,
+        auth_token=auth_token,
+        allowed_origins=allowed_origins,
+        dangerously_omit_auth=dangerously_omit_auth,
+        restrict_sensitive_apis=restrict_sensitive_apis,
+        lan_only=lan_only,
+    )