vibecore 0.5.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

vibecore/main.py

@@ -1,30 +1,28 @@
 import asyncio
 import traceback
 from collections import deque
-from typing import ClassVar, Literal
+from typing import TYPE_CHECKING, ClassVar, Literal
 
 from agents import (
-    Agent,
-    ModelSettings,
-    Runner,
     RunResultStreaming,
+    Session,
     StreamEvent,
-    TResponseInputItem,
 )
-from openai.types import Reasoning
 from openai.types.responses.response_output_message import Content
 from textual import log, work
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.reactive import reactive
+from textual.selection import Selection
+from textual.widget import Widget
 from textual.widgets import Header
 from textual.worker import Worker
 
-from vibecore.context import VibecoreContext
+if TYPE_CHECKING:
+    from vibecore.flow import TWorkflowReturn, VibecoreTextualRunner
+
 from vibecore.handlers import AgentStreamHandler
-from vibecore.session import JSONLSession
 from vibecore.session.loader import SessionLoader
-from vibecore.settings import settings
 from vibecore.utils.text import TextExtractor
 from vibecore.widgets.core import AppFooter, MainScroll, MyTextArea
 from vibecore.widgets.info import Welcome
@@ -37,28 +35,6 @@ class AppIsExiting(Exception):
     pass
 
 
-def detect_reasoning_effort(prompt: str) -> Literal["low", "medium", "high"] | None:
-    """Detect reasoning effort level from user prompt keywords.
-
-    Args:
-        prompt: User input text
-
-    Returns:
-        Reasoning effort level or None if no keywords detected
-    """
-    prompt_lower = prompt.lower()
-
-    # Check for highest priority keywords first
-    if "ultrathink" in prompt_lower:
-        return "high"
-    elif "think hard" in prompt_lower:
-        return "medium"
-    elif "think" in prompt_lower:
-        return "low"
-
-    return None
-
-
 class VibecoreApp(App):
     """A Textual app to manage stopwatches."""
 
@@ -83,10 +59,7 @@ class VibecoreApp(App):
 
     def __init__(
         self,
-        context: VibecoreContext,
-        agent: Agent,
-        session_id: str | None = None,
-        print_mode: bool = False,
+        runner: "VibecoreTextualRunner[TWorkflowReturn]",
         show_welcome: bool = True,
     ) -> None:
         """Initialize the Vibecore app with context and agent.
@@ -95,37 +68,35 @@ class VibecoreApp(App):
             context: The VibecoreContext instance
             agent: The Agent instance to use
             session_id: Optional session ID to load existing session
-            print_mode: Whether to run in print mode (useful for pipes)
             show_welcome: Whether to show the welcome message (default: True)
         """
-        self.context = context
-        self.context.app = self  # Set the app reference in context
-        self.agent = agent
-        self.input_items: list[TResponseInputItem] = []
+        self.runner = runner
+        if runner.context:
+            runner.context.app = self  # Set the app reference in context
         self.current_result: RunResultStreaming | None = None
         self.current_worker: Worker[None] | None = None
-        self._session_id_provided = session_id is not None  # Track if continuing session
-        self.print_mode = print_mode
         self.show_welcome = show_welcome
         self.message_queue: deque[str] = deque()  # Queue for user messages
+        self.user_input_event = asyncio.Event()  # Initialize event for user input coordination
 
-        # Initialize session based on settings
-        if settings.session.storage_type == "jsonl":
-            if session_id is None:
-                # Generate a new session ID based on current date/time
-                import datetime
+        super().__init__()
 
-                session_id = f"chat-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
+    def on_mouse_up(self) -> None:
+        if not self.screen.selections:
+            return None
 
-            self.session = JSONLSession(
-                session_id=session_id,
-                project_path=None,  # Will use current working directory
-                base_dir=settings.session.base_dir,
-            )
-        else:
-            raise NotImplementedError("SQLite session support will be added later")
+        widget_text: list[str] = []
+        for widget, selection in self.screen.selections.items():
+            assert isinstance(widget, Widget) and isinstance(selection, Selection)
+            if "copy-button" in widget.classes:  # Skip copy buttons
+                continue
+            selected_text_in_widget = widget.get_selection(selection)
+            if selected_text_in_widget is not None:
+                widget_text.extend(selected_text_in_widget)
 
-        super().__init__()
+        selected_text = "".join(widget_text)
+        self.copy_to_clipboard(selected_text)
+        self.notify("Copied to clipboard")
 
     def compose(self) -> ComposeResult:
         """Create child widgets for the app."""
@@ -135,32 +106,6 @@ class VibecoreApp(App):
             if self.show_welcome:
                 yield Welcome()
 
-    async def on_mount(self) -> None:
-        """Called when the app is mounted."""
-        # Connect to MCP servers if configured
-        if self.context.mcp_manager:
-            try:
-                await self.context.mcp_manager.connect()
-                log(f"Connected to {len(self.context.mcp_manager.servers)} MCP servers")
-            except Exception as e:
-                log(f"Failed to connect to MCP servers: {e}")
-                # Continue without MCP servers rather than crashing
-
-        # Load session history if we're continuing from a previous session
-        if self._session_id_provided:
-            await self.load_session_history()
-
-    async def on_unmount(self) -> None:
-        """Called when the app is being unmounted (shutdown)."""
-        # Cleanup MCP servers during unmount
-        if self.context.mcp_manager:
-            try:
-                log("Disconnecting from MCP servers...")
-                await self.context.mcp_manager.disconnect()
-                log("Disconnected from MCP servers")
-            except Exception as e:
-                log(f"Error disconnecting from MCP servers during unmount: {e}")
-
     def extract_text_from_content(self, content: list[Content]) -> str:
         """Extract text from various content formats."""
         return TextExtractor.extract_from_content(content)
@@ -180,11 +125,6 @@ class VibecoreApp(App):
         """Add a message widget to the main scroll area."""
         await self.add_message(message)
 
-    async def handle_agent_update(self, new_agent: Agent) -> None:
-        """Handle agent updates."""
-        log(f"Agent updated: {new_agent.name}")
-        self.agent = new_agent
-
     async def handle_agent_error(self, error: Exception) -> None:
         """Handle errors during streaming."""
         log(f"Error during agent response: {type(error).__name__}: {error!s}")
@@ -213,9 +153,9 @@ class VibecoreApp(App):
             # No messages to clean up
             pass
 
-    async def load_session_history(self) -> None:
+    async def load_session_history(self, session: Session) -> None:
         """Load and display messages from session history."""
-        loader = SessionLoader(self.session)
+        loader = SessionLoader(session)
         messages = await loader.load_history()
 
         # Remove Welcome widget if we have messages
@@ -238,10 +178,24 @@ class VibecoreApp(App):
 
     async def wait_for_user_input(self) -> str:
         """Used in flow mode. See examples/basic_agent.py"""
+        if self.message_queue:
+            user_input = self.message_queue.popleft()
+
+            user_message = UserMessage(user_input)
+            await self.add_message(user_message)
+            user_message.scroll_visible()
+
+            return user_input
+
         self.agent_status = "waiting_user_input"
-        self.user_input_event = asyncio.Event()
+        self.user_input_event.clear()  # Reset the event for next wait
         await self.user_input_event.wait()
-        user_input = self.message_queue.pop()
+        user_input = self.message_queue.popleft()
+
+        user_message = UserMessage(user_input)
+        await self.add_message(user_message)
+        user_message.scroll_visible()
+
         return user_input
 
     async def on_my_text_area_user_message(self, event: MyTextArea.UserMessage) -> None:
@@ -249,12 +203,8 @@ class VibecoreApp(App):
         if event.text:
             # Check for special commands
             text_strip = event.text.strip()
-            if text_strip == "/clear":
-                await self.handle_clear_command()
-                return
-            elif text_strip == "/help":
+            if text_strip == "/help":
                 help_text = "Available commands:\n"
-                help_text += "• /clear - Clear the current session and start a new one\n"
                 help_text += "• /help - Show this help message\n\n"
                 help_text += "Keyboard shortcuts:\n"
                 help_text += "• Esc - Cancel current agent operation\n"
@@ -263,14 +213,7 @@ class VibecoreApp(App):
                 await self.add_message(SystemMessage(help_text))
                 return
 
-            user_message = UserMessage(event.text)
-            await self.add_message(user_message)
-            user_message.scroll_visible()
-
-            if self.agent_status == "waiting_user_input":
-                self.message_queue.append(event.text)
-                self.user_input_event.set()
-            elif self.agent_status == "running":
+            if self.agent_status == "running":
                 # If agent is running, queue the message
                 self.message_queue.append(event.text)
                 log(f"Message queued: {event.text}")
@@ -281,41 +224,8 @@ class VibecoreApp(App):
                     status="Generating…", metadata=f"{queued_count} message{'s' if queued_count > 1 else ''} queued"
                 )
             else:
-                # Detect reasoning effort from prompt keywords
-                detected_effort = detect_reasoning_effort(event.text)
-                reasoning_effort = detected_effort or settings.reasoning_effort
-
-                # Create agent with appropriate reasoning effort
-                agent_to_use = self.agent
-                if reasoning_effort is not None:
-                    # Create a copy of the agent with updated model settings
-                    current_settings = self.agent.model_settings or ModelSettings()
-                    new_reasoning = Reasoning(effort=reasoning_effort, summary=settings.reasoning_summary)
-                    updated_settings = ModelSettings(
-                        include_usage=current_settings.include_usage,
-                        reasoning=new_reasoning,
-                    )
-                    agent_to_use = Agent[VibecoreContext](
-                        name=self.agent.name,
-                        handoff_description=self.agent.handoff_description,
-                        instructions=self.agent.instructions,
-                        tools=self.agent.tools,
-                        model=self.agent.model,
-                        model_settings=updated_settings,
-                        handoffs=self.agent.handoffs,
-                        mcp_servers=self.agent.mcp_servers,
-                    )
-
-                # Process the message immediately
-                result = Runner.run_streamed(
-                    agent_to_use,
-                    input=event.text,  # Pass string directly when using session
-                    context=self.context,
-                    max_turns=settings.max_turns,
-                    session=self.session,
-                )
-
-                self.current_worker = self.handle_streamed_response(result)
+                self.message_queue.append(event.text)
+                self.user_input_event.set()
 
     @work(exclusive=True)
     async def handle_streamed_response(self, result: RunResultStreaming) -> None:
@@ -325,42 +235,27 @@ class VibecoreApp(App):
         self.agent_stream_handler = AgentStreamHandler(self)
         await self.agent_stream_handler.process_stream(result)
 
-        used = result.context_wrapper.usage.total_tokens
+        # Determine usage based on the last model response rather than the aggregated usage
+        # from the entire session so that context fullness reflects the most recent request.
+        used_tokens: float = 0.0
+        if result.raw_responses:
+            last_response = result.raw_responses[-1]
+            last_usage = getattr(last_response, "usage", None)
+            if last_usage:
+                used_tokens = float(last_usage.total_tokens)
+
         max_ctx = self._get_model_context_window()
-        log(f"Context usage: {used} / {max_ctx} total tokens")
-        self.context.context_fullness = min(1.0, float(used) / float(max_ctx))
+        log(f"Context usage: {used_tokens} / {max_ctx} total tokens")
+        context_fullness = min(1.0, used_tokens / float(max_ctx))
         footer = self.query_one(AppFooter)
-        footer.set_context_progress(self.context.context_fullness)
+        footer.set_context_progress(context_fullness)
 
         self.agent_status = "idle"
         self.current_result = None
         self.current_worker = None
 
-        await self.process_message_queue()
-
-    async def process_message_queue(self) -> None:
-        """Process any messages that were queued while the agent was running."""
-        if self.message_queue:
-            # Get the next message from the queue
-            next_message = self.message_queue.popleft()
-            log(f"Processing queued message: {next_message}")
-
-            # Process the message
-            result = Runner.run_streamed(
-                self.agent,
-                input=next_message,
-                context=self.context,
-                max_turns=settings.max_turns,
-                session=self.session,
-            )
-
-            self.current_worker = self.handle_streamed_response(result)
-
     def _get_model_context_window(self) -> int:
-        from vibecore.settings import settings
-
-        model_name = settings.default_model
-        log(f"Getting context window for model: {model_name}")
+        # TODO(serialx): Implement later
         return 200000
 
     def action_toggle_dark(self) -> None:
@@ -400,7 +295,7 @@ class VibecoreApp(App):
         """Reset exit confirmation after 1 second and remove the message."""
         try:
             # Wait for 1 second
-            await asyncio.sleep(1.0)
+            await asyncio.sleep(2.0)
 
             # Reset confirmation state
             self._exit_confirmation_active = False
@@ -411,55 +306,6 @@ class VibecoreApp(App):
             # Task was cancelled (new Ctrl-D pressed)
             pass
 
-    async def run_print(self, prompt: str | None = None) -> str:
-        """Run the agent and return the raw output for printing.
-
-        Args:
-            prompt: Optional prompt text. If not provided, reads from stdin.
-
-        Returns:
-            The agent's text output as a string
-        """
-        import sys
-
-        # Use provided prompt or read from stdin
-        input_text = prompt.strip() if prompt else sys.stdin.read().strip()
-
-        if not input_text:
-            return ""
-
-        # Import needed event types
-        from agents import RawResponsesStreamEvent
-        from openai.types.responses import ResponseTextDeltaEvent
-
-        if self.context.mcp_manager:
-            await self.context.mcp_manager.connect()
-
-        # Run the agent
-        result = Runner.run_streamed(
-            self.agent,
-            input=input_text,
-            context=self.context,
-            max_turns=settings.max_turns,
-            session=self.session,
-        )
-
-        # Collect all agent text output
-        agent_output = ""
-
-        async for event in result.stream_events():
-            # Handle text output from agent
-            match event:
-                case RawResponsesStreamEvent(data=data):
-                    match data:
-                        case ResponseTextDeltaEvent(delta=delta) if delta:
-                            agent_output += delta
-
-        if self.context.mcp_manager:
-            await self.context.mcp_manager.disconnect()
-
-        return agent_output.strip()
-
     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.
 
@@ -471,56 +317,3 @@ class VibecoreApp(App):
         Note: The main app receives this event from the agent's task tool handler.
         """
         await self.agent_stream_handler.handle_task_tool_event(tool_name, tool_call_id, event)
-
-    async def handle_clear_command(self) -> None:
-        """Handle the /clear command to create a new session and clear the UI."""
-        log("Clearing session and creating new session")
-
-        # Cancel any running agent
-        if self.agent_status == "running":
-            self.action_cancel_agent()
-
-        # Clear message queue
-        self.message_queue.clear()
-
-        # Generate a new session ID
-        import datetime
-
-        new_session_id = f"chat-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
-
-        # Create new session
-        if settings.session.storage_type == "jsonl":
-            self.session = JSONLSession(
-                session_id=new_session_id,
-                project_path=None,  # Will use current working directory
-                base_dir=settings.session.base_dir,
-            )
-        else:
-            raise NotImplementedError("SQLite session support will be added later")
-
-        # Reset context state
-        self.context.reset_state()
-
-        # Clear input items
-        self.input_items.clear()
-
-        # Clear the UI - remove all messages and add welcome back
-        main_scroll = self.query_one("#messages", MainScroll)
-
-        # Remove all existing messages
-        for message in main_scroll.query("BaseMessage"):
-            message.remove()
-
-        # Remove welcome if it exists
-        for welcome in main_scroll.query("Welcome"):
-            welcome.remove()
-
-        # Add welcome widget back if show_welcome is True
-        if self.show_welcome:
-            await main_scroll.mount(Welcome())
-
-        # Show system message to confirm the clear operation
-        system_message = SystemMessage(f"✨ Session cleared! Started new session: {new_session_id}")
-        await main_scroll.mount(system_message)
-
-        log(f"New session created: {new_session_id}")

vibecore/session/loader.py

@@ -2,6 +2,7 @@
 
 from typing import Any
 
+from agents import Session
 from openai.types.responses import (
     ResponseFunctionToolCall,
     ResponseInputItemParam,
@@ -12,7 +13,6 @@ from openai.types.responses import (
 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,
@@ -28,7 +28,7 @@ from vibecore.widgets.tool_messages import BaseToolMessage
 class SessionLoader:
     """Loads and parses session history into message widgets."""
 
-    def __init__(self, session: JSONLSession):
+    def __init__(self, session: Session):
         """Initialize SessionLoader with a session.
 
         Args:

vibecore/tools/file/executor.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from agents import RunContextWrapper
 
-from vibecore.context import VibecoreContext
+from vibecore.context import PathValidatorContext
 from vibecore.settings import settings
 from vibecore.tools.file.utils import PathValidationError
 
@@ -12,7 +12,7 @@ from .utils import format_line_with_number
 
 
 async def read_file(
-    ctx: RunContextWrapper[VibecoreContext], file_path: str, offset: int | None = None, limit: int | None = None
+    ctx: RunContextWrapper[PathValidatorContext], file_path: str, offset: int | None = None, limit: int | None = None
 ) -> str:
     """Read a file and return its contents in cat -n format.
 
@@ -100,7 +100,11 @@ async def read_file(
 
 
 async def edit_file(
-    ctx: RunContextWrapper[VibecoreContext], file_path: str, old_string: str, new_string: str, replace_all: bool = False
+    ctx: RunContextWrapper[PathValidatorContext],
+    file_path: str,
+    old_string: str,
+    new_string: str,
+    replace_all: bool = False,
 ) -> str:
     """Edit a file by replacing strings.
 
@@ -182,7 +186,11 @@ async def edit_file(
         return f"Error: Unexpected error editing file: {e}"
 
 
-async def multi_edit_file(ctx: RunContextWrapper[VibecoreContext], file_path: str, edits: list[dict[str, Any]]) -> str:
+async def multi_edit_file(
+    ctx: RunContextWrapper[PathValidatorContext],
+    file_path: str,
+    edits: list[dict[str, Any]],
+) -> str:
     """Edit a file by applying multiple replacements sequentially.
 
     Args:
@@ -270,7 +278,7 @@ async def multi_edit_file(ctx: RunContextWrapper[VibecoreContext], file_path: st
         return f"Error: Unexpected error editing file: {e}"
 
 
-async def write_file(ctx: RunContextWrapper[VibecoreContext], file_path: str, content: str) -> str:
+async def write_file(ctx: RunContextWrapper[PathValidatorContext], file_path: str, content: str) -> str:
     """Write content to a file.
 
     Args:

vibecore/tools/file/tools.py

@@ -3,7 +3,7 @@
 from agents import RunContextWrapper, function_tool
 from pydantic import BaseModel
 
-from vibecore.context import VibecoreContext
+from vibecore.context import PathValidatorContext
 
 from .executor import edit_file, multi_edit_file, read_file, write_file
 
@@ -18,7 +18,7 @@ class EditOperation(BaseModel):
 
 @function_tool
 async def read(
-    ctx: RunContextWrapper[VibecoreContext],
+    ctx: RunContextWrapper[PathValidatorContext],
     file_path: str,
     offset: int | None = None,
     limit: int | None = None,
@@ -54,7 +54,7 @@ async def read(
 
 @function_tool
 async def edit(
-    ctx: RunContextWrapper[VibecoreContext],
+    ctx: RunContextWrapper[PathValidatorContext],
     file_path: str,
     old_string: str,
     new_string: str,
@@ -91,7 +91,7 @@ async def edit(
 
 @function_tool
 async def multi_edit(
-    ctx: RunContextWrapper[VibecoreContext],
+    ctx: RunContextWrapper[PathValidatorContext],
     file_path: str,
     edits: list[EditOperation],
 ) -> str:
@@ -158,7 +158,7 @@ async def multi_edit(
 
 @function_tool
 async def write(
-    ctx: RunContextWrapper[VibecoreContext],
+    ctx: RunContextWrapper[PathValidatorContext],
     file_path: str,
     content: str,
 ) -> str:

vibecore/tools/python/helpers.py

@@ -5,7 +5,7 @@ from io import BytesIO
 
 from agents import RunContextWrapper
 
-from vibecore.context import VibecoreContext
+from vibecore.context import PythonToolContext
 
 try:
     from PIL import Image  # type: ignore[import-not-found]
@@ -16,7 +16,7 @@ except ImportError:
     TERM_IMAGE_AVAILABLE = False
 
 
-async def execute_python_helper(ctx: RunContextWrapper[VibecoreContext], code: str) -> str:
+async def execute_python_helper(ctx: RunContextWrapper[PythonToolContext], code: str) -> str:
     """Helper function to execute Python code.
 
     This is the actual implementation extracted from the tool decorator.

vibecore/tools/python/tools.py

@@ -2,13 +2,13 @@
 
 from agents import RunContextWrapper, function_tool
 
-from vibecore.context import VibecoreContext
+from vibecore.context import PythonToolContext
 
 from .helpers import execute_python_helper
 
 
 @function_tool
-async def execute_python(ctx: RunContextWrapper[VibecoreContext], code: str) -> str:
+async def execute_python(ctx: RunContextWrapper[PythonToolContext], code: str) -> str:
     """Execute Python code with persistent context across the session.
 
     The execution environment maintains state between calls, allowing you to:

vibecore/tools/shell/executor.py

@@ -8,13 +8,13 @@ from pathlib import Path
 
 from agents import RunContextWrapper
 
-from vibecore.context import VibecoreContext
+from vibecore.context import PathValidatorContext
 from vibecore.settings import settings
 from vibecore.tools.file.utils import PathValidationError, validate_file_path
 
 
 async def bash_executor(
-    ctx: RunContextWrapper[VibecoreContext], command: str, timeout: int | None = None
+    ctx: RunContextWrapper[PathValidatorContext], command: str, timeout: int | None = None
 ) -> tuple[str, int]:
     """Execute a bash command asynchronously.
 
@@ -80,7 +80,7 @@ async def bash_executor(
         return f"Error executing command: {e}", 1
 
 
-async def glob_files(ctx: RunContextWrapper[VibecoreContext], pattern: str, path: str | None = None) -> list[str]:
+async def glob_files(ctx: RunContextWrapper[PathValidatorContext], pattern: str, path: str | None = None) -> list[str]:
     """Find files matching a glob pattern.
 
     Args:
@@ -142,7 +142,7 @@ async def glob_files(ctx: RunContextWrapper[VibecoreContext], pattern: str, path
 
 
 async def grep_files(
-    ctx: RunContextWrapper[VibecoreContext], pattern: str, path: str | None = None, include: str | None = None
+    ctx: RunContextWrapper[PathValidatorContext], pattern: str, path: str | None = None, include: str | None = None
 ) -> list[str]:
     """Search file contents using regular expressions.
 
@@ -226,7 +226,7 @@ async def grep_files(
 
 
 async def list_directory(
-    ctx: RunContextWrapper[VibecoreContext], path: str, ignore: list[str] | None = None
+    ctx: RunContextWrapper[PathValidatorContext], path: str, ignore: list[str] | None = None
 ) -> list[str]:
     """List files and directories in a given path.