pythinker-code 2.0.0__py3-none-any.whl

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/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,
+    )

pythinker_code/config.py

@@ -0,0 +1,453 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Literal, Self
+
+import tomlkit
+from pydantic import (
+    AliasChoices,
+    BaseModel,
+    Field,
+    SecretStr,
+    ValidationError,
+    field_serializer,
+    model_validator,
+)
+from tomlkit.exceptions import TOMLKitError
+
+from pythinker_code.exception import ConfigError
+from pythinker_code.hooks.config import HookDef
+from pythinker_code.llm import ModelCapability, ProviderType
+from pythinker_code.share import get_share_dir
+from pythinker_code.utils.logging import logger
+
+
+class OAuthRef(BaseModel):
+    """Reference to OAuth credentials stored outside the config file."""
+
+    storage: Literal["keyring", "file"] = "file"
+    """Credential storage backend."""
+    key: str
+    """Storage key to locate OAuth credentials."""
+
+
+class LLMProvider(BaseModel):
+    """LLM provider configuration."""
+
+    type: ProviderType
+    """Provider type"""
+    base_url: str
+    """API base URL"""
+    api_key: SecretStr
+    """API key"""
+    env: dict[str, str] | None = None
+    """Environment variables to set before creating the provider instance"""
+    custom_headers: dict[str, str] | None = None
+    """Custom headers to include in API requests"""
+    reasoning_key: str | None = None
+    """Message field name carrying reasoning content for OpenAI-compatible APIs.
+    Applies to provider type ``openai_legacy``. Defaults to ``reasoning_content``
+    when unset. Use an empty string to disable reasoning round-tripping."""
+    oauth: OAuthRef | None = None
+    """OAuth credential reference (do not store tokens here)."""
+
+    @field_serializer("api_key", when_used="json")
+    def dump_secret(self, v: SecretStr):
+        return v.get_secret_value()
+
+
+class LLMModel(BaseModel):
+    """LLM model configuration."""
+
+    provider: str
+    """Provider name"""
+    model: str
+    """Model name"""
+    max_context_size: int
+    """Maximum context size (unit: tokens)"""
+    capabilities: set[ModelCapability] | None = None
+    """Model capabilities"""
+    display_name: str | None = None
+    """Human-readable model name (sourced from the provider's models API when available)"""
+
+
+class LoopControl(BaseModel):
+    """Agent loop control configuration."""
+
+    max_steps_per_turn: int = Field(
+        default=1000,
+        ge=1,
+        validation_alias=AliasChoices("max_steps_per_turn", "max_steps_per_run"),
+    )
+    """Maximum number of steps in one turn"""
+    max_retries_per_step: int = Field(default=3, ge=1)
+    """Maximum number of retries in one step"""
+    max_ralph_iterations: int = Field(default=0, ge=-1)
+    """Extra iterations after the first turn in Ralph mode. Use -1 for unlimited."""
+    reserved_context_size: int = Field(default=50_000, ge=1000)
+    """Reserved token count for LLM response generation. Auto-compaction triggers when
+    either context_tokens + reserved_context_size >= max_context_size or
+    context_tokens >= max_context_size * compaction_trigger_ratio. Default is 50000."""
+    compaction_trigger_ratio: float = Field(default=0.85, ge=0.5, le=0.99)
+    """Context usage ratio threshold for auto-compaction. Default is 0.85 (85%).
+    Auto-compaction triggers when context_tokens >= max_context_size * compaction_trigger_ratio
+    or when context_tokens + reserved_context_size >= max_context_size."""
+
+
+class BackgroundConfig(BaseModel):
+    """Background task runtime configuration."""
+
+    max_running_tasks: int = Field(default=4, ge=1)
+    read_max_bytes: int = Field(default=30_000, ge=1024)
+    notification_tail_lines: int = Field(default=20, ge=1)
+    notification_tail_chars: int = Field(default=3_000, ge=256)
+    wait_poll_interval_ms: int = Field(default=500, ge=50)
+    worker_heartbeat_interval_ms: int = Field(default=5_000, ge=100)
+    worker_stale_after_ms: int = Field(default=15_000, ge=1000)
+    kill_grace_period_ms: int = Field(default=2_000, ge=100)
+    keep_alive_on_exit: bool = Field(
+        default=False,
+        description="Keep background tasks alive when CLI exits. Default: kill on exit.",
+    )
+    agent_task_timeout_s: int = Field(default=900, ge=60)
+    """Maximum runtime in seconds for a background agent task. Default: 900 (15 min)."""
+    print_wait_ceiling_s: int = Field(default=3600, ge=1)
+    """Hard ceiling for how long ``--print`` mode waits for background tasks before
+    killing them and exiting. The effective wait is
+    ``min(max(active_task.timeout_s or agent_task_timeout_s), print_wait_ceiling_s)``.
+    Default: 3600 (1 hour)."""
+
+
+class NotificationConfig(BaseModel):
+    """Notification runtime configuration."""
+
+    claim_stale_after_ms: int = Field(default=15_000, ge=1000)
+
+
+class PythinkerAISearchConfig(BaseModel):
+    """Pythinker AI Search configuration."""
+
+    base_url: str
+    """Base URL for Pythinker AI Search service."""
+    api_key: SecretStr
+    """API key for Pythinker AI Search service."""
+    custom_headers: dict[str, str] | None = None
+    """Custom headers to include in API requests."""
+    oauth: OAuthRef | None = None
+    """OAuth credential reference (do not store tokens here)."""
+
+    @field_serializer("api_key", when_used="json")
+    def dump_secret(self, v: SecretStr):
+        return v.get_secret_value()
+
+
+class PythinkerAIFetchConfig(BaseModel):
+    """Pythinker AI Fetch configuration."""
+
+    base_url: str
+    """Base URL for Pythinker AI Fetch service."""
+    api_key: SecretStr
+    """API key for Pythinker AI Fetch service."""
+    custom_headers: dict[str, str] | None = None
+    """Custom headers to include in API requests."""
+    oauth: OAuthRef | None = None
+    """OAuth credential reference (do not store tokens here)."""
+
+    @field_serializer("api_key", when_used="json")
+    def dump_secret(self, v: SecretStr):
+        return v.get_secret_value()
+
+
+class Services(BaseModel):
+    """Services configuration."""
+
+    pythinker_ai_search: PythinkerAISearchConfig | None = None
+    """Pythinker AI Search configuration."""
+    pythinker_ai_fetch: PythinkerAIFetchConfig | None = None
+    """Pythinker AI Fetch configuration."""
+
+
+class MCPClientConfig(BaseModel):
+    """MCP client configuration."""
+
+    tool_call_timeout_ms: int = 60000
+    """Timeout for tool calls in milliseconds."""
+
+
+class MCPConfig(BaseModel):
+    """MCP configuration."""
+
+    client: MCPClientConfig = Field(
+        default_factory=MCPClientConfig, description="MCP client configuration"
+    )
+
+
+class Config(BaseModel):
+    """Main configuration structure."""
+
+    is_from_default_location: bool = Field(
+        default=False,
+        description="Whether the config was loaded from the default location",
+        exclude=True,
+    )
+    source_file: Path | None = Field(
+        default=None,
+        description="Path to the loaded config file. None when loaded from --config text.",
+        exclude=True,
+    )
+    default_model: str = Field(default="", description="Default model to use")
+    default_thinking: bool = Field(default=False, description="Default thinking mode")
+    default_yolo: bool = Field(default=False, description="Default yolo (auto-approve) mode")
+    skip_auto_prompt_injection: bool = Field(
+        default=False,
+        description=(
+            "If true, suppress the auto-mode system reminder. "
+            "Yolo mode does not inject a system reminder."
+        ),
+    )
+    default_plan_mode: bool = Field(default=False, description="Default plan mode for new sessions")
+    default_editor: str = Field(
+        default="",
+        description="Default external editor command (e.g. 'vim', 'code --wait')",
+    )
+    theme: Literal["dark", "light"] = Field(
+        default="dark",
+        description="Terminal color theme. Use 'light' for light terminal backgrounds.",
+    )
+    show_thinking_stream: bool = Field(
+        default=True,
+        description=(
+            "If true, stream the raw reasoning text in the live area as a "
+            "6-line scrolling preview and commit the full reasoning markdown "
+            "to history when the block ends. Default true. Set to false to "
+            "show only the compact 'Thinking ...' indicator and a one-line "
+            "trace summary."
+        ),
+    )
+    models: dict[str, LLMModel] = Field(default_factory=dict, description="List of LLM models")
+    providers: dict[str, LLMProvider] = Field(
+        default_factory=dict, description="List of LLM providers"
+    )
+    loop_control: LoopControl = Field(default_factory=LoopControl, description="Agent loop control")
+    background: BackgroundConfig = Field(
+        default_factory=BackgroundConfig, description="Background task configuration"
+    )
+    notifications: NotificationConfig = Field(
+        default_factory=NotificationConfig, description="Notification configuration"
+    )
+    services: Services = Field(default_factory=Services, description="Services configuration")
+    mcp: MCPConfig = Field(default_factory=MCPConfig, description="MCP configuration")
+    hooks: list[HookDef] = Field(default_factory=list, description="Hook definitions")  # pyright: ignore[reportUnknownVariableType]
+    merge_all_available_skills: bool = Field(
+        default=True,
+        description=(
+            "Merge skills from all existing brand directories (pythinker/claude/codex) "
+            "instead of using only the first one found. Defaults to true so users "
+            "who keep skills in multiple brand directories see everything out of "
+            "the box; set to false to restore the first-match-only behaviour."
+        ),
+    )
+    extra_skill_dirs: list[str] = Field(
+        default_factory=list,
+        description=(
+            "Extra directories to discover skills from, added on top of the "
+            "built-in / user / project locations. Each entry may be an absolute "
+            "path, ``~``-prefixed (expanded against $HOME), or relative to the "
+            "project root (the nearest ``.git`` directory above the work dir). "
+            "Missing paths are silently skipped."
+        ),
+    )
+    telemetry: bool = Field(
+        default=False,
+        description=(
+            "Enable anonymous telemetry to help improve pythinker-code. Set to true to enable."
+        ),
+    )
+
+    @model_validator(mode="after")
+    def validate_model(self) -> Self:
+        if self.default_model and self.default_model not in self.models:
+            raise ValueError(f"Default model {self.default_model} not found in models")
+        for model in self.models.values():
+            if model.provider not in self.providers:
+                raise ValueError(f"Provider {model.provider} not found in providers")
+        return self
+
+
+def get_config_file() -> Path:
+    """Get the configuration file path."""
+    return get_share_dir() / "config.toml"
+
+
+def get_default_config() -> Config:
+    """Get the default configuration."""
+    return Config(
+        default_model="",
+        models={},
+        providers={},
+        services=Services(),
+    )
+
+
+def load_config(config_file: Path | None = None) -> Config:
+    """
+    Load configuration from config file.
+    If the config file does not exist, create it with default configuration.
+
+    Args:
+        config_file (Path | None): Path to the configuration file. If None, use default path.
+
+    Returns:
+        Validated Config object.
+
+    Raises:
+        ConfigError: If the configuration file is invalid.
+    """
+    default_config_file = get_config_file().expanduser().resolve(strict=False)
+    if config_file is None:
+        config_file = default_config_file
+    config_file = config_file.expanduser().resolve(strict=False)
+    is_default_config_file = config_file == default_config_file
+    logger.debug("Loading config from file: {file}", file=config_file)
+
+    # If the user hasn't provided an explicit config path, migrate legacy JSON config once.
+    if is_default_config_file and not config_file.exists():
+        _migrate_json_config_to_toml()
+
+    if not config_file.exists():
+        config = get_default_config()
+        logger.debug("No config file found, creating default config: {config}", config=config)
+        save_config(config, config_file)
+        config.is_from_default_location = is_default_config_file
+        config.source_file = config_file
+        return config
+
+    try:
+        config_text = config_file.read_text(encoding="utf-8")
+        if config_file.suffix.lower() == ".json":
+            data = json.loads(config_text)
+        else:
+            data = tomlkit.loads(config_text)
+        config = Config.model_validate(data)
+    except json.JSONDecodeError as e:
+        raise ConfigError(f"Invalid JSON in configuration file {config_file}: {e}") from e
+    except TOMLKitError as e:
+        raise ConfigError(f"Invalid TOML in configuration file {config_file}: {e}") from e
+    except ValidationError as e:
+        raise ConfigError(f"Invalid configuration file {config_file}: {e}") from e
+    config.is_from_default_location = is_default_config_file
+    config.source_file = config_file
+    return config
+
+
+def load_config_from_string(config_string: str) -> Config:
+    """
+    Load configuration from a TOML or JSON string.
+
+    Args:
+        config_string (str): TOML or JSON configuration text.
+
+    Returns:
+        Validated Config object.
+
+    Raises:
+        ConfigError: If the configuration text is invalid.
+    """
+    if not config_string.strip():
+        raise ConfigError("Configuration text cannot be empty")
+
+    json_error: json.JSONDecodeError | None = None
+    try:
+        data = json.loads(config_string)
+    except json.JSONDecodeError as exc:
+        json_error = exc
+        data = None
+
+    if data is None:
+        try:
+            data = tomlkit.loads(config_string)
+        except TOMLKitError as toml_error:
+            raise ConfigError(
+                f"Invalid configuration text: {json_error}; {toml_error}"
+            ) from toml_error
+
+    try:
+        config = Config.model_validate(data)
+    except ValidationError as e:
+        raise ConfigError(f"Invalid configuration text: {e}") from e
+    config.is_from_default_location = False
+    config.source_file = None
+    return config
+
+
+def save_config(config: Config, config_file: Path | None = None):
+    """
+    Save configuration to config file.
+
+    Args:
+        config (Config): Config object to save.
+        config_file (Path | None): Path to the configuration file. If None, use default path.
+    """
+    config_file = config_file or get_config_file()
+    logger.debug("Saving config to file: {file}", file=config_file)
+    config_file.parent.mkdir(parents=True, exist_ok=True)
+    config_data = config.model_dump(mode="json", exclude_none=True)
+    with open(config_file, "w", encoding="utf-8") as f:
+        if config_file.suffix.lower() == ".json":
+            f.write(json.dumps(config_data, ensure_ascii=False, indent=2))
+        else:
+            f.write(tomlkit.dumps(config_data))  # type: ignore[reportUnknownMemberType]
+
+
+def _migrate_json_config_to_toml() -> None:
+    old_json_config_file = get_share_dir() / "config.json"
+    new_toml_config_file = get_share_dir() / "config.toml"
+
+    if not old_json_config_file.exists():
+        return
+    if new_toml_config_file.exists():
+        return
+
+    logger.info(
+        "Migrating legacy config file from {old} to {new}",
+        old=old_json_config_file,
+        new=new_toml_config_file,
+    )
+
+    try:
+        with open(old_json_config_file, encoding="utf-8") as f:
+            data = json.load(f)
+        config = Config.model_validate(data)
+    except json.JSONDecodeError as e:
+        logger.warning(
+            "Ignoring invalid legacy JSON config file {file}: {err}",
+            file=old_json_config_file,
+            err=e,
+        )
+        config = get_default_config()
+    except ValidationError as e:
+        logger.warning(
+            "Ignoring incompatible legacy config file {file}: {err}",
+            file=old_json_config_file,
+            err=e,
+        )
+        config = get_default_config()
+
+    # Write new TOML config, then keep a backup of the original JSON file.
+    save_config(config, new_toml_config_file)
+    backup_path = _next_legacy_config_backup_path(old_json_config_file)
+    old_json_config_file.replace(backup_path)
+    logger.info("Legacy config backed up to {file}", file=backup_path)
+
+
+def _next_legacy_config_backup_path(config_file: Path) -> Path:
+    backup_path = config_file.with_name("config.json.bak")
+    if not backup_path.exists():
+        return backup_path
+    index = 1
+    while True:
+        candidate = config_file.with_name(f"config.json.bak.{index}")
+        if not candidate.exists():
+            return candidate
+        index += 1

pythinker_code/constant.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from functools import cache
+from typing import TYPE_CHECKING
+
+NAME = "Pythinker CLI"
+
+if TYPE_CHECKING:
+    VERSION: str
+    USER_AGENT: str
+
+
+@cache
+def get_version() -> str:
+    from importlib import metadata
+
+    return metadata.version("pythinker-code")
+
+
+@cache
+def get_user_agent() -> str:
+    return f"PythinkerCLI/{get_version()}"
+
+
+def __getattr__(name: str) -> str:
+    if name == "VERSION":
+        return get_version()
+    if name == "USER_AGENT":
+        return get_user_agent()
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = ["NAME", "VERSION", "USER_AGENT", "get_version", "get_user_agent"]