vibecore 0.3.0__py3-none-any.whl → 0.6.2__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,34 +35,13 @@ 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."""
 
     CSS_PATH: ClassVar = [
         "widgets/core.tcss",
         "widgets/messages.tcss",
+        "widgets/feedback.tcss",
         "widgets/tool_messages.tcss",
         "widgets/expandable.tcss",
         "widgets/info.tcss",
@@ -82,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.
@@ -94,72 +68,45 @@ 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."""
         yield Header()
         yield AppFooter()
-        with MainScroll(id="messages"):
+        with MainScroll(id="messages") as main_scroll:
+            main_scroll.anchor()
             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)
@@ -179,10 +126,9 @@ 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_message_update(self, message: BaseMessage) -> None:
+        """Message in the widget's message list is updated with new delta or status"""
+        pass
 
     async def handle_agent_error(self, error: Exception) -> None:
         """Handle errors during streaming."""
@@ -207,14 +153,16 @@ class VibecoreApp(App):
         try:
             last_message = main_scroll.query_one("BaseMessage:last-child", BaseMessage)
             if last_message.status == MessageStatus.EXECUTING:
+                # XXX(serialx): Consider marking it as cancelled instead
+                # last_message.status = MessageStatus.ERROR
                 last_message.remove()
         except Exception:
             # 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
@@ -237,10 +185,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)
+            self.get_child_by_id("messages").scroll_end()
+
+            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)
+        self.get_child_by_id("messages").scroll_end()
+
         return user_input
 
     async def on_my_text_area_user_message(self, event: MyTextArea.UserMessage) -> None:
@@ -248,12 +210,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"
@@ -262,13 +220,6 @@ 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()
             if self.agent_status == "running":
                 # If agent is running, queue the message
                 self.message_queue.append(event.text)
@@ -280,41 +231,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:
@@ -324,45 +242,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 on_click(self) -> None:
-        self.query_one("#input-textarea").focus()
-
     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:
@@ -402,7 +302,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
@@ -413,55 +313,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.
 
@@ -473,56 +324,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/jsonl_session.py

@@ -5,6 +5,8 @@ import logging
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from agents import Session
+
 if TYPE_CHECKING:
     from openai.types.responses import ResponseInputItemParam as TResponseInputItem
 
@@ -14,7 +16,7 @@ from .path_utils import get_session_file_path
 logger = logging.getLogger(__name__)
 
 
-class JSONLSession:
+class JSONLSession(Session):
     """JSONL-based implementation of the agents.Session protocol.
 
     Stores conversation history in JSON Lines format, with one JSON object

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/settings.py

@@ -39,6 +39,48 @@ class SessionSettings(BaseModel):
     )
 
 
+class PathConfinementSettings(BaseModel):
+    """Configuration for path confinement."""
+
+    enabled: bool = Field(
+        default=True,
+        description="Enable path confinement for file and shell tools",
+    )
+
+    allowed_directories: list[Path] = Field(
+        default_factory=lambda: [Path.cwd()],
+        description="List of directories that tools can access",
+    )
+
+    allow_home: bool = Field(
+        default=False,
+        description="Allow access to user's home directory",
+    )
+
+    allow_temp: bool = Field(
+        default=True,
+        description="Allow access to system temp directories",
+    )
+
+    strict_mode: bool = Field(
+        default=False,
+        description="Strict mode prevents any path traversal attempts",
+    )
+
+    @field_validator("allowed_directories", mode="before")
+    @classmethod
+    def resolve_paths(cls, v: list[str | Path]) -> list[Path]:
+        """Resolve and validate directory paths."""
+        paths = []
+        for p in v:
+            path = Path(p).expanduser().resolve()
+            if not path.exists():
+                # Create directory if it doesn't exist
+                path.mkdir(parents=True, exist_ok=True)
+            paths.append(path)
+        return paths
+
+
 class MCPServerConfig(BaseModel):
     """Configuration for an MCP server."""
 
@@ -155,6 +197,12 @@ class Settings(BaseSettings):
         description="List of MCP servers to connect to",
     )
 
+    # Path confinement configuration
+    path_confinement: PathConfinementSettings = Field(
+        default_factory=PathConfinementSettings,
+        description="Path confinement configuration",
+    )
+
     rich_tool_names: list[str] = Field(
         default_factory=list,
         description="List of tools to render with RichToolMessage (temporary settings)",
@@ -207,7 +255,6 @@ class Settings(BaseSettings):
         return (
             init_settings,
             env_settings,
-            dotenv_settings,
             YamlConfigSettingsSource(settings_cls),
             file_secret_settings,
         )