codebuddy-agent-sdk 0.3.7__py3-none-manylinux_2_17_x86_64.whl

codebuddy_agent_sdk/__init__.py

@@ -0,0 +1,133 @@
+"""CodeBuddy Agent SDK for Python."""
+
+from ._errors import (
+    CLIConnectionError,
+    CLIJSONDecodeError,
+    CLINotFoundError,
+    CodeBuddySDKError,
+    ExecutionError,
+    ProcessError,
+)
+from ._version import __version__
+from .client import CodeBuddySDKClient
+from .mcp import (
+    CallToolResult,
+    SdkControlServerTransport,
+    SdkMcpServerOptions,
+    SdkMcpServerResult,
+    SdkMcpToolDefinition,
+    TextContent,
+    ToolHandler,
+    create_sdk_mcp_server,
+    tool,
+)
+from .query import query
+from .transport import Transport
+from .types import (
+    AgentDefinition,
+    AppendSystemPrompt,
+    AskUserQuestionInput,
+    AskUserQuestionOption,
+    AskUserQuestionQuestion,
+    AssistantMessage,
+    CanUseTool,
+    CanUseToolOptions,
+    Checkpoint,
+    CheckpointFileChangeStats,
+    CodeBuddyAgentOptions,
+    ContentBlock,
+    ErrorMessage,
+    FileVersion,
+    HookCallback,
+    HookContext,
+    HookEvent,
+    HookJSONOutput,
+    HookMatcher,
+    McpSdkServerConfig,
+    McpServerConfig,
+    McpStdioServerConfig,
+    Message,
+    PermissionMode,
+    PermissionResult,
+    PermissionResultAllow,
+    PermissionResultDeny,
+    ResultMessage,
+    SettingSource,
+    StreamEvent,
+    SystemMessage,
+    TextBlock,
+    ThinkingBlock,
+    ToolResultBlock,
+    ToolUseBlock,
+    UserMessage,
+)
+
+__all__ = [
+    # Main API
+    "query",
+    "CodeBuddySDKClient",
+    "Transport",
+    "__version__",
+    # MCP Server API
+    "create_sdk_mcp_server",
+    "tool",
+    "SdkControlServerTransport",
+    "SdkMcpServerOptions",
+    "SdkMcpServerResult",
+    "SdkMcpToolDefinition",
+    "ToolHandler",
+    "CallToolResult",
+    "TextContent",
+    # Types - Permission
+    "PermissionMode",
+    # Types - Messages
+    "Message",
+    "UserMessage",
+    "AssistantMessage",
+    "SystemMessage",
+    "ResultMessage",
+    "StreamEvent",
+    "ErrorMessage",
+    # Types - Content blocks
+    "ContentBlock",
+    "TextBlock",
+    "ThinkingBlock",
+    "ToolUseBlock",
+    "ToolResultBlock",
+    # Types - Configuration
+    "CodeBuddyAgentOptions",
+    "AgentDefinition",
+    "AppendSystemPrompt",
+    "SettingSource",
+    # Types - Permission
+    "CanUseTool",
+    "CanUseToolOptions",
+    "PermissionResult",
+    "PermissionResultAllow",
+    "PermissionResultDeny",
+    # Types - AskUserQuestion
+    "AskUserQuestionOption",
+    "AskUserQuestionQuestion",
+    "AskUserQuestionInput",
+    # Types - Hooks
+    "HookEvent",
+    "HookCallback",
+    "HookMatcher",
+    "HookJSONOutput",
+    "HookContext",
+    # Types - Checkpoint
+    "Checkpoint",
+    "CheckpointFileChangeStats",
+    "FileVersion",
+    # Types - MCP
+    "McpServerConfig",
+    "McpStdioServerConfig",
+    "McpSdkServerConfig",
+    # Errors
+    "CodeBuddySDKError",
+    "CLIConnectionError",
+    "CLINotFoundError",
+    "CLIJSONDecodeError",
+    "ProcessError",
+    "ExecutionError",
+]

codebuddy_agent_sdk/_binary.py

@@ -0,0 +1,150 @@
+"""
+Binary locator for CodeBuddy CLI.
+
+This module provides functions to locate the CodeBuddy CLI binary.
+The binary is bundled in platform-specific wheels.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import sys
+from pathlib import Path
+
+from ._errors import CLINotFoundError
+
+__all__ = ["get_cli_path", "try_cli_path", "get_platform_info"]
+
+
+# Platform mapping for goreleaser output directories (for monorepo development)
+# Note: For musl (Alpine), the correct binary is bundled in the wheel at build time
+_PLATFORM_DIRS: dict[tuple[str, str], str] = {
+    ("Darwin", "arm64"): "darwin-arm64_bun-darwin-arm64",
+    ("Darwin", "x86_64"): "darwin-x64_bun-darwin-x64",
+    ("Linux", "x86_64"): "linux-x64_bun-linux-x64",
+    ("Linux", "aarch64"): "linux-arm64_bun-linux-arm64",
+    ("Windows", "AMD64"): "windows-x64_bun-windows-x64",
+}
+
+# Binary name per platform
+_BINARY_NAMES: dict[str, str] = {
+    "Darwin": "codebuddy",
+    "Linux": "codebuddy",
+    "Windows": "codebuddy.exe",
+}
+
+
+def _get_package_binary_path() -> Path | None:
+    """Get the binary path bundled in the package."""
+    # Binary is bundled at package_root/bin/codebuddy
+    pkg_root = Path(__file__).parent
+    system = platform.system()
+    binary_name = _BINARY_NAMES.get(system, "codebuddy")
+    bin_path = pkg_root / "bin" / binary_name
+
+    if bin_path.exists() and bin_path.is_file():
+        return bin_path
+
+    return None
+
+
+def _get_monorepo_binary_path() -> Path | None:
+    """Get the binary path from monorepo development structure."""
+    system = platform.system()
+    machine = platform.machine()
+    key = (system, machine)
+
+    dir_name = _PLATFORM_DIRS.get(key)
+    if not dir_name:
+        return None
+
+    binary_name = _BINARY_NAMES.get(system, "codebuddy")
+
+    # Try relative to this package (agent-sdk-python -> agent-cli)
+    pkg_root = Path(__file__).parent
+    monorepo_path = pkg_root.parent.parent.parent / "agent-cli" / "out" / dir_name / binary_name
+
+    if monorepo_path.exists() and monorepo_path.is_file():
+        return monorepo_path
+
+    return None
+
+
+def get_cli_path() -> str:
+    """
+    Get the path to the CodeBuddy CLI binary.
+
+    Resolution order:
+    1. CODEBUDDY_CODE_PATH environment variable
+    2. Binary bundled in the package (wheel)
+    3. Monorepo development path
+
+    Returns:
+        The absolute path to the CLI binary.
+
+    Raises:
+        CLINotFoundError: If the binary cannot be found.
+    """
+    system = platform.system()
+    machine = platform.machine()
+
+    # 1. Environment variable takes precedence
+    env_path = os.environ.get("CODEBUDDY_CODE_PATH")
+    if env_path:
+        path = Path(env_path)
+        if path.exists():
+            return str(path)
+        # Warn but continue to try other methods
+        print(
+            f"Warning: CODEBUDDY_CODE_PATH is set to '{env_path}' but file does not exist. "
+            "Falling back to other resolution methods.",
+            file=sys.stderr,
+        )
+
+    # 2. Try package bundled binary
+    pkg_path = _get_package_binary_path()
+    if pkg_path:
+        return str(pkg_path)
+
+    # 3. Try monorepo development path
+    monorepo_path = _get_monorepo_binary_path()
+    if monorepo_path:
+        return str(monorepo_path)
+
+    # 4. Nothing found - raise helpful error
+    supported = ", ".join(f"{s}-{m}" for s, m in _PLATFORM_DIRS)
+    raise CLINotFoundError(
+        f"CodeBuddy CLI binary not found for platform '{system}-{machine}'.\n\n"
+        f"Possible solutions:\n"
+        f"  1. Reinstall the package to get the correct platform wheel:\n"
+        f"     pip install --force-reinstall codebuddy-agent-sdk\n\n"
+        f"  2. Set CODEBUDDY_CODE_PATH environment variable to the CLI binary path\n\n"
+        f"  3. Install the CLI separately and set the path\n\n"
+        f"Supported platforms: {supported}",
+        system,
+        machine,
+    )
+
+
+def try_cli_path() -> str | None:
+    """
+    Try to get the CLI path without raising an exception.
+
+    Returns:
+        The CLI path if found, None otherwise.
+    """
+    try:
+        return get_cli_path()
+    except CLINotFoundError:
+        return None
+
+
+def get_platform_info() -> tuple[str, str]:
+    """
+    Get the current platform information.
+
+    Returns:
+        A tuple of (system, machine).
+    """
+    return platform.system(), platform.machine()

codebuddy_agent_sdk/_errors.py

@@ -0,0 +1,54 @@
+"""Error definitions for CodeBuddy Agent SDK."""
+
+from __future__ import annotations
+
+
+class CodeBuddySDKError(Exception):
+    """Base exception for CodeBuddy SDK errors."""
+
+    pass
+
+
+class CLIConnectionError(CodeBuddySDKError):
+    """Raised when connection to CLI fails or is not established."""
+
+    pass
+
+
+class CLINotFoundError(CodeBuddySDKError):
+    """Raised when CLI executable is not found."""
+
+    def __init__(
+        self,
+        message: str,
+        platform: str | None = None,
+        arch: str | None = None,
+    ):
+        super().__init__(message)
+        self.platform = platform
+        self.arch = arch
+
+
+class CLIJSONDecodeError(CodeBuddySDKError):
+    """Raised when JSON decoding from CLI output fails."""
+
+    pass
+
+
+class ProcessError(CodeBuddySDKError):
+    """Raised when CLI process encounters an error."""
+
+    pass
+
+
+class ExecutionError(CodeBuddySDKError):
+    """Raised when execution fails (e.g., authentication error, API error).
+
+    Contains the errors array from the ResultMessage.
+    """
+
+    def __init__(self, errors: list[str], subtype: str):
+        message = errors[0] if errors else "Execution failed"
+        super().__init__(message)
+        self.errors = errors
+        self.subtype = subtype

codebuddy_agent_sdk/_message_parser.py

@@ -0,0 +1,122 @@
+"""Message parser for CLI output."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .types import (
+    AssistantMessage,
+    ContentBlock,
+    ErrorMessage,
+    Message,
+    ResultMessage,
+    StreamEvent,
+    SystemMessage,
+    TextBlock,
+    ThinkingBlock,
+    ToolResultBlock,
+    ToolUseBlock,
+    UserMessage,
+)
+
+
+def parse_content_block(data: dict[str, Any]) -> ContentBlock | None:
+    """Parse a content block from raw data."""
+    block_type = data.get("type")
+
+    if block_type == "text":
+        return TextBlock(text=data.get("text", ""))
+
+    if block_type == "thinking":
+        return ThinkingBlock(
+            thinking=data.get("thinking", ""),
+            signature=data.get("signature", ""),
+        )
+
+    if block_type == "tool_use":
+        return ToolUseBlock(
+            id=data.get("id", ""),
+            name=data.get("name", ""),
+            input=data.get("input", {}),
+        )
+
+    if block_type == "tool_result":
+        return ToolResultBlock(
+            tool_use_id=data.get("tool_use_id", ""),
+            content=data.get("content"),
+            is_error=data.get("is_error"),
+        )
+
+    return None
+
+
+def parse_content_blocks(content: list[dict[str, Any]]) -> list[ContentBlock]:
+    """Parse a list of content blocks."""
+    blocks: list[ContentBlock] = []
+    for item in content:
+        block = parse_content_block(item)
+        if block:
+            blocks.append(block)
+    return blocks
+
+
+def parse_message(data: dict[str, Any]) -> Message | None:
+    """Parse a message from raw JSON data."""
+    msg_type = data.get("type")
+
+    if msg_type == "user":
+        message_data = data.get("message", {})
+        content = message_data.get("content", "")
+        if isinstance(content, list):
+            content = parse_content_blocks(content)
+        return UserMessage(
+            content=content,
+            uuid=data.get("uuid"),
+            parent_tool_use_id=data.get("parent_tool_use_id"),
+        )
+
+    if msg_type == "assistant":
+        message_data = data.get("message", {})
+        content = message_data.get("content", [])
+        return AssistantMessage(
+            content=parse_content_blocks(content) if isinstance(content, list) else [],
+            model=data.get("model", ""),
+            parent_tool_use_id=data.get("parent_tool_use_id"),
+            error=data.get("error"),
+        )
+
+    if msg_type == "system":
+        return SystemMessage(
+            subtype=data.get("subtype", ""),
+            data=data,
+        )
+
+    if msg_type == "result":
+        return ResultMessage(
+            subtype=data.get("subtype", ""),
+            duration_ms=data.get("duration_ms", 0),
+            duration_api_ms=data.get("duration_api_ms", 0),
+            is_error=data.get("is_error", False),
+            num_turns=data.get("num_turns", 0),
+            session_id=data.get("session_id", ""),
+            total_cost_usd=data.get("total_cost_usd"),
+            usage=data.get("usage"),
+            result=data.get("result"),
+            errors=data.get("errors"),
+        )
+
+    if msg_type == "stream_event":
+        return StreamEvent(
+            uuid=data.get("uuid", ""),
+            session_id=data.get("session_id", ""),
+            event=data.get("event", {}),
+            parent_tool_use_id=data.get("parent_tool_use_id"),
+        )
+
+    if msg_type == "error":
+        return ErrorMessage(
+            error=data.get("error", ""),
+            session_id=data.get("session_id"),
+        )
+
+    return None

codebuddy_agent_sdk/_version.py

@@ -0,0 +1,3 @@
+"""Version information for CodeBuddy Agent SDK."""
+
+__version__ = "0.3.7"