pidevkit-coding-agent 0.1.0__tar.gz

pidevkit_coding_agent-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+.pytest_cache/
+.ruff_cache/
+.venv/
+*.pyc
+*.pyo
+*.pyd
+.coverage
+.coverage.*
+htmlcov/
+dist/
+build/
+*.egg-info/
+.mypy_cache/
+.DS_Store

pidevkit_coding_agent-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: pidevkit-coding-agent
+Version: 0.1.0
+Summary: Coding-agent implementation for pidevkit
+Requires-Python: >=3.11
+Requires-Dist: pidevkit-ai>=0.1.0
+Requires-Dist: pidevkit-tui>=0.1.0
+Requires-Dist: pillow>=12.0.0
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# pidevkit-coding-agent
+
+Port of the coding-agent subsystem, including resource loading, session handling, extension hooks, and utilities.
+
+## Install
+
+```bash
+pip install pidevkit-coding-agent
+```
+
+## Import
+
+```python
+from pidevkit.coding_agent.core.session_manager import SessionManager
+```

pidevkit_coding_agent-0.1.0/README.md

@@ -0,0 +1,15 @@
+# pidevkit-coding-agent
+
+Port of the coding-agent subsystem, including resource loading, session handling, extension hooks, and utilities.
+
+## Install
+
+```bash
+pip install pidevkit-coding-agent
+```
+
+## Import
+
+```python
+from pidevkit.coding_agent.core.session_manager import SessionManager
+```

pidevkit_coding_agent-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling>=1.24.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pidevkit-coding-agent"
+version = "0.1.0"
+description = "Coding-agent implementation for pidevkit"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+  "pidevkit-ai>=0.1.0",
+  "pidevkit-tui>=0.1.0",
+  "Pillow>=12.0.0",
+  "PyYAML>=6.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pidevkit/coding_agent"]

pidevkit_coding_agent-0.1.0/src/pidevkit/coding_agent/cli/args.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from typing import Any, Literal, Mapping
+
+Mode = Literal["text", "json", "rpc"]
+ThinkingLevel = Literal["off", "minimal", "low", "medium", "high", "xhigh"]
+ToolName = Literal["read", "bash", "edit", "write", "grep", "find", "ls"]
+
+VALID_THINKING_LEVELS: tuple[ThinkingLevel, ...] = ("off", "minimal", "low", "medium", "high", "xhigh")
+VALID_TOOLS: tuple[ToolName, ...] = ("read", "bash", "edit", "write", "grep", "find", "ls")
+
+
+def is_valid_thinking_level(level: str) -> bool:
+    return level in VALID_THINKING_LEVELS
+
+
+def parse_args(
+    args: list[str],
+    extension_flags: Mapping[str, Mapping[str, Literal["boolean", "string"]]] | None = None,
+) -> dict[str, Any]:
+    """Parse coding-agent CLI args with compatibility to the TypeScript parser."""
+
+    result: dict[str, Any] = {
+        "messages": [],
+        "fileArgs": [],
+        "unknownFlags": {},
+    }
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+
+        if arg in {"--help", "-h"}:
+            result["help"] = True
+        elif arg in {"--version", "-v"}:
+            result["version"] = True
+        elif arg == "--mode" and i + 1 < len(args):
+            i += 1
+            mode = args[i]
+            if mode in {"text", "json", "rpc"}:
+                result["mode"] = mode
+        elif arg in {"--continue", "-c"}:
+            result["continue"] = True
+        elif arg in {"--resume", "-r"}:
+            result["resume"] = True
+        elif arg == "--provider" and i + 1 < len(args):
+            i += 1
+            result["provider"] = args[i]
+        elif arg == "--model" and i + 1 < len(args):
+            i += 1
+            result["model"] = args[i]
+        elif arg == "--api-key" and i + 1 < len(args):
+            i += 1
+            result["apiKey"] = args[i]
+        elif arg == "--system-prompt" and i + 1 < len(args):
+            i += 1
+            result["systemPrompt"] = args[i]
+        elif arg == "--append-system-prompt" and i + 1 < len(args):
+            i += 1
+            result["appendSystemPrompt"] = args[i]
+        elif arg == "--no-session":
+            result["noSession"] = True
+        elif arg == "--session" and i + 1 < len(args):
+            i += 1
+            result["session"] = args[i]
+        elif arg == "--session-dir" and i + 1 < len(args):
+            i += 1
+            result["sessionDir"] = args[i]
+        elif arg == "--models" and i + 1 < len(args):
+            i += 1
+            result["models"] = [part.strip() for part in args[i].split(",")]
+        elif arg == "--no-tools":
+            result["noTools"] = True
+        elif arg == "--tools" and i + 1 < len(args):
+            i += 1
+            tool_names = [part.strip() for part in args[i].split(",")]
+            result["tools"] = [name for name in tool_names if name in VALID_TOOLS]
+        elif arg == "--thinking" and i + 1 < len(args):
+            i += 1
+            level = args[i]
+            if is_valid_thinking_level(level):
+                result["thinking"] = level
+        elif arg in {"--print", "-p"}:
+            result["print"] = True
+        elif arg == "--export" and i + 1 < len(args):
+            i += 1
+            result["export"] = args[i]
+        elif arg in {"--extension", "-e"} and i + 1 < len(args):
+            i += 1
+            extensions: list[str] = result.setdefault("extensions", [])
+            extensions.append(args[i])
+        elif arg in {"--no-extensions", "-ne"}:
+            result["noExtensions"] = True
+        elif arg == "--skill" and i + 1 < len(args):
+            i += 1
+            skills: list[str] = result.setdefault("skills", [])
+            skills.append(args[i])
+        elif arg == "--prompt-template" and i + 1 < len(args):
+            i += 1
+            prompt_templates: list[str] = result.setdefault("promptTemplates", [])
+            prompt_templates.append(args[i])
+        elif arg == "--theme" and i + 1 < len(args):
+            i += 1
+            themes: list[str] = result.setdefault("themes", [])
+            themes.append(args[i])
+        elif arg in {"--no-skills", "-ns"}:
+            result["noSkills"] = True
+        elif arg in {"--no-prompt-templates", "-np"}:
+            result["noPromptTemplates"] = True
+        elif arg == "--no-themes":
+            result["noThemes"] = True
+        elif arg == "--list-models":
+            if i + 1 < len(args) and not args[i + 1].startswith("-") and not args[i + 1].startswith("@"):
+                i += 1
+                result["listModels"] = args[i]
+            else:
+                result["listModels"] = True
+        elif arg == "--verbose":
+            result["verbose"] = True
+        elif arg.startswith("@"):
+            file_args: list[str] = result["fileArgs"]
+            file_args.append(arg[1:])
+        elif arg.startswith("--") and extension_flags is not None:
+            flag_name = arg[2:]
+            ext_flag = extension_flags.get(flag_name)
+            if ext_flag:
+                flag_type = ext_flag.get("type")
+                if flag_type == "boolean":
+                    unknown_flags: dict[str, bool | str] = result["unknownFlags"]
+                    unknown_flags[flag_name] = True
+                elif flag_type == "string" and i + 1 < len(args):
+                    i += 1
+                    unknown_flags = result["unknownFlags"]
+                    unknown_flags[flag_name] = args[i]
+        elif not arg.startswith("-"):
+            messages: list[str] = result["messages"]
+            messages.append(arg)
+
+        i += 1
+
+    return result

pidevkit_coding_agent-0.1.0/src/pidevkit/coding_agent/core/auth_storage.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from threading import RLock
+from typing import Any, Callable, Literal, TypedDict
+
+from pidevkit.ai.stream import get_env_api_key
+
+from .resolve_config_value import resolve_config_value
+
+CredentialType = Literal["api_key", "oauth"]
+
+
+class ApiKeyCredential(TypedDict):
+    type: Literal["api_key"]
+    key: str
+
+
+class OAuthCredential(TypedDict, total=False):
+    type: Literal["oauth"]
+    refresh: str
+    access: str
+    expires: int
+
+
+AuthCredential = ApiKeyCredential | OAuthCredential
+AuthStorageData = dict[str, AuthCredential]
+
+
+@dataclass(frozen=True, slots=True)
+class LockResult:
+    result: Any
+    next: str | None = None
+
+
+class AuthStorageBackend:
+    def with_lock(self, fn: Callable[[str | None], LockResult]) -> Any:
+        raise NotImplementedError
+
+    async def with_lock_async(self, fn: Callable[[str | None], asyncio.Future | Any]) -> Any:  # noqa: ANN401
+        raise NotImplementedError
+
+
+class FileAuthStorageBackend(AuthStorageBackend):
+    def __init__(self, auth_path: str | Path) -> None:
+        self.auth_path = Path(auth_path)
+        self._lock = RLock()
+
+    def _ensure_file(self) -> None:
+        self.auth_path.parent.mkdir(parents=True, exist_ok=True)
+        if not self.auth_path.exists():
+            self.auth_path.write_text("{}", encoding="utf-8")
+
+    def with_lock(self, fn: Callable[[str | None], LockResult]) -> Any:
+        with self._lock:
+            self._ensure_file()
+            current = self.auth_path.read_text(encoding="utf-8") if self.auth_path.exists() else None
+            payload = fn(current)
+            if payload.next is not None:
+                self.auth_path.write_text(payload.next, encoding="utf-8")
+            return payload.result
+
+    async def with_lock_async(self, fn: Callable[[str | None], asyncio.Future | Any]) -> Any:  # noqa: ANN401
+        with self._lock:
+            self._ensure_file()
+            current = self.auth_path.read_text(encoding="utf-8") if self.auth_path.exists() else None
+            value = fn(current)
+            payload = await value if asyncio.iscoroutine(value) else value
+            if payload.next is not None:
+                self.auth_path.write_text(payload.next, encoding="utf-8")
+            return payload.result
+
+
+class InMemoryAuthStorageBackend(AuthStorageBackend):
+    def __init__(self, value: str | None = None) -> None:
+        self.value = value
+        self._lock = RLock()
+
+    def with_lock(self, fn: Callable[[str | None], LockResult]) -> Any:
+        with self._lock:
+            payload = fn(self.value)
+            if payload.next is not None:
+                self.value = payload.next
+            return payload.result
+
+    async def with_lock_async(self, fn: Callable[[str | None], asyncio.Future | Any]) -> Any:  # noqa: ANN401
+        with self._lock:
+            value = fn(self.value)
+            payload = await value if asyncio.iscoroutine(value) else value
+            if payload.next is not None:
+                self.value = payload.next
+            return payload.result
+
+
+class AuthStorage:
+    def __init__(self, backend: AuthStorageBackend) -> None:
+        self._backend = backend
+        self._data: AuthStorageData = {}
+        self._runtime_overrides: dict[str, str] = {}
+        self._fallback_resolver: Callable[[str], str | None] | None = None
+        self._errors: list[Exception] = []
+        self._load_error: Exception | None = None
+        self.reload()
+
+    @classmethod
+    def create(cls, auth_path: str | Path) -> AuthStorage:
+        return cls(FileAuthStorageBackend(auth_path))
+
+    @classmethod
+    def from_storage(cls, backend: AuthStorageBackend) -> AuthStorage:
+        return cls(backend)
+
+    @classmethod
+    def in_memory(cls, data: AuthStorageData | None = None) -> AuthStorage:
+        value = json.dumps(data or {}, ensure_ascii=False, indent=2)
+        return cls(InMemoryAuthStorageBackend(value))
+
+    def _parse_storage_data(self, content: str | None) -> AuthStorageData:
+        if not content:
+            return {}
+        parsed = json.loads(content)
+        if not isinstance(parsed, dict):
+            return {}
+        return parsed  # type: ignore[return-value]
+
+    def _record_error(self, error: Exception) -> None:
+        self._errors.append(error)
+
+    def reload(self) -> None:
+        content: str | None = None
+        try:
+            def _capture(current: str | None) -> LockResult:
+                nonlocal content
+                content = current
+                return LockResult(result=None, next=None)
+
+            self._backend.with_lock(_capture)
+        except Exception as exc:  # noqa: BLE001
+            self._load_error = exc
+            self._record_error(exc)
+            return
+
+        try:
+            self._data = self._parse_storage_data(content)
+            self._load_error = None
+        except Exception as exc:  # noqa: BLE001
+            self._load_error = exc
+            self._record_error(exc)
+
+    def _persist_provider_change(self, provider: str, credential: AuthCredential | None) -> None:
+        if self._load_error is not None:
+            return
+
+        try:
+            def _mutate(current: str | None) -> LockResult:
+                merged = self._parse_storage_data(current)
+                if credential is None:
+                    merged.pop(provider, None)
+                else:
+                    merged[provider] = credential
+                return LockResult(result=None, next=json.dumps(merged, ensure_ascii=False, indent=2))
+
+            self._backend.with_lock(_mutate)
+        except Exception as exc:  # noqa: BLE001
+            self._record_error(exc if isinstance(exc, Exception) else Exception(str(exc)))
+
+    def set_runtime_api_key(self, provider: str, api_key: str) -> None:
+        self._runtime_overrides[provider] = api_key
+
+    def setRuntimeApiKey(self, provider: str, api_key: str) -> None:
+        self.set_runtime_api_key(provider, api_key)
+
+    def remove_runtime_api_key(self, provider: str) -> None:
+        self._runtime_overrides.pop(provider, None)
+
+    def removeRuntimeApiKey(self, provider: str) -> None:
+        self.remove_runtime_api_key(provider)
+
+    def set_fallback_resolver(self, resolver: Callable[[str], str | None]) -> None:
+        self._fallback_resolver = resolver
+
+    def setFallbackResolver(self, resolver: Callable[[str], str | None]) -> None:
+        self.set_fallback_resolver(resolver)
+
+    def get(self, provider: str) -> AuthCredential | None:
+        value = self._data.get(provider)
+        return value.copy() if isinstance(value, dict) else None
+
+    def set(self, provider: str, credential: AuthCredential) -> None:
+        self._data[provider] = credential
+        self._persist_provider_change(provider, credential)
+
+    def remove(self, provider: str) -> None:
+        self._data.pop(provider, None)
+        self._persist_provider_change(provider, None)
+
+    def list(self) -> list[str]:
+        return list(self._data.keys())
+
+    def has(self, provider: str) -> bool:
+        return provider in self._data
+
+    def has_auth(self, provider: str) -> bool:
+        if provider in self._runtime_overrides:
+            return True
+        if provider in self._data:
+            return True
+        if get_env_api_key(provider):
+            return True
+        fallback = self._fallback_resolver(provider) if self._fallback_resolver else None
+        return bool(fallback)
+
+    def hasAuth(self, provider: str) -> bool:
+        return self.has_auth(provider)
+
+    def get_all(self) -> AuthStorageData:
+        return dict(self._data)
+
+    def getAll(self) -> AuthStorageData:
+        return self.get_all()
+
+    def drain_errors(self) -> list[Exception]:
+        drained = list(self._errors)
+        self._errors.clear()
+        return drained
+
+    def drainErrors(self) -> list[Exception]:
+        return self.drain_errors()
+
+    def _resolve_api_key_credential(self, credential: AuthCredential) -> str | None:
+        if credential.get("type") != "api_key":
+            return None
+        key = credential.get("key")
+        if not isinstance(key, str):
+            return None
+        return resolve_config_value(key)
+
+    async def get_api_key(self, provider: str) -> str | None:
+        runtime = self._runtime_overrides.get(provider)
+        if runtime:
+            return runtime
+
+        credential = self._data.get(provider)
+        if isinstance(credential, dict):
+            resolved = self._resolve_api_key_credential(credential)
+            if resolved:
+                return resolved
+
+        env = get_env_api_key(provider)
+        if env:
+            return env
+
+        if self._fallback_resolver:
+            fallback = self._fallback_resolver(provider)
+            if fallback:
+                return fallback
+
+        return None
+
+    async def getApiKey(self, provider: str) -> str | None:
+        return await self.get_api_key(provider)
+
+    # OAuth support is intentionally minimal in this port.
+    async def login(self, provider_id: str, callbacks: Any) -> None:  # noqa: ANN401
+        raise NotImplementedError(f"OAuth login is not implemented for provider {provider_id}")
+
+    def logout(self, provider: str) -> None:
+        self.remove(provider)
+
+    def get_oauth_providers(self) -> list[Any]:  # noqa: ANN401
+        return []
+
+    def getOAuthProviders(self) -> list[Any]:  # noqa: ANN401
+        return self.get_oauth_providers()
+
+
+__all__ = [
+    "ApiKeyCredential",
+    "AuthCredential",
+    "AuthStorage",
+    "AuthStorageBackend",
+    "AuthStorageData",
+    "FileAuthStorageBackend",
+    "InMemoryAuthStorageBackend",
+    "OAuthCredential",
+]

pidevkit_coding_agent-0.1.0/src/pidevkit/coding_agent/core/diagnostics.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Literal, TypedDict
+
+
+class ResourceDiagnostic(TypedDict, total=False):
+    type: Literal["warning", "error"]
+    message: str
+    path: str
+
+
+class ResourceCollision(TypedDict, total=False):
+    path: str
+    message: str
+
+
+__all__ = ["ResourceCollision", "ResourceDiagnostic"]

pidevkit_coding_agent-0.1.0/src/pidevkit/coding_agent/core/extensions_input_event.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import inspect
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Any, Literal
+
+InputSource = Literal["interactive", "rpc", "extension"]
+InputAction = Literal["continue", "transform", "handled"]
+
+InputHandler = Callable[[dict[str, Any]], Awaitable[dict[str, Any] | None] | dict[str, Any] | None]
+ErrorListener = Callable[[Exception], None]
+
+
+@dataclass(frozen=True, slots=True)
+class InputEventResult:
+    action: InputAction
+    text: str | None = None
+    images: list[dict[str, Any]] | None = None
+
+
+async def _invoke_handler(handler: InputHandler, event: dict[str, Any]) -> dict[str, Any] | None:
+    result = handler(event)
+    if inspect.isawaitable(result):
+        awaited = await result
+        return awaited if isinstance(awaited, dict) else None
+    return result if isinstance(result, dict) else None
+
+
+class InputEventRunner:
+    def __init__(self, handlers: list[InputHandler] | None = None) -> None:
+        self._handlers: list[InputHandler] = list(handlers or [])
+        self._error_listeners: list[ErrorListener] = []
+
+    def add_handler(self, handler: InputHandler) -> None:
+        self._handlers.append(handler)
+
+    def addHandler(self, handler: InputHandler) -> None:
+        self.add_handler(handler)
+
+    def on_error(self, listener: ErrorListener) -> None:
+        self._error_listeners.append(listener)
+
+    def onError(self, listener: ErrorListener) -> None:
+        self.on_error(listener)
+
+    def has_handlers(self) -> bool:
+        return bool(self._handlers)
+
+    def hasHandlers(self) -> bool:
+        return self.has_handlers()
+
+    async def emit_input(
+        self,
+        text: str,
+        images: list[dict[str, Any]] | None,
+        source: InputSource,
+    ) -> InputEventResult:
+        current_text = text
+        current_images = images
+
+        for handler in self._handlers:
+            event = {
+                "type": "input",
+                "text": current_text,
+                "images": current_images,
+                "source": source,
+            }
+            try:
+                result = await _invoke_handler(handler, event)
+            except Exception as exc:  # noqa: BLE001
+                for listener in self._error_listeners:
+                    listener(exc)
+                continue
+
+            if result is None:
+                continue
+
+            action = result.get("action")
+            if action == "handled":
+                return InputEventResult(
+                    action="handled",
+                    text=str(result.get("text")) if isinstance(result.get("text"), str) else None,
+                    images=result.get("images") if isinstance(result.get("images"), list) else None,
+                )
+            if action == "transform":
+                next_text = result.get("text")
+                if isinstance(next_text, str):
+                    current_text = next_text
+                if "images" in result:
+                    images_value = result.get("images")
+                    if images_value is None or isinstance(images_value, list):
+                        current_images = images_value
+                continue
+
+        if current_text != text or current_images != images:
+            return InputEventResult(action="transform", text=current_text, images=current_images)
+        return InputEventResult(action="continue")
+
+    async def emitInput(
+        self,
+        text: str,
+        images: list[dict[str, Any]] | None,
+        source: InputSource,
+    ) -> InputEventResult:
+        return await self.emit_input(text, images, source)
+
+
+async def emit_input(
+    handlers: list[InputHandler],
+    *,
+    text: str,
+    images: list[dict[str, Any]] | None,
+    source: InputSource,
+) -> InputEventResult:
+    runner = InputEventRunner(handlers)
+    return await runner.emit_input(text, images, source)
+
+
+emitInput = emit_input