pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/plugin/tool.py

@@ -0,0 +1,173 @@
+"""Plugin tool wrapper — runs plugin-declared tools as subprocesses."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from loguru import logger
+from pythinker_core.tooling import CallableTool, ToolError, ToolOk
+from pythinker_core.tooling.error import ToolRuntimeError
+
+from pythinker_code.plugin import PluginToolSpec
+from pythinker_code.tools.utils import ToolRejectedError
+from pythinker_code.utils.subprocess_env import get_clean_env
+from pythinker_code.wire.types import ToolReturnValue
+
+if TYPE_CHECKING:
+    from pythinker_code.config import Config
+    from pythinker_code.soul.approval import Approval
+
+
+def _get_host_values(config: Config) -> dict[str, str]:
+    """Extract current host values (api_key, base_url) from config.
+
+    Reads the latest provider credentials, which may have been
+    refreshed by OAuth since plugin install time.
+    """
+    from pythinker_code.auth.oauth import OAuthManager
+    from pythinker_code.plugin.manager import collect_host_values
+
+    oauth = OAuthManager(config)
+    return collect_host_values(config, oauth)
+
+
+class PluginTool(CallableTool):
+    """A tool that executes a plugin command in a subprocess.
+
+    Parameters are passed via stdin as JSON.
+    stdout is captured as the tool result.
+    Host credentials are injected as environment variables at runtime
+    (not baked into config files) to handle OAuth token refresh.
+    """
+
+    def __init__(
+        self,
+        tool_spec: PluginToolSpec,
+        plugin_dir: Path,
+        *,
+        inject: dict[str, str],
+        config: Config,
+        approval: Approval | None = None,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            name=tool_spec.name,
+            description=tool_spec.description,
+            parameters=tool_spec.parameters or {"type": "object", "properties": {}},
+            **kwargs,
+        )
+        self._command = tool_spec.command
+        self._plugin_dir = plugin_dir
+        self._inject = inject  # e.g. {"pythinkerCodeAPIKey": "api_key"}
+        self._config = config
+        self._approval = approval
+
+    def _build_env(self) -> dict[str, str]:
+        """Build env vars with fresh host credentials for the subprocess."""
+        env = get_clean_env()
+        if self._inject:
+            host_values = _get_host_values(self._config)
+            for target_key, source_key in self._inject.items():
+                if source_key in host_values:
+                    # Inject as env var using the plugin's config key name
+                    # e.g. pythinkerCodeAPIKey=<fresh api_key>
+                    env[target_key] = host_values[source_key]
+        return env
+
+    async def __call__(self, *args: Any, **kwargs: Any) -> ToolReturnValue:
+        if self._approval is not None:
+            description = f"Run plugin tool `{self.name}`."
+            if not await self._approval.request(self.name, f"plugin:{self.name}", description):
+                return ToolRejectedError()
+
+        params_json = json.dumps(kwargs, ensure_ascii=False)
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *self._command,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=str(self._plugin_dir),
+                env=self._build_env(),
+            )
+        except Exception as exc:
+            return ToolRuntimeError(str(exc))
+
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                proc.communicate(input=params_json.encode("utf-8")),
+                timeout=120,
+            )
+        except asyncio.CancelledError:
+            proc.kill()
+            await proc.wait()
+            raise
+        except TimeoutError:
+            proc.kill()
+            await proc.wait()
+            return ToolError(
+                message=f"Plugin tool '{self.name}' timed out after 120s.",
+                brief="Timeout",
+            )
+
+        output = stdout.decode("utf-8", errors="replace").strip()
+        err_output = stderr.decode("utf-8", errors="replace").strip()
+
+        if proc.returncode != 0:
+            error_msg = err_output or output or f"Exit code {proc.returncode}"
+            return ToolError(
+                message=f"Plugin tool '{self.name}' failed: {error_msg}",
+                brief=f"Exit {proc.returncode}",
+            )
+
+        if err_output:
+            logger.debug("Plugin tool {name} stderr: {err}", name=self.name, err=err_output)
+
+        return ToolOk(output=output)
+
+
+def load_plugin_tools(
+    plugins_dir: Path, config: Config, *, approval: Approval | None = None
+) -> list[PluginTool]:
+    """Scan installed plugins and create PluginTool instances for declared tools."""
+    from pythinker_code.plugin import PLUGIN_JSON, PluginError, parse_plugin_json
+
+    if not plugins_dir.is_dir():
+        return []
+
+    tools: list[PluginTool] = []
+    for child in sorted(plugins_dir.iterdir()):
+        plugin_json = child / PLUGIN_JSON
+        if not child.is_dir() or not plugin_json.is_file():
+            continue
+        try:
+            spec = parse_plugin_json(plugin_json)
+        except PluginError:
+            continue
+        for tool_spec in spec.tools:
+            try:
+                tool = PluginTool(
+                    tool_spec,
+                    plugin_dir=child,
+                    inject=spec.inject,
+                    config=config,
+                    approval=approval,
+                )
+            except Exception:
+                logger.warning(
+                    "Skipping invalid plugin tool: {name} (from {plugin})",
+                    name=tool_spec.name,
+                    plugin=spec.name,
+                )
+                continue
+            tools.append(tool)
+            logger.info(
+                "Loaded plugin tool: {name} (from {plugin})",
+                name=tool_spec.name,
+                plugin=spec.name,
+            )
+    return tools

pythinker_code/prompt_templates.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+from pythinker_host.path import HostPath
+
+from pythinker_code.utils.frontmatter import parse_frontmatter, strip_frontmatter
+from pythinker_code.utils.logging import logger
+from pythinker_code.utils.path import find_project_root
+
+PromptTemplateScope = Literal["project", "user"]
+
+
+@dataclass(frozen=True, slots=True)
+class PromptTemplate:
+    """A markdown prompt template exposed as a slash command."""
+
+    name: str
+    description: str
+    content: str
+    file_path: HostPath
+    scope: PromptTemplateScope
+    argument_hint: str | None = None
+
+
+def parse_command_args(args_string: str) -> list[str]:
+    """Parse template arguments using simple shell quoting."""
+    args: list[str] = []
+    current = ""
+    quote: str | None = None
+
+    for char in args_string:
+        if quote is not None:
+            if char == quote:
+                quote = None
+            else:
+                current += char
+        elif char in {'"', "'"}:
+            quote = char
+        elif char in {" ", "\t"}:
+            if current:
+                args.append(current)
+                current = ""
+        else:
+            current += char
+
+    if current:
+        args.append(current)
+    return args
+
+
+def substitute_args(content: str, args: list[str]) -> str:
+    """Substitute prompt-template placeholders.
+
+    Supports ``$1``, ``$2``, ``$@``, ``$ARGUMENTS``, ``${@:N}``, and
+    ``${@:N:L}``. Replacement is one-pass; inserted argument values are not
+    recursively substituted.
+    """
+    import re
+
+    def positional(match: re.Match[str]) -> str:
+        index = int(match.group(1)) - 1
+        return args[index] if 0 <= index < len(args) else ""
+
+    result = re.sub(r"\$(\d+)", positional, content)
+
+    def sliced(match: re.Match[str]) -> str:
+        start = max(0, int(match.group(1)) - 1)
+        length_group = match.group(2)
+        if length_group is None:
+            return " ".join(args[start:])
+        length = int(length_group)
+        return " ".join(args[start : start + length])
+
+    result = re.sub(r"\$\{@:(\d+)(?::(\d+))?\}", sliced, result)
+    all_args = " ".join(args)
+    result = result.replace("$ARGUMENTS", all_args)
+    result = result.replace("$@", all_args)
+    return result
+
+
+def expand_prompt_template(template: PromptTemplate, args_string: str) -> str:
+    """Expand *template* with a raw slash-command argument string."""
+    return substitute_args(template.content, parse_command_args(args_string))
+
+
+async def discover_prompt_templates(work_dir: HostPath) -> dict[str, PromptTemplate]:
+    """Discover project/user prompt templates.
+
+    Project templates win over user templates.
+    """
+    roots: list[tuple[PromptTemplateScope, HostPath]] = []
+    project_root = await find_project_root(work_dir)
+    roots.extend(
+        [
+            ("project", project_root / ".pythinker" / "prompts"),
+            ("user", HostPath.home() / ".pythinker" / "prompts"),
+        ]
+    )
+
+    templates: dict[str, PromptTemplate] = {}
+    for scope, root in roots:
+        for template in await _load_templates_from_dir(root, scope=scope):
+            templates.setdefault(template.name, template)
+    return dict(sorted(templates.items()))
+
+
+async def _load_templates_from_dir(
+    directory: HostPath,
+    *,
+    scope: PromptTemplateScope,
+) -> list[PromptTemplate]:
+    try:
+        if not await directory.is_dir():
+            return []
+    except OSError as exc:
+        logger.debug("Cannot stat prompt templates dir {path}: {error}", path=directory, error=exc)
+        return []
+
+    templates: list[PromptTemplate] = []
+    try:
+        async for entry in directory.iterdir():
+            try:
+                if await entry.is_dir() or not entry.name.lower().endswith(".md"):
+                    continue
+                content = await entry.read_text(encoding="utf-8")
+            except OSError as exc:
+                logger.info(
+                    "Skipping unreadable prompt template {path}: {error}",
+                    path=entry,
+                    error=exc,
+                )
+                continue
+            try:
+                templates.append(parse_prompt_template_text(content, file_path=entry, scope=scope))
+            except Exception as exc:
+                logger.info(
+                    "Skipping invalid prompt template {path}: {error}",
+                    path=entry,
+                    error=exc,
+                )
+    except OSError as exc:
+        logger.warning(
+            "Failed to iterate prompt templates dir {path}: {error}",
+            path=directory,
+            error=exc,
+        )
+    return sorted(templates, key=lambda t: t.name)
+
+
+def parse_prompt_template_text(
+    text: str,
+    *,
+    file_path: HostPath,
+    scope: PromptTemplateScope,
+) -> PromptTemplate:
+    """Parse a markdown prompt template file."""
+    frontmatter = parse_frontmatter(text) or {}
+    body = strip_frontmatter(text).strip()
+    name = file_path.name.rsplit(".", 1)[0]
+    description = str(frontmatter.get("description") or "").strip()
+    if not description:
+        description = _first_body_line(body)
+    argument_hint = frontmatter.get("argument-hint")
+    return PromptTemplate(
+        name=name,
+        description=description,
+        argument_hint=str(argument_hint).strip() if argument_hint else None,
+        content=body,
+        file_path=file_path,
+        scope=scope,
+    )
+
+
+def _first_body_line(body: str) -> str:
+    for line in body.splitlines():
+        stripped = line.strip()
+        if stripped:
+            return stripped[:60] + ("..." if len(stripped) > 60 else "")
+    return "Prompt template"

pythinker_code/prompts/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+INIT = (Path(__file__).parent / "init.md").read_text(encoding="utf-8")
+COMPACT = (Path(__file__).parent / "compact.md").read_text(encoding="utf-8")

pythinker_code/prompts/compact.md

@@ -0,0 +1,73 @@
+
+---
+
+The above is a list of messages in an agent conversation. You are now given a task to compact this conversation context according to specific priorities and rules.
+
+**Compression Priorities (in order):**
+1. **Current Task State**: What is being worked on RIGHT NOW
+2. **Errors & Solutions**: All encountered errors and their resolutions
+3. **Code Evolution**: Final working versions only (remove intermediate attempts)
+4. **System Context**: Project structure, dependencies, environment setup
+5. **Design Decisions**: Architectural choices and their rationale
+6. **TODO Items**: Unfinished tasks and known issues
+
+**Compression Rules:**
+- MUST KEEP: Error messages, stack traces, working solutions, current task
+- MERGE: Similar discussions into single summary points
+- REMOVE: Redundant explanations, failed attempts (keep lessons learned), verbose comments
+- CONDENSE: Long code blocks → keep signatures + key logic only
+
+**Special Handling:**
+- For code: Keep full version if < 20 lines, otherwise keep signature + key logic
+- For errors: Keep full error message + final solution
+- For discussions: Extract decisions and action items only
+
+**Required Output Structure:**
+
+<current_focus>
+[What we're working on now]
+</current_focus>
+
+<environment>
+- [Key setup/config points]
+- ...more...
+</environment>
+
+<completed_tasks>
+- [Task]: [Brief outcome]
+- ...more...
+</completed_tasks>
+
+<active_issues>
+- [Issue]: [Status/Next steps]
+- ...more...
+</active_issues>
+
+<code_state>
+
+<file>
+[filename]
+
+**Summary:**
+[What this code file does]
+
+**Key elements:**
+- [Important functions/classes]
+- ...more...
+
+**Latest version:**
+[Critical code snippets in this file]
+</file>
+
+<file>
+[filename]
+...Similar as above...
+</file>
+
+...more files...
+</code_state>
+
+<important_context>
+- [Any crucial information not covered above]
+- ...more...
+</important_context>

pythinker_code/prompts/init.md

@@ -0,0 +1,21 @@
+You are a software engineering expert with many years of programming experience. Please explore the current project directory to understand the project's architecture and main details.
+
+Task requirements:
+1. Analyze the project structure and identify key configuration files (such as pyproject.toml, package.json, Cargo.toml, etc.).
+2. Understand the project's technology stack, build process and runtime architecture.
+3. Identify how the code is organized and main module divisions.
+4. Discover project-specific development conventions, testing strategies, and deployment processes.
+
+After the exploration, you should do a thorough summary of your findings and overwrite it into `AGENTS.md` file in the project root. You need to refer to what is already in the file when you do so.
+
+For your information, `AGENTS.md` is a file intended to be read by AI coding agents. Expect the reader of this file know nothing about the project.
+
+You should compose this file according to the actual project content. Do not make any assumptions or generalizations. Ensure the information is accurate and useful. You must use the natural language that is mainly used in the project's comments and documentation.
+
+Popular sections that people usually write in `AGENTS.md` are:
+
+- Project overview
+- Build and test commands
+- Code style guidelines
+- Testing instructions
+- Security considerations