vibecore 0.2.0__py3-none-any.whl

vibecore/agents/default.py

@@ -0,0 +1,79 @@
+from typing import TYPE_CHECKING
+
+from agents import Agent, ModelSettings
+from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
+from openai.types import Reasoning
+
+from vibecore.context import VibecoreContext
+from vibecore.settings import settings
+from vibecore.tools.file.tools import edit, multi_edit, read, write
+from vibecore.tools.python.tools import execute_python
+from vibecore.tools.shell.tools import bash, glob, grep, ls
+from vibecore.tools.task.tools import task
+from vibecore.tools.todo.tools import todo_read, todo_write
+
+from .prompts import COMMON_PROMPT
+
+if TYPE_CHECKING:
+    from agents.mcp import MCPServer
+
+INSTRUCTIONS = (
+    COMMON_PROMPT + "\n\n"
+    "You are a versatile AI assistant capable of helping with a wide range of tasks. "
+    "You have access to various tools including file operations, shell commands, "
+    "Python execution, and task management. "
+    "Use the appropriate tools to accomplish any task the user requests. "
+    "You can handle programming, system administration, file manipulation, "
+    "automation, and general problem-solving tasks."
+)
+
+
+def create_default_agent(mcp_servers: list["MCPServer"] | None = None) -> Agent[VibecoreContext]:
+    """Create the general-purpose agent with appropriate tools.
+
+    Args:
+        mcp_servers: Optional list of MCP servers to connect to.
+
+    Returns:
+        Configured general-purpose agent.
+    """
+    tools: list = [
+        todo_read,
+        todo_write,
+        execute_python,
+        read,
+        edit,
+        multi_edit,
+        write,
+        bash,
+        glob,
+        grep,
+        ls,
+        task,
+    ]
+    instructions = INSTRUCTIONS
+
+    instructions = prompt_with_handoff_instructions(instructions)
+
+    # Configure reasoning based on settings
+    reasoning_config = Reasoning(summary="auto")
+    if settings.reasoning_effort is not None:
+        reasoning_config = Reasoning(effort=settings.reasoning_effort, summary="auto")
+
+    return Agent[VibecoreContext](
+        name="Vibecore Agent",
+        handoff_description="A versatile general-purpose assistant",
+        instructions=instructions,
+        tools=tools,
+        model=settings.model,
+        model_settings=ModelSettings(
+            include_usage=True,  # Ensure token usage is tracked in streaming mode
+            reasoning=reasoning_config,
+        ),
+        handoffs=[],
+        mcp_servers=mcp_servers or [],
+    )
+
+
+# Create default agent without MCP servers for backward compatibility
+default_agent = create_default_agent()

vibecore/agents/prompts.py

@@ -0,0 +1,12 @@
+"""Common prompts and instructions for agents."""
+
+from pathlib import Path
+
+
+def load_common_prompt() -> str:
+    """Load the common system prompt from file."""
+    prompt_file = Path(__file__).parent.parent / "prompts" / "common_system_prompt.txt"
+    return prompt_file.read_text()
+
+
+COMMON_PROMPT = load_common_prompt()

vibecore/agents/task_agent.py

@@ -0,0 +1,66 @@
+"""Task-specific agent configuration for executing delegated tasks."""
+
+from agents import Agent, ModelSettings
+from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
+from openai.types import Reasoning
+
+from vibecore.context import VibecoreContext
+from vibecore.settings import settings
+from vibecore.tools.file.tools import edit, multi_edit, read, write
+from vibecore.tools.python.tools import execute_python
+from vibecore.tools.shell.tools import bash, glob, grep, ls
+from vibecore.tools.todo.tools import todo_read, todo_write
+
+from .prompts import COMMON_PROMPT
+
+
+def create_task_agent(prompt: str) -> Agent[VibecoreContext]:
+    """Create a task agent with all tools except the Task tool.
+
+    This agent is used by the Task tool to execute specific tasks.
+    It has access to all tools except the Task tool itself to prevent
+    infinite recursion.
+
+    Args:
+        prompt: The task-specific instructions to add to the agent
+
+    Returns:
+        Configured task agent
+    """
+    # Same tools as default agent, but excluding task tool
+    tools: list = [
+        todo_read,
+        todo_write,
+        execute_python,
+        read,
+        edit,
+        multi_edit,
+        write,
+        bash,
+        glob,
+        grep,
+        ls,
+    ]
+
+    instructions = (
+        COMMON_PROMPT + "\n\n"
+        "You are a task-specific AI agent. Your purpose is to complete the following task:\n\n"
+        f"{prompt}\n\n"
+        "Focus on completing this specific task using the tools available to you. "
+        "Provide clear results and any relevant findings."
+    )
+
+    instructions = prompt_with_handoff_instructions(instructions)
+
+    return Agent[VibecoreContext](
+        name="Task Agent",
+        handoff_description="A task-specific agent",
+        instructions=instructions,
+        tools=tools,
+        model=settings.model,
+        model_settings=ModelSettings(
+            include_usage=True,  # Ensure token usage is tracked in streaming mode
+            reasoning=Reasoning(summary="auto"),
+        ),
+        handoffs=[],
+    )

vibecore/cli.py

@@ -0,0 +1,150 @@
+"""Vibecore CLI interface using typer."""
+
+import logging
+from importlib.metadata import version
+from pathlib import Path
+
+import typer
+from textual.logging import TextualHandler
+
+from vibecore.agents.default import create_default_agent
+from vibecore.context import VibecoreContext
+from vibecore.main import VibecoreApp
+from vibecore.mcp import MCPManager
+from vibecore.settings import settings
+
+app = typer.Typer()
+
+
+def version_callback(value: bool):
+    """Handle --version flag."""
+    if value:
+        try:
+            pkg_version = version("vibecore")
+        except Exception:
+            pkg_version = "unknown"
+        typer.echo(f"vibecore {pkg_version}")
+        raise typer.Exit()
+
+
+def find_latest_session(project_path: Path | None = None, base_dir: Path | None = None) -> str | None:
+    """Find the most recent session file for the current project."""
+    from vibecore.session.path_utils import canonicalize_path
+    from vibecore.settings import settings
+
+    # Use provided paths or defaults
+    if project_path is None:
+        project_path = Path.cwd()
+    if base_dir is None:
+        base_dir = settings.session.base_dir
+
+    # Get the session directory for this project
+    canonical_project = canonicalize_path(project_path)
+    session_dir = base_dir / "projects" / canonical_project
+
+    if not session_dir.exists():
+        return None
+
+    # Find all session files
+    session_files = list(session_dir.glob("chat-*.jsonl"))
+    if not session_files:
+        return None
+
+    # Sort by modification time (most recent first)
+    session_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+
+    # Return the session ID (filename without extension)
+    return session_files[0].stem
+
+
+@app.command()
+def run(
+    prompt: str | None = typer.Argument(None, help="Prompt text (requires -p flag)"),
+    continue_session: bool = typer.Option(
+        False,
+        "--continue",
+        "-c",
+        help="Continue the most recent session for this project",
+    ),
+    session_id: str | None = typer.Option(
+        None,
+        "--session",
+        "-s",
+        help="Continue a specific session by ID",
+    ),
+    print_mode: bool = typer.Option(
+        False,
+        "--print",
+        "-p",
+        help="Print response and exit (useful for pipes)",
+    ),
+    version: bool | None = typer.Option(
+        None,
+        "--version",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit",
+    ),
+):
+    """Run the Vibecore TUI application."""
+    # Set up logging
+    logging.basicConfig(
+        level="WARNING",
+        handlers=[TextualHandler()],
+    )
+
+    logger = logging.getLogger("openai.agents")
+    logger.addHandler(TextualHandler())
+
+    # Create context
+    ctx = VibecoreContext()
+
+    # Initialize MCP manager if configured
+    mcp_servers = []
+    if settings.mcp_servers:
+        # Create MCP manager
+        mcp_manager = MCPManager(settings.mcp_servers)
+        ctx.mcp_manager = mcp_manager
+
+        # Get the MCP servers from the manager
+        mcp_servers = mcp_manager.servers
+
+    # Create agent with MCP servers
+    agent = create_default_agent(mcp_servers=mcp_servers)
+
+    # Determine session to use
+    session_to_load = None
+    if continue_session:
+        session_to_load = find_latest_session()
+        if not session_to_load:
+            typer.echo("No existing sessions found for this project.")
+            raise typer.Exit(1)
+        typer.echo(f"Continuing session: {session_to_load}")
+    elif session_id:
+        session_to_load = session_id
+        typer.echo(f"Loading session: {session_to_load}")
+
+    # Create app
+    app_instance = VibecoreApp(ctx, agent, session_id=session_to_load, print_mode=print_mode)
+
+    if print_mode:
+        # Run in print mode
+        import asyncio
+
+        # Use provided prompt or None to read from stdin
+        result = asyncio.run(app_instance.run_print(prompt))
+        # Print raw output to stdout
+        if result:
+            print(result)
+    else:
+        # Run normal TUI mode
+        app_instance.run()
+
+
+def main():
+    """Entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

vibecore/context.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Optional
+
+from vibecore.tools.python.manager import PythonExecutionManager
+from vibecore.tools.todo.manager import TodoManager
+
+if TYPE_CHECKING:
+    from vibecore.main import VibecoreApp
+    from vibecore.mcp import MCPManager
+
+
+@dataclass
+class VibecoreContext:
+    todo_manager: TodoManager = field(default_factory=TodoManager)
+    python_manager: PythonExecutionManager = field(default_factory=PythonExecutionManager)
+    app: Optional["VibecoreApp"] = None
+    context_fullness: float = 0.0
+    mcp_manager: Optional["MCPManager"] = None
+
+    def reset_state(self) -> None:
+        """Reset all context state for a new session."""
+        self.todo_manager = TodoManager()
+        self.python_manager = PythonExecutionManager()
+        self.context_fullness = 0.0

vibecore/handlers/__init__.py

@@ -0,0 +1,5 @@
+"""Handlers for various application concerns."""
+
+from vibecore.handlers.stream_handler import AgentStreamHandler
+
+__all__ = ["AgentStreamHandler"]

vibecore/handlers/stream_handler.py

@@ -0,0 +1,231 @@
+"""Stream handler for processing agent streaming responses."""
+
+import json
+from typing import Protocol
+
+from agents import (
+    Agent,
+    AgentUpdatedStreamEvent,
+    MessageOutputItem,
+    RawResponsesStreamEvent,
+    RunItemStreamEvent,
+    RunResultStreaming,
+    StreamEvent,
+    ToolCallItem,
+    ToolCallOutputItem,
+)
+from openai.types.responses import (
+    ResponseFunctionToolCall,
+    ResponseOutputItemAddedEvent,
+    ResponseOutputItemDoneEvent,
+    ResponseReasoningItem,
+    ResponseReasoningSummaryPartAddedEvent,
+    ResponseReasoningSummaryTextDeltaEvent,
+    ResponseReasoningSummaryTextDoneEvent,
+    ResponseTextDeltaEvent,
+)
+
+from vibecore.widgets.messages import (
+    AgentMessage,
+    BaseMessage,
+    MessageStatus,
+    ReasoningMessage,
+)
+from vibecore.widgets.tool_message_factory import create_tool_message
+from vibecore.widgets.tool_messages import BaseToolMessage, TaskToolMessage
+
+
+class MessageHandler(Protocol):
+    """Protocol defining the interface for message handling."""
+
+    async def handle_agent_message(self, message: BaseMessage) -> None:
+        """Add a message to the widget's message list."""
+        ...
+
+    async def handle_agent_update(self, new_agent: Agent) -> None:
+        """Handle agent updates."""
+        ...
+
+    async def handle_agent_error(self, error: Exception) -> None:
+        """Handle errors during streaming."""
+        ...
+
+    async def handle_agent_finished(self) -> None:
+        """Handle when the agent has finished processing."""
+        ...
+
+
+class AgentStreamHandler:
+    """Handles streaming responses from agents."""
+
+    def __init__(self, message_handler: MessageHandler) -> None:
+        """Initialize the stream handler.
+
+        Args:
+            message_handler: The MessageHandler protocol instance
+        """
+        self.message_handler = message_handler
+        self.message_content = ""
+        self.agent_message: AgentMessage | None = None
+        self.tool_messages: dict[str, BaseToolMessage] = {}
+        self.reasoning_messages: dict[str, ReasoningMessage] = {}
+
+    async def handle_text_delta(self, delta: str) -> None:
+        """Handle incremental text updates from the agent.
+
+        Args:
+            delta: The text delta to append
+        """
+        self.message_content += delta
+        if not self.agent_message:
+            self.agent_message = AgentMessage(self.message_content, status=MessageStatus.EXECUTING)
+            await self.message_handler.handle_agent_message(self.agent_message)
+        else:
+            self.agent_message.update(self.message_content)
+
+    async def handle_tool_call(self, tool_name: str, arguments: str, call_id: str) -> None:
+        """Create and display tool message when tool is invoked.
+
+        Args:
+            tool_name: Name of the tool being called
+            arguments: JSON string of tool arguments
+            call_id: Unique identifier for this tool call
+        """
+        # Use factory to create the appropriate tool message
+        tool_message = create_tool_message(tool_name, arguments)
+
+        self.tool_messages[call_id] = tool_message
+        await self.message_handler.handle_agent_message(tool_message)
+
+    async def handle_tool_output(self, output: str, call_id: str) -> None:
+        """Update tool message with execution results.
+
+        Args:
+            output: The tool execution output
+            call_id: The tool call identifier to match with pending calls
+        """
+        if call_id in self.tool_messages:
+            tool_message = self.tool_messages[call_id]
+            tool_message.update(MessageStatus.SUCCESS, str(output))
+
+    async def handle_message_complete(self) -> None:
+        """Finalize agent message when complete."""
+        if self.agent_message:
+            self.agent_message.update(self.message_content, status=MessageStatus.IDLE)
+            self.agent_message = None
+            self.message_content = ""
+
+    async def handle_event(self, event: StreamEvent) -> None:
+        """Handle a single streaming event.
+
+        Args:
+            event: The streaming event to process
+        """
+        match event:
+            case RawResponsesStreamEvent(data=data):
+                match data:
+                    case ResponseOutputItemAddedEvent(item=ResponseReasoningItem() as item):
+                        reasoning_id = item.id
+                        reasoning_message = ReasoningMessage("Thinking...", status=MessageStatus.EXECUTING)
+                        self.reasoning_messages[reasoning_id] = reasoning_message
+                        await self.message_handler.handle_agent_message(reasoning_message)
+
+                    case ResponseReasoningSummaryPartAddedEvent() as e:
+                        reasoning_id = e.item_id
+                        reasoning_message = self.reasoning_messages[reasoning_id]
+                        assert reasoning_message, f"Reasoning message with ID {reasoning_id} not found"
+                        updated = reasoning_message.text + "\n\n" if reasoning_message.text != "Thinking..." else ""
+                        reasoning_message.update(updated, status=MessageStatus.EXECUTING)
+
+                    case ResponseReasoningSummaryTextDeltaEvent(item_id=reasoning_id, delta=delta):
+                        reasoning_message = self.reasoning_messages[reasoning_id]
+                        assert reasoning_message, f"Reasoning message with ID {reasoning_id} not found"
+                        updated = reasoning_message.text + delta
+                        reasoning_message.update(updated, status=MessageStatus.EXECUTING)
+
+                    case ResponseReasoningSummaryTextDoneEvent(item_id=reasoning_id) as e:
+                        pass
+
+                    case ResponseOutputItemDoneEvent(item=ResponseReasoningItem() as item):
+                        reasoning_id = item.id
+                        reasoning_message = self.reasoning_messages[reasoning_id]
+                        assert reasoning_message, f"Reasoning message with ID {reasoning_id} not found"
+                        reasoning_message.update(reasoning_message.text, status=MessageStatus.IDLE)
+
+                    case ResponseOutputItemAddedEvent(item=ResponseFunctionToolCall(name=tool_name, call_id=call_id)):
+                        # TODO(serialx): We should move all tool call lifecycle start to here
+                        #                ResponseOutputItemDoneEvent can have race conditions in case of task tool calls
+                        #                Because we stream sub-agent events to our method: handle_task_tool_event()
+                        # XXX(serialx): Just handle task tool call lifecycle here for now
+                        #               I'm deferring this because `arguments` is not available here... need to refactor
+                        if tool_name == "task":
+                            await self.handle_tool_call(tool_name, "{}", call_id)
+
+                    case ResponseTextDeltaEvent(delta=delta) if delta:
+                        await self.handle_text_delta(delta)
+
+                    case ResponseOutputItemDoneEvent(
+                        item=ResponseFunctionToolCall(name=tool_name, arguments=arguments, call_id=call_id)
+                    ):
+                        # XXX(serialx): See above comments
+                        if tool_name == "task":
+                            assert call_id in self.tool_messages, f"Tool call ID {call_id} not found in tool messages"
+                            task_tool_message = self.tool_messages[call_id]
+                            assert isinstance(task_tool_message, TaskToolMessage), (
+                                "Tool message must be a TaskToolMessage instance"
+                            )
+                            args = json.loads(arguments)
+                            task_tool_message.description = args.get("description", "")
+                            task_tool_message.prompt = args.get("prompt", "")
+                        else:
+                            await self.handle_tool_call(tool_name, arguments, call_id)
+
+            case RunItemStreamEvent(item=item):
+                match item:
+                    case ToolCallItem():
+                        pass
+                    case ToolCallOutputItem(output=output, raw_item=raw_item):
+                        # Find the corresponding tool message by call_id
+                        if (
+                            isinstance(raw_item, dict)
+                            and "call_id" in raw_item
+                            and raw_item["call_id"] in self.tool_messages
+                        ):
+                            await self.handle_tool_output(output, raw_item["call_id"])
+                    case MessageOutputItem():
+                        await self.handle_message_complete()
+
+            case AgentUpdatedStreamEvent(new_agent=new_agent):
+                await self.message_handler.handle_agent_update(new_agent)
+
+    async def handle_task_tool_event(self, tool_name: str, tool_call_id: str, event: StreamEvent) -> None:
+        """Handle streaming events from task tool sub-agents.
+
+        Args:
+            tool_name: Name of the tool (e.g., "task")
+            tool_call_id: Unique identifier for this tool call
+            event: The streaming event from the sub-agent
+
+        Note: This is called by the main app to handle task tool events.
+        The main app receives this event from the agent's task tool handler.
+        """
+
+        assert tool_call_id in self.tool_messages, f"Tool call ID {tool_call_id} not found in tool messages"
+        tool_message = self.tool_messages[tool_call_id]
+        assert isinstance(tool_message, TaskToolMessage), "Tool message must be a TaskToolMessage instance"
+        await tool_message.handle_task_tool_event(event)
+
+    async def process_stream(self, result: RunResultStreaming) -> None:
+        """Process all streaming events from the agent.
+
+        Args:
+            result: The streaming result to process
+        """
+        try:
+            async for event in result.stream_events():
+                await self.handle_event(event)
+        except Exception as e:
+            await self.message_handler.handle_agent_error(e)
+        finally:
+            await self.message_handler.handle_agent_finished()
+            # await self._cleanup()