pythinker-code 2.0.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/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

pythinker_code/session.py

@@ -0,0 +1,319 @@
+from __future__ import annotations
+
+import asyncio
+import builtins
+import json
+import shutil
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+
+from pythinker_core.message import Message
+from pythinker_host.path import HostPath
+
+from pythinker_code.metadata import WorkDirMeta, load_metadata, save_metadata
+from pythinker_code.session_state import SessionState, load_session_state, save_session_state
+from pythinker_code.utils.logging import logger
+from pythinker_code.utils.string import shorten
+from pythinker_code.wire.file import WireFile
+from pythinker_code.wire.types import TurnBegin
+
+
+@dataclass(slots=True, kw_only=True)
+class Session:
+    """A session of a work directory."""
+
+    # static metadata
+    id: str
+    """The session ID."""
+    work_dir: HostPath
+    """The absolute path of the work directory."""
+    work_dir_meta: WorkDirMeta
+    """The metadata of the work directory."""
+    context_file: Path
+    """The absolute path to the file storing the message history."""
+    wire_file: WireFile
+    """The wire message log file wrapper."""
+
+    # session state
+    state: SessionState
+    """Persisted session state (approval settings, plan mode, workspace scope, etc.)."""
+
+    # refreshable metadata
+    title: str
+    """The title of the session."""
+    updated_at: float
+    """The timestamp of the last update to the session."""
+
+    @property
+    def dir(self) -> Path:
+        """The absolute path of the session directory."""
+        path = self.work_dir_meta.sessions_dir / self.id
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+
+    @property
+    def subagents_dir(self) -> Path:
+        """The absolute path of the subagent instances directory."""
+        path = self.dir / "subagents"
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+
+    def is_empty(self) -> bool:
+        """Whether the session has any context history or a custom title."""
+        if self.state.custom_title:
+            return False
+        if not self.wire_file.is_empty():
+            return False
+        try:
+            with self.context_file.open(encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    role = json.loads(line, strict=False).get("role")
+                    if isinstance(role, str) and not role.startswith("_"):
+                        return False
+        except FileNotFoundError:
+            return True
+        except (OSError, ValueError, TypeError):
+            logger.exception("Failed to read context file {file}:", file=self.context_file)
+            return False
+        return True
+
+    def save_state(self) -> None:
+        """Persist the session state to disk.
+
+        Reloads externally-mutable fields (title, archive) from disk first
+        to avoid overwriting concurrent changes made by the web API.
+        """
+        fresh = load_session_state(self.dir)
+        self.state.custom_title = fresh.custom_title
+        self.state.title_generated = fresh.title_generated
+        self.state.title_generate_attempts = fresh.title_generate_attempts
+        self.state.archived = fresh.archived
+        self.state.archived_at = fresh.archived_at
+        self.state.auto_archive_exempt = fresh.auto_archive_exempt
+        save_session_state(self.state, self.dir)
+
+    async def delete(self) -> None:
+        """Delete the session directory."""
+        session_dir = self.work_dir_meta.sessions_dir / self.id
+        if not session_dir.exists():
+            return
+        await asyncio.to_thread(shutil.rmtree, session_dir, True)
+
+    async def refresh(self) -> None:
+        self.title = "Untitled"
+        self.updated_at = self.context_file.stat().st_mtime if self.context_file.exists() else 0.0
+
+        if self.state.custom_title:
+            self.title = self.state.custom_title
+            return
+
+        try:
+            async for record in self.wire_file.iter_records():
+                wire_msg = record.to_wire_message()
+                if isinstance(wire_msg, TurnBegin):
+                    self.title = shorten(
+                        Message(role="user", content=wire_msg.user_input).extract_text(" "),
+                        width=50,
+                    )
+                    return
+        except Exception:
+            logger.exception(
+                "Failed to derive session title from wire file {file}:",
+                file=self.wire_file.path,
+            )
+
+    @staticmethod
+    async def create(
+        work_dir: HostPath,
+        session_id: str | None = None,
+        _context_file: Path | None = None,
+    ) -> Session:
+        """Create a new session for a work directory."""
+        work_dir = work_dir.canonical()
+        logger.debug("Creating new session for work directory: {work_dir}", work_dir=work_dir)
+
+        metadata = load_metadata()
+        work_dir_meta = metadata.get_work_dir_meta(work_dir)
+        if work_dir_meta is None:
+            work_dir_meta = metadata.new_work_dir_meta(work_dir)
+
+        if session_id is None:
+            session_id = str(uuid.uuid4())
+        session_dir = work_dir_meta.sessions_dir / session_id
+        session_dir.mkdir(parents=True, exist_ok=True)
+
+        if _context_file is None:
+            context_file = session_dir / "context.jsonl"
+        else:
+            logger.warning(
+                "Using provided context file: {context_file}", context_file=_context_file
+            )
+            _context_file.parent.mkdir(parents=True, exist_ok=True)
+            if _context_file.exists():
+                assert _context_file.is_file()
+            context_file = _context_file
+
+        if context_file.exists():
+            # truncate if exists
+            logger.warning(
+                "Context file already exists, truncating: {context_file}", context_file=context_file
+            )
+            context_file.unlink()
+        context_file.touch()
+
+        save_metadata(metadata)
+
+        session = Session(
+            id=session_id,
+            work_dir=work_dir,
+            work_dir_meta=work_dir_meta,
+            context_file=context_file,
+            wire_file=WireFile(path=session_dir / "wire.jsonl"),
+            state=SessionState(),
+            title="",
+            updated_at=0.0,
+        )
+        await session.refresh()
+        return session
+
+    @staticmethod
+    async def find(work_dir: HostPath, session_id: str) -> Session | None:
+        """Find a session by work directory and session ID."""
+        work_dir = work_dir.canonical()
+        logger.debug(
+            "Finding session for work directory: {work_dir}, session ID: {session_id}",
+            work_dir=work_dir,
+            session_id=session_id,
+        )
+
+        metadata = load_metadata()
+        work_dir_meta = metadata.get_work_dir_meta(work_dir)
+        if work_dir_meta is None:
+            logger.debug("Work directory never been used")
+            return None
+
+        _migrate_session_context_file(work_dir_meta, session_id)
+
+        session_dir = work_dir_meta.sessions_dir / session_id
+        if not session_dir.is_dir():
+            logger.debug("Session directory not found: {session_dir}", session_dir=session_dir)
+            return None
+
+        context_file = session_dir / "context.jsonl"
+        if not context_file.exists():
+            logger.debug(
+                "Session context file not found: {context_file}", context_file=context_file
+            )
+            return None
+
+        session = Session(
+            id=session_id,
+            work_dir=work_dir,
+            work_dir_meta=work_dir_meta,
+            context_file=context_file,
+            wire_file=WireFile(path=session_dir / "wire.jsonl"),
+            state=load_session_state(session_dir),
+            title="",
+            updated_at=0.0,
+        )
+        await session.refresh()
+        return session
+
+    @staticmethod
+    async def list(work_dir: HostPath) -> builtins.list[Session]:
+        """List all sessions for a work directory."""
+        work_dir = work_dir.canonical()
+        logger.debug("Listing sessions for work directory: {work_dir}", work_dir=work_dir)
+
+        metadata = load_metadata()
+        work_dir_meta = metadata.get_work_dir_meta(work_dir)
+        if work_dir_meta is None:
+            logger.debug("Work directory never been used")
+            return []
+
+        session_ids = {
+            path.name if path.is_dir() else path.stem
+            for path in work_dir_meta.sessions_dir.iterdir()
+            if path.is_dir() or path.suffix == ".jsonl"
+        }
+
+        sessions: list[Session] = []
+        for session_id in session_ids:
+            _migrate_session_context_file(work_dir_meta, session_id)
+            session_dir = work_dir_meta.sessions_dir / session_id
+            if not session_dir.is_dir():
+                logger.debug("Session directory not found: {session_dir}", session_dir=session_dir)
+                continue
+            context_file = session_dir / "context.jsonl"
+            if not context_file.exists():
+                logger.debug(
+                    "Session context file not found: {context_file}", context_file=context_file
+                )
+                continue
+            session = Session(
+                id=session_id,
+                work_dir=work_dir,
+                work_dir_meta=work_dir_meta,
+                context_file=context_file,
+                wire_file=WireFile(path=session_dir / "wire.jsonl"),
+                state=load_session_state(session_dir),
+                title="",
+                updated_at=0.0,
+            )
+            if session.is_empty():
+                logger.debug(
+                    "Session context file is empty: {context_file}", context_file=context_file
+                )
+                continue
+            await session.refresh()
+            sessions.append(session)
+        sessions.sort(key=lambda session: session.updated_at, reverse=True)
+        return sessions
+
+    @classmethod
+    async def list_all(cls) -> builtins.list[Session]:
+        """List sessions across all known work directories."""
+        all_sessions: list[Session] = []
+        for wd in load_metadata().work_dirs:
+            sessions = await cls.list(HostPath.unsafe_from_local_path(Path(wd.path)))
+            all_sessions.extend(sessions)
+        all_sessions.sort(key=lambda s: s.updated_at, reverse=True)
+        return all_sessions
+
+    @staticmethod
+    async def continue_(work_dir: HostPath) -> Session | None:
+        """Get the last session for a work directory."""
+        work_dir = work_dir.canonical()
+        logger.debug("Continuing session for work directory: {work_dir}", work_dir=work_dir)
+
+        metadata = load_metadata()
+        work_dir_meta = metadata.get_work_dir_meta(work_dir)
+        if work_dir_meta is None:
+            logger.debug("Work directory never been used")
+            return None
+        if work_dir_meta.last_session_id is None:
+            logger.debug("Work directory never had a session")
+            return None
+
+        logger.debug(
+            "Found last session for work directory: {session_id}",
+            session_id=work_dir_meta.last_session_id,
+        )
+        return await Session.find(work_dir, work_dir_meta.last_session_id)
+
+
+def _migrate_session_context_file(work_dir_meta: WorkDirMeta, session_id: str) -> None:
+    old_context_file = work_dir_meta.sessions_dir / f"{session_id}.jsonl"
+    new_context_file = work_dir_meta.sessions_dir / session_id / "context.jsonl"
+    if old_context_file.exists() and not new_context_file.exists():
+        new_context_file.parent.mkdir(parents=True, exist_ok=True)
+        old_context_file.rename(new_context_file)
+        logger.info(
+            "Migrated session context file from {old} to {new}",
+            old=old_context_file,
+            new=new_context_file,
+        )