pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+
+All notable changes to `pythinker-code` are tracked in this file.
+
+Pythinker Code uses a `0.MINOR.PATCH` version scheme. `MINOR` is a release
+counter that continues advancing with each release. `PATCH` is reserved for
+hotfixes against an already-released `MINOR`. There is no `1.0.0` milestone
+planned on this line.
+
+Releases earlier than `0.8.0` were published as `pythinker-code` 1.x/2.x
+under a different scheme. The full pre-`0.8.0` history is preserved in
+[`docs/history/CHANGELOG-pre-0.8.0.md`](docs/history/CHANGELOG-pre-0.8.0.md).
+All 1.x and 2.x releases have been yanked from PyPI and removed from the
+GitHub Releases page; `0.8.0` is the new starting line.
+
+## Unreleased
+
+## 0.8.0 (2026-05-21)
+
+Version-scheme reset. The next release after `pythinker-code` 2.7.0 ships as
+`0.8.0` under the new `0.MINOR.PATCH` line.
+
+### What changed in this release
+
+- **Version line reset.** `pyproject.toml` `version` moves from `2.7.0` to `0.8.0`.
+  All prior `pythinker-code` 1.x/2.x releases have been yanked from PyPI and
+  removed from the GitHub Releases page. New installs of
+  `pip install --upgrade pythinker-code==0.8.0` resolve to the `0.x` line.
+- **Tag scheme standardised** on `v<MAJOR>.<MINOR>.<PATCH>`. The
+  `release-pythinker-cli.yml` workflow trigger now matches `v[0-9]+.[0-9]+.[0-9]+`
+  and `scripts/check_version_tag.py` strips the leading `v` before comparing the
+  tag to `pyproject.toml`.
+- **Release gate preserved.** The `What's New in <version>` section,
+  `pythinker-code==<version>` install snippet, and `## <version> (YYYY-MM-DD)`
+  CHANGELOG entry are still required for every tag — only the version values
+  change.
+- **CHANGELOG restart.** Pre-`0.8.0` history archived to
+  `docs/history/CHANGELOG-pre-0.8.0.md`; this file starts fresh at `0.8.0`.
+- **README "What's New" trimmed.** The cascading 2.x "What's New" wall is
+  replaced by a single `0.8.0` section. Past release notes live in the archived
+  CHANGELOG and the per-tag GitHub Releases (from `v0.8.0` onward).
+- **Test refactor.** `tests/telemetry/test_otel_resource.py` now reads the
+  expected service version from `importlib.metadata.version("pythinker-code")`
+  instead of a hard-coded string, so future version bumps don't require a test
+  edit.
+
+### Carried forward from 2.7.0
+
+All functionality shipped through `pythinker-code` 2.7.0 is preserved:
+review-first workflows (`pythinker review`, `pythinker secscan`,
+`pythinker security-scan`, `pythinker debug`), Reviewflow stateful
+review/fix workflows, the new `code-reviewer` / `security-reviewer` /
+`debugger` subagent roles, hardened review-output validation, and the
+read-only PR artifact helpers (`describe`, `improve` / `suggest`, `ask`,
+`labels`, `changelog`, `docs`, `compliance`, etc.).
+
+See [`docs/history/CHANGELOG-pre-0.8.0.md`](docs/history/CHANGELOG-pre-0.8.0.md)
+for the detailed 2.x release-by-release notes.
+
+Upgrade with `pythinker update` or `pip install --upgrade pythinker-code==0.8.0`.

pythinker_code/__main__.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+ROOT_HELP = """Usage: pythinker [OPTIONS] COMMAND [ARGS]...
+
+  Pythinker, your next CLI agent.
+
+Options:
+  -h, --help                       Show this message and exit.
+  -V, --version                    Show version and exit.
+  --verbose                        Print verbose information.
+  --debug                          Log debug information.
+  -w, --work-dir DIRECTORY         Working directory for the agent.
+  --add-dir DIRECTORY              Add an additional workspace directory.
+  -S, -r, --session, --resume TEXT Resume a session.
+  -C, --continue                   Continue the previous session.
+  --config TEXT                    Config TOML/JSON string to load.
+  --config-file FILE               Config TOML/JSON file to load.
+  -m, --model TEXT                 LLM model to use.
+  --thinking / --no-thinking       Enable or disable thinking mode.
+  -y, --yolo, --yes, --auto-approve
+                                   Dangerously skip permission approvals.
+  --plan                           Start in plan mode.
+  --auto                           Run in auto mode (no user present).
+  -p, -c, --prompt, --command TEXT User prompt to the agent.
+  --print                          Run in print mode.
+  --acp                            Deprecated; use `pythinker acp`.
+  --wire                           Run as Wire server.
+  --quiet                          Print only the final assistant message.
+  --agent [default|okabe]          Builtin agent specification to use.
+  --agent-file FILE                Custom agent specification file.
+  --mcp-config-file FILE           MCP config file to load; repeatable.
+  --mcp-config TEXT                MCP config JSON to load; repeatable.
+  --skills-dir DIRECTORY           Custom skills directory; repeatable.
+  --no-telemetry                   Disable anonymous telemetry & error reporting.
+
+Commands:
+  acp      Run Pythinker CLI ACP server.
+  term     Run Toad TUI backed by Pythinker CLI ACP server.
+  login    Login with a model provider.
+  logout   Logout from a model provider.
+  info     Show version and protocol information.
+  export   Export session data.
+  mcp      Manage MCP server configurations.
+  plugin   Manage plugins.
+  review          Diff-focused code review (delegates to pythinker-review).
+  secscan         Diff-focused security review (delegates to pythinker-review).
+  security-scan   Repo-wide Pythinker Security Scan pipeline (Python-native).
+  debug           Failure/log root-cause analysis (delegates to pythinker-review).
+  update   Check for and install Pythinker CLI updates.
+  vis      Run Pythinker Agent Tracing Visualizer.
+  web      Run Pythinker CLI web interface.
+
+Documentation:        https://mohamed-elkholy95.github.io/Pythinker-Code/
+LLM friendly version: https://mohamed-elkholy95.github.io/Pythinker-Code/llms.txt
+"""
+
+
+def _prog_name() -> str:
+    return Path(sys.argv[0]).name or "pythinker"
+
+
+def main(argv: Sequence[str] | None = None) -> int | str | None:
+    args = list(sys.argv[1:] if argv is None else argv)
+
+    if len(args) == 1 and args[0] in {"--version", "-V"}:
+        from pythinker_code.constant import get_version
+
+        print(f"pythinker, version {get_version()}")
+        return 0
+
+    if len(args) == 1 and args[0] in {"--help", "-h"}:
+        print(ROOT_HELP, end="")
+        return 0
+
+    from pythinker_code.telemetry.crash import install_crash_handlers, set_phase
+    from pythinker_code.utils.proxy import normalize_proxy_env
+
+    # Install excepthook before anything else so startup-phase crashes are captured.
+    install_crash_handlers()
+    normalize_proxy_env()
+
+    from pythinker_code.cli import cli
+
+    try:
+        return cli(args=args, prog_name=_prog_name())
+    except SystemExit as exc:
+        return exc.code
+    finally:
+        set_phase("shutdown")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pythinker_code/acp/AGENTS.md

@@ -0,0 +1,93 @@
+# ACP Integration Notes (pythinker-code)
+
+## Protocol summary (ACP overview)
+- ACP is JSON-RPC 2.0 with request/response methods plus one-way notifications.
+- Typical flow: `initialize` -> optional `authenticate` -> `session/new` or `session/load`
+  -> `session/prompt`
+  with `session/update` notifications and optional `session/cancel`.
+- Clients provide `session/request_permission` and optional terminal/filesystem methods.
+- All ACP file paths must be absolute; line numbers are 1-based.
+
+## Entry points and server modes
+- **Deprecated single-session server**: `PythinkerCLI.run_acp()` uses `ACP` -> `ACPServerSingleSession`.
+  - Code: `src/pythinker_code/app.py`, `src/pythinker_code/ui/acp/__init__.py`.
+  - Used when running CLI with `--acp` UI mode; every ACP method now raises a deprecation error.
+- **Multi-session server**: `acp_main()` runs `ACPServer` with `use_unstable_protocol=True`.
+  - Code: `src/pythinker_code/acp/__init__.py`, `src/pythinker_code/acp/server.py`.
+  - Exposed via the `pythinker acp` command in `src/pythinker_code/cli/__init__.py`.
+
+## Capabilities advertised
+- `prompt_capabilities`: `embedded_context=True`, `image=True`, `audio=False`.
+- `mcp_capabilities`: `http=True`, `sse=False`.
+- Multi-session: `load_session=True`, `session_capabilities.list` and `session_capabilities.resume` supported.
+- `auth_methods` advertises terminal auth for `pythinker login`.
+
+## Session lifecycle (implemented behavior)
+- `session/new`
+  - Multi-session: creates a persisted `Session`, builds `PythinkerCLI`, stores `ACPSession`.
+  - Sends `AvailableCommandsUpdate` for slash commands on session creation.
+  - MCP servers passed by ACP are converted via `acp_mcp_servers_to_mcp_config`.
+- `session/load`
+  - Multi-session only: loads by `Session.find`, then builds `PythinkerCLI` and `ACPSession`.
+  - No history replay yet (TODO).
+- `session/list`
+  - Multi-session only: lists sessions via `Session.list`, no pagination.
+- `session/resume`
+  - Multi-session only: loads the session if needed and returns current mode/model state.
+- `session/set_mode`
+  - Multi-session only: accepts only `default`.
+- `session/set_model`
+  - Multi-session only: switches the session LLM and persists default model/thinking settings.
+- `session/prompt`
+  - Uses `ACPSession.prompt()` to stream updates and produce a `stop_reason`.
+  - Stop reasons: `end_turn`, `max_turn_requests`, `cancelled`.
+- `session/cancel`
+  - Sets the per-turn cancel event to stop the prompt.
+
+## Streaming updates and content mapping
+- Text chunks -> `AgentMessageChunk`.
+- Think chunks -> `AgentThoughtChunk`.
+- Tool calls:
+  - Start -> `ToolCallStart` with JSON args as text content.
+  - Streaming args -> `ToolCallProgress` with updated title/args.
+  - Results -> `ToolCallProgress` with `completed` or `failed`.
+  - Tool call IDs are prefixed with turn ID to avoid collisions across turns.
+- Plan updates:
+  - `TodoDisplayBlock` is converted into `AgentPlanUpdate`.
+- Available commands:
+  - `AvailableCommandsUpdate` is sent right after session creation.
+
+## Prompt/content conversion
+- Incoming prompt blocks:
+  - Supported: `TextContentBlock`, `ImageContentBlock` (converted to data URL).
+  - Unsupported types are logged and ignored.
+- Tool result display blocks:
+  - `DiffDisplayBlock` -> `FileEditToolCallContent`.
+  - `HideOutputDisplayBlock` suppresses tool output in ACP (used by terminal tool).
+
+## Tool integration and permission flow
+- ACP sessions use `ACPHost` to route filesystem reads/writes through ACP clients.
+- If the client advertises `terminal` capability, the `Shell` tool is replaced by an
+  ACP-backed `Terminal` tool.
+  - Uses ACP `terminal/create`, waits for exit, streams `TerminalToolCallContent`,
+    then releases the terminal handle.
+- Approval requests in the core tool system are bridged to ACP
+  `session/request_permission` with allow-once/allow-always/reject options.
+
+## Current gaps / not implemented
+- `fork_session` is not implemented.
+- `ext_method` / `ext_notification` for custom ACP extensions are stubbed.
+- Deprecated single-session `--acp` rejects all methods and exists only to report migration guidance.
+- `session/load` still has no history replay.
+
+## Filesystem (ACP client-backed)
+- When the client advertises `fs.readTextFile` / `fs.writeTextFile`, `ACPHost` routes
+  reads and writes through ACP `fs/*` methods.
+- `ReadFile` uses `HostPath.read_lines`, which `ACPHost` implements via ACP reads.
+- `ReadMediaFile` uses `HostPath.read_bytes` to load image/video payloads through ACP reads.
+- `WriteFile` uses `HostPath.read_text/write_text/append_text` and still generates diffs
+  and approvals in the tool layer.
+
+## Zed-specific notes (as of current integration)
+- Terminal auth advertises `pythinker login`; `authenticate` verifies that login completed.
+- External agent clients should use `pythinker acp`, not deprecated `pythinker --acp`.

pythinker_code/acp/__init__.py

@@ -0,0 +1,13 @@
+def acp_main() -> None:
+    """Entry point for the multi-session ACP server."""
+    import asyncio
+
+    import acp
+
+    from pythinker_code.acp.server import ACPServer
+    from pythinker_code.app import enable_logging
+    from pythinker_code.utils.logging import logger
+
+    enable_logging()
+    logger.info("Starting ACP server on stdio")
+    asyncio.run(acp.run_agent(ACPServer(), use_unstable_protocol=True))

pythinker_code/acp/convert.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import acp
+
+from pythinker_code.acp.types import ACPContentBlock
+from pythinker_code.utils.logging import logger
+from pythinker_code.wire.types import (
+    ContentPart,
+    DiffDisplayBlock,
+    DisplayBlock,
+    ImageURLPart,
+    TextPart,
+    ToolReturnValue,
+)
+
+
+def acp_blocks_to_content_parts(prompt: list[ACPContentBlock]) -> list[ContentPart]:
+    content: list[ContentPart] = []
+    for block in prompt:
+        match block:
+            case acp.schema.TextContentBlock():
+                content.append(TextPart(text=block.text))
+            case acp.schema.ImageContentBlock():
+                content.append(
+                    ImageURLPart(
+                        image_url=ImageURLPart.ImageURL(
+                            url=f"data:{block.mime_type};base64,{block.data}"
+                        )
+                    )
+                )
+            case acp.schema.EmbeddedResourceContentBlock():
+                resource = block.resource
+                if isinstance(resource, acp.schema.TextResourceContents):
+                    uri = resource.uri
+                    text = resource.text
+                    content.append(TextPart(text=f"<resource uri={uri!r}>\n{text}\n</resource>"))
+                else:
+                    logger.warning(
+                        "Unsupported embedded resource type: {type}",
+                        type=type(resource).__name__,
+                    )
+            case acp.schema.ResourceContentBlock():
+                # ResourceContentBlock is a link reference without inline content;
+                # include the URI so the model is at least aware of the reference.
+                content.append(
+                    TextPart(text=f"<resource_link uri={block.uri!r} name={block.name!r} />")
+                )
+            case _:
+                logger.warning("Unsupported prompt content block: {block}", block=block)
+    return content
+
+
+def display_block_to_acp_content(
+    block: DisplayBlock,
+) -> acp.schema.FileEditToolCallContent | None:
+    if isinstance(block, DiffDisplayBlock):
+        return acp.schema.FileEditToolCallContent(
+            type="diff",
+            path=block.path,
+            old_text=block.old_text,
+            new_text=block.new_text,
+        )
+
+    return None
+
+
+def tool_result_to_acp_content(
+    tool_ret: ToolReturnValue,
+) -> list[
+    acp.schema.ContentToolCallContent
+    | acp.schema.FileEditToolCallContent
+    | acp.schema.TerminalToolCallContent
+]:
+    from pythinker_code.acp.tools import HideOutputDisplayBlock
+
+    def _to_acp_content(
+        part: ContentPart,
+    ) -> (
+        acp.schema.ContentToolCallContent
+        | acp.schema.FileEditToolCallContent
+        | acp.schema.TerminalToolCallContent
+    ):
+        if isinstance(part, TextPart):
+            return acp.schema.ContentToolCallContent(
+                type="content", content=acp.schema.TextContentBlock(type="text", text=part.text)
+            )
+        logger.warning("Unsupported content part in tool result: {part}", part=part)
+        return acp.schema.ContentToolCallContent(
+            type="content",
+            content=acp.schema.TextContentBlock(type="text", text=f"[{part.__class__.__name__}]"),
+        )
+
+    def _to_text_block(text: str) -> acp.schema.ContentToolCallContent:
+        return acp.schema.ContentToolCallContent(
+            type="content", content=acp.schema.TextContentBlock(type="text", text=text)
+        )
+
+    contents: list[
+        acp.schema.ContentToolCallContent
+        | acp.schema.FileEditToolCallContent
+        | acp.schema.TerminalToolCallContent
+    ] = []
+
+    for block in tool_ret.display:
+        if isinstance(block, HideOutputDisplayBlock):
+            # return early to indicate no output should be shown
+            return []
+
+        content = display_block_to_acp_content(block)
+        if content is not None:
+            contents.append(content)
+    # TODO: better concatenation of `display` blocks and `output`?
+
+    output = tool_ret.output
+    if isinstance(output, str):
+        if output:
+            contents.append(_to_text_block(output))
+    else:
+        # NOTE: At the moment, ToolReturnValue.output is either a string or a
+        # list of ContentPart. We avoid an unnecessary isinstance() check here
+        # to keep pyright happy while still handling list outputs.
+        contents.extend(_to_acp_content(part) for part in output)
+
+    if not contents and tool_ret.message:
+        # Fallback to the `message` for LLM if there's no other content
+        contents.append(_to_text_block(tool_ret.message))
+
+    return contents