vibecore 0.2.0a1__py3-none-any.whl

vibecore/session/jsonl_session.py

@@ -0,0 +1,236 @@
+"""JSONL-based session storage implementation for openai-agents SDK."""
+
+import json
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from openai.types.responses import ResponseInputItemParam as TResponseInputItem
+
+from .file_lock import acquire_file_lock, cleanup_file_lock
+from .path_utils import get_session_file_path
+
+logger = logging.getLogger(__name__)
+
+
+class JSONLSession:
+    """JSONL-based implementation of the agents.Session protocol.
+
+    Stores conversation history in JSON Lines format, with one JSON object
+    per line. This provides human-readable storage and efficient append operations.
+
+    The session files are stored at:
+    {base_dir}/projects/{canonicalized_project_path}/{session_id}.jsonl
+    """
+
+    def __init__(
+        self,
+        session_id: str,
+        project_path: str | Path | None = None,
+        base_dir: str | Path | None = None,
+    ):
+        """Initialize the JSONL session.
+
+        Args:
+            session_id: Unique identifier for the session
+            project_path: Project path to canonicalize (defaults to cwd)
+            base_dir: Base directory for sessions (defaults to ~/.vibecore)
+        """
+        self.session_id = session_id
+
+        # Set default project path to current working directory
+        if project_path is None:
+            self.project_path = Path.cwd()
+        else:
+            self.project_path = Path(project_path)
+
+        # Set default base directory
+        if base_dir is None:
+            self.base_dir = Path.home() / ".vibecore"
+        else:
+            self.base_dir = Path(base_dir)
+
+        # Get the full path to the session file
+        self.file_path = get_session_file_path(
+            self.session_id,
+            self.project_path,
+            self.base_dir,
+        )
+
+        # Ensure the parent directory exists
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        logger.debug(f"Initialized JSONLSession for {self.session_id} at {self.file_path}")
+
+    async def get_items(self, limit: int | None = None) -> list["TResponseInputItem"]:
+        """Retrieve the conversation history for this session.
+
+        Args:
+            limit: Maximum number of items to retrieve. If None, retrieves all items.
+                   When specified, returns the latest N items in chronological order.
+
+        Returns:
+            List of input items representing the conversation history
+        """
+        # If file doesn't exist, return empty list
+        if not self.file_path.exists():
+            return []
+
+        items: list[TResponseInputItem] = []
+
+        async with acquire_file_lock(self.file_path, exclusive=False):
+            try:
+                if limit is None:
+                    # Read entire file sequentially
+                    with open(self.file_path, encoding="utf-8") as f:
+                        for line in f:
+                            line = line.strip()
+                            if not line:
+                                continue
+                            try:
+                                item = json.loads(line)
+                                items.append(item)
+                            except json.JSONDecodeError as e:
+                                logger.warning(f"Skipping invalid JSON line in {self.file_path}: {e}")
+                else:
+                    # Read file backwards to get last N items efficiently
+                    # For now, read all and slice (optimize in Phase 2)
+                    all_items = []
+                    with open(self.file_path, encoding="utf-8") as f:
+                        for line in f:
+                            line = line.strip()
+                            if not line:
+                                continue
+                            try:
+                                item = json.loads(line)
+                                all_items.append(item)
+                            except json.JSONDecodeError as e:
+                                logger.warning(f"Skipping invalid JSON line in {self.file_path}: {e}")
+
+                    # Return the last N items
+                    items = all_items[-limit:] if len(all_items) > limit else all_items
+
+            except FileNotFoundError:
+                # File was deleted between existence check and read
+                return []
+            except Exception as e:
+                logger.error(f"Error reading session file {self.file_path}: {e}")
+                raise
+
+        return items
+
+    async def add_items(self, items: list["TResponseInputItem"]) -> None:
+        """Add new items to the conversation history.
+
+        Args:
+            items: List of input items to add to the history
+        """
+        if not items:
+            return
+
+        # Ensure parent directory exists
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        async with acquire_file_lock(self.file_path, exclusive=True):
+            try:
+                # Open file in append mode
+                with open(self.file_path, "a", encoding="utf-8") as f:
+                    for item in items:
+                        # Write each item as a JSON line
+                        json_line = json.dumps(item, ensure_ascii=False, separators=(",", ":"))
+                        f.write(json_line + "\n")
+
+                    # Ensure data is written to disk
+                    f.flush()
+
+                logger.debug(f"Added {len(items)} items to session {self.session_id}")
+
+            except Exception as e:
+                logger.error(f"Error adding items to session file {self.file_path}: {e}")
+                raise
+
+    async def pop_item(self) -> "TResponseInputItem | None":
+        """Remove and return the most recent item from the session.
+
+        Returns:
+            The most recent item if it exists, None if the session is empty
+        """
+        if not self.file_path.exists():
+            return None
+
+        async with acquire_file_lock(self.file_path, exclusive=True):
+            try:
+                # Read all lines
+                with open(self.file_path, encoding="utf-8") as f:
+                    lines = f.readlines()
+
+                if not lines:
+                    return None
+
+                # Find the last non-empty line
+                last_item = None
+                last_item_index = -1
+
+                for i in range(len(lines) - 1, -1, -1):
+                    line = lines[i].strip()
+                    if line:
+                        try:
+                            last_item = json.loads(line)
+                            last_item_index = i
+                            break
+                        except json.JSONDecodeError as e:
+                            logger.warning(f"Skipping invalid JSON line in {self.file_path}: {e}")
+
+                if last_item is None:
+                    return None
+
+                # Remove the last item and write back the rest
+                remaining_lines = lines[:last_item_index]
+
+                # Write atomically by writing to a temp file and renaming
+                temp_file = self.file_path.with_suffix(".tmp")
+                try:
+                    with open(temp_file, "w", encoding="utf-8") as f:
+                        f.writelines(remaining_lines)
+
+                    # Atomically replace the original file
+                    temp_file.replace(self.file_path)
+
+                except Exception:
+                    # Clean up temp file if something went wrong
+                    if temp_file.exists():
+                        temp_file.unlink()
+                    raise
+
+                logger.debug(f"Popped item from session {self.session_id}")
+                return last_item
+
+            except FileNotFoundError:
+                # File was deleted between existence check and read
+                return None
+            except Exception as e:
+                logger.error(f"Error popping item from session file {self.file_path}: {e}")
+                raise
+
+    async def clear_session(self) -> None:
+        """Clear all items for this session."""
+        if not self.file_path.exists():
+            return
+
+        async with acquire_file_lock(self.file_path, exclusive=True):
+            try:
+                # Delete the file
+                self.file_path.unlink()
+
+                # Clean up the lock for this file
+                cleanup_file_lock(self.file_path)
+
+                logger.debug(f"Cleared session {self.session_id}")
+
+            except FileNotFoundError:
+                # File was already deleted
+                pass
+            except Exception as e:
+                logger.error(f"Error clearing session file {self.file_path}: {e}")
+                raise

vibecore/session/loader.py

@@ -0,0 +1,193 @@
+"""Session loading functionality for vibecore."""
+
+from typing import Any
+
+from openai.types.responses import (
+    ResponseFunctionToolCall,
+    ResponseInputItemParam,
+    ResponseOutputItem,
+    ResponseOutputMessage,
+    ResponseReasoningItem,
+)
+from pydantic import TypeAdapter
+from textual import log
+
+from vibecore.session.jsonl_session import JSONLSession
+from vibecore.utils.text import TextExtractor
+from vibecore.widgets.messages import (
+    AgentMessage,
+    BaseMessage,
+    MessageStatus,
+    ReasoningMessage,
+    UserMessage,
+)
+from vibecore.widgets.tool_message_factory import create_tool_message
+from vibecore.widgets.tool_messages import BaseToolMessage
+
+
+class SessionLoader:
+    """Loads and parses session history into message widgets."""
+
+    def __init__(self, session: JSONLSession):
+        """Initialize SessionLoader with a session.
+
+        Args:
+            session: The JSONL session to load from
+        """
+        self.session = session
+        self.adapter = TypeAdapter(ResponseOutputItem)
+        self.tool_calls_pending: dict[str, tuple[str, str]] = {}
+
+    async def load_history(self) -> list[BaseMessage]:
+        """Load all session items and convert to message widgets.
+
+        Returns:
+            List of message widgets from the session history
+
+        Raises:
+            RuntimeError: If there are pending tool calls without outputs
+        """
+        session_items = await self.session.get_items()
+        messages = []
+
+        for item in session_items:
+            if message := self.parse_session_item(item):
+                messages.append(message)
+
+        self._validate_no_pending_calls()
+        return messages
+
+    def parse_session_item(self, item: ResponseInputItemParam) -> BaseMessage | None:
+        """Parse a single session item into a message widget.
+
+        Args:
+            item: Raw session item from the session
+
+        Returns:
+            A message widget or None if item cannot be parsed
+        """
+        # Try to parse as output item first
+        if output_item := self._parse_output_item(item):
+            return output_item
+
+        # Otherwise try to parse as input item
+        return self._parse_input_item(item)
+
+    def _parse_output_item(self, item: Any) -> BaseMessage | None:
+        """Try to parse item as ResponseOutputItem.
+
+        Args:
+            item: Raw item dict
+
+        Returns:
+            A message widget or None if not a valid output item
+        """
+        try:
+            output_item = self.adapter.validate_python(item)
+
+            match output_item:
+                case ResponseOutputMessage(role="user", content=content):
+                    # User message
+                    text_content = TextExtractor.extract_from_content(content)
+                    return UserMessage(text_content)
+
+                case ResponseReasoningItem(summary=summary):
+                    # assert len(summary) == 1, "Summary must contain exactly one item"
+                    summary_merged = "\n\n".join(item.text for item in summary) if summary else "Thinking..."
+                    return ReasoningMessage(summary_merged, status=MessageStatus.IDLE)
+
+                case ResponseOutputMessage(role="assistant", content=content):
+                    # Handle assistant messages
+                    text_content = TextExtractor.extract_from_content(content)
+                    if text_content:
+                        # If agent decides to immediately tool call, we often have no text content
+                        return AgentMessage(text_content, status=MessageStatus.IDLE)
+                    return None
+
+                case ResponseFunctionToolCall(call_id=call_id, name=name, arguments=arguments) if call_id:
+                    log(f"Tool call: {name} with arguments: {arguments}")
+                    # Tool call - store for matching with output
+                    self._handle_tool_call(call_id, name, str(arguments))
+                    return None
+
+                case _:
+                    # Log unknown output item types for debugging
+                    log(f"Unknown output item type: {type(output_item).__name__}")
+                    return None
+
+        except Exception:
+            # Not a valid output item
+            return None
+
+    def _parse_input_item(self, item: Any) -> BaseMessage | None:
+        """Parse items that are input-only (not valid output items).
+
+        Args:
+            item: Raw item
+
+        Returns:
+            A message widget or None if item cannot be parsed
+        """
+        if not isinstance(item, dict):
+            return None
+
+        match item:
+            case {"role": "user", "content": content}:
+                # User message input (EasyInputMessageParam is not convertible to ResponseOutputMessage)
+                text_content = str(content) if isinstance(content, list) else content
+                return UserMessage(text_content)
+
+            case {"type": "function_call_output", "call_id": call_id, "output": output}:
+                # Tool output - check if we have a pending call
+                return self._create_tool_message(call_id, output)
+
+            case _:
+                # Log unhandled input items
+                log(f"Unhandled session item: {item}")
+                return None
+
+    def _handle_tool_call(self, call_id: str, name: str, arguments: str) -> None:
+        """Track pending tool calls for matching with outputs.
+
+        Args:
+            call_id: The tool call ID
+            name: The tool name
+            arguments: The tool arguments as a string
+        """
+        self.tool_calls_pending[call_id] = (name, arguments)
+
+    def _create_tool_message(self, call_id: str, output: str) -> BaseToolMessage | None:
+        """Create tool message by matching call_id with pending calls.
+
+        Args:
+            call_id: The tool call ID
+            output: The tool output
+
+        Returns:
+            A BaseToolMessage widget, or None if no matching call found
+        """
+        if not call_id or call_id not in self.tool_calls_pending:
+            return None
+
+        tool_name, command = self.tool_calls_pending.pop(call_id)
+
+        # Determine status based on output
+        output_str = str(output) if output else ""
+        status = MessageStatus.SUCCESS
+
+        # Use factory to create the appropriate tool message with output
+        return create_tool_message(
+            tool_name=tool_name,
+            arguments=command,
+            output=output_str,
+            status=status,
+        )
+
+    def _validate_no_pending_calls(self) -> None:
+        """Validate that there are no pending tool calls without outputs.
+
+        Raises:
+            RuntimeError: If there are pending tool calls
+        """
+        if self.tool_calls_pending:
+            raise RuntimeError(f"Pending tool calls without outputs found: {self.tool_calls_pending}")

vibecore/session/path_utils.py

@@ -0,0 +1,81 @@
+"""Path utilities for session file management."""
+
+from pathlib import Path
+
+
+def canonicalize_path(path: Path) -> str:
+    """Convert a path to a safe directory name.
+
+    Converts absolute paths to a safe format suitable for use as a directory name.
+    Replaces path separators with hyphens to create a flat namespace.
+
+    Args:
+        path: The path to canonicalize
+
+    Returns:
+        A canonicalized string safe for use as a directory name
+
+    Example:
+        >>> canonicalize_path(Path("/Users/serialx/workspace/vibecore"))
+        '-Users-serialx-workspace-vibecore'
+    """
+    # Resolve to absolute path and convert to string
+    absolute_path = path.resolve()
+    path_str = str(absolute_path)
+
+    # Replace path separators with hyphens
+    # This creates a flat namespace while preserving path uniqueness
+    canonicalized = path_str.replace("/", "-")
+
+    # Handle Windows paths (replace backslashes and colons)
+    canonicalized = canonicalized.replace("\\", "-")
+    canonicalized = canonicalized.replace(":", "")
+
+    # Remove any leading/trailing hyphens that might occur
+    canonicalized = canonicalized.strip("-")
+
+    # Ensure we always have a non-empty result
+    if not canonicalized:
+        canonicalized = "root"
+
+    return canonicalized
+
+
+def get_session_file_path(
+    session_id: str,
+    project_path: Path,
+    base_dir: Path,
+) -> Path:
+    """Construct the full path to a session file.
+
+    Creates a path structure like:
+    {base_dir}/projects/{canonicalized_project_path}/{session_id}.jsonl
+
+    Args:
+        session_id: Unique identifier for the session
+        project_path: Project path to canonicalize
+        base_dir: Base directory for sessions (e.g., ~/.vibecore)
+
+    Returns:
+        Full path to the session file
+
+    Example:
+        >>> get_session_file_path(
+        ...     "chat-2024-01-15",
+        ...     Path("/Users/serialx/workspace/vibecore"),
+        ...     Path.home() / ".vibecore"
+        ... )
+        PosixPath('/Users/serialx/.vibecore/projects/-Users-serialx-workspace-vibecore/chat-2024-01-15.jsonl')
+    """
+    # Validate session_id to prevent directory traversal
+    if "/" in session_id or "\\" in session_id or ".." in session_id:
+        raise ValueError(f"Invalid session_id: {session_id}")
+
+    # Canonicalize the project path
+    canonicalized_project = canonicalize_path(project_path)
+
+    # Build the full path
+    session_dir = base_dir / "projects" / canonicalized_project
+    session_file = session_dir / f"{session_id}.jsonl"
+
+    return session_file

vibecore/settings.py

@@ -0,0 +1,161 @@
+"""Settings configuration for Vibecore application."""
+
+import os
+from pathlib import Path
+from typing import Literal
+
+from agents import Model, OpenAIChatCompletionsModel
+from agents.models.multi_provider import MultiProvider
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict, YamlConfigSettingsSource
+
+from vibecore.models import AnthropicModel
+
+
+class SessionSettings(BaseModel):
+    """Configuration for session storage."""
+
+    storage_type: Literal["jsonl", "sqlite"] = Field(
+        default="jsonl",
+        description="Type of storage backend for sessions",
+    )
+    base_dir: Path = Field(
+        default=Path.home() / ".vibecore",
+        description="Base directory for session storage",
+    )
+
+
+class MCPServerConfig(BaseModel):
+    """Configuration for an MCP server."""
+
+    name: str = Field(
+        description="Unique name for this MCP server",
+    )
+    type: Literal["stdio", "sse", "http"] = Field(
+        description="Type of MCP server connection",
+    )
+
+    # For stdio servers
+    command: str | None = Field(
+        default=None,
+        description="Command to run for stdio servers (e.g., 'node /path/to/server.js')",
+    )
+    args: list[str] = Field(
+        default_factory=list,
+        description="Arguments for the stdio command",
+    )
+    env: dict[str, str] = Field(
+        default_factory=dict,
+        description="Environment variables for stdio servers",
+    )
+
+    # For SSE/HTTP servers
+    url: str | None = Field(
+        default=None,
+        description="URL for SSE or HTTP servers",
+    )
+
+    # Tool filtering
+    allowed_tools: list[str] | None = Field(
+        default=None,
+        description="List of allowed tool names (whitelist)",
+    )
+    blocked_tools: list[str] | None = Field(
+        default=None,
+        description="List of blocked tool names (blacklist)",
+    )
+
+    # Other options
+    cache_tools: bool = Field(
+        default=True,
+        description="Whether to cache the tool list",
+    )
+    timeout_seconds: float | None = Field(
+        default=30.0,
+        description="Timeout for server operations",
+    )
+
+
+class Settings(BaseSettings):
+    """Application settings with environment variable support."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        env_prefix="VIBECORE_",
+        yaml_file=["config.yaml"],
+        yaml_file_encoding="utf-8",
+        case_sensitive=False,
+    )
+
+    # Model configuration
+    default_model: str = Field(
+        # default="o3",
+        # default="gpt-4.1",
+        # default="qwen3-30b-a3b-mlx@8bit",
+        # default="mistralai/devstral-small-2507",
+        default="anthropic/claude-sonnet-4-20250514",
+        # default="anthropic/claude-3-5-haiku-20241022",
+        # default="litellm/deepseek/deepseek-chat",
+        description="Default model to use for agents (e.g., 'gpt-4.1', 'o3-mini', 'anthropic/claude-sonnet-4')",
+    )
+
+    # Agent configuration
+    max_turns: int = Field(
+        default=200,
+        description="Maximum number of turns for agent conversation",
+    )
+    reasoning_effort: Literal["minimal", "low", "medium", "high"] | None = Field(
+        default=None,
+        description="Default reasoning effort level for agents (null, 'minimal', 'low', 'medium', 'high')",
+    )
+
+    # Session configuration
+    session: SessionSettings = Field(
+        default_factory=SessionSettings,
+        description="Session storage configuration",
+    )
+
+    # MCP server configuration
+    mcp_servers: list[MCPServerConfig] = Field(
+        default_factory=list,
+        description="List of MCP servers to connect to",
+    )
+
+    @property
+    def model(self) -> str | Model:
+        """Get the configured model.
+
+        Returns an AnthropicModel instance if the model name starts with 'anthropic/',
+        returns a OpenAIChatCompletionsModel instance if there is a custom base URL set,
+        otherwise returns the model name as a plain string (for OpenAI/LiteLLM models).
+        """
+        custom_base = "OPENAI_BASE_URL" in os.environ
+        if self.default_model.startswith("anthropic/"):
+            return AnthropicModel(self.default_model)
+        elif custom_base:
+            openai_provider = MultiProvider().openai_provider
+            return OpenAIChatCompletionsModel(self.default_model, openai_provider._get_client())
+        return self.default_model
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        """Configure settings sources to include YAML support."""
+        return (
+            init_settings,
+            env_settings,
+            dotenv_settings,
+            YamlConfigSettingsSource(settings_cls),
+            file_secret_settings,
+        )
+
+
+# Create a singleton settings instance
+settings = Settings()

vibecore/tools/__init__.py

@@ -0,0 +1 @@
+"""Tools for the Vibecore agents."""

vibecore/tools/base.py

@@ -0,0 +1,27 @@
+"""Base utilities for tools."""
+
+from typing import Any, Protocol
+
+from rich.console import Console
+
+
+class ToolRenderer(Protocol):
+    """Protocol for tool-specific renderers."""
+
+    def render_call(self, tool_name: str, args: dict[str, Any]) -> None:
+        """Render a tool call."""
+        ...
+
+    def render_output(self, tool_name: str, output: Any) -> None:
+        """Render tool output."""
+        ...
+
+
+def create_console() -> Console:
+    """Create a configured console instance."""
+    return Console()
+
+
+def render_error(console: Console, error: str) -> None:
+    """Render an error message."""
+    console.print(f"[red]Error:[/red] {error}")