vibecore 0.4.1__tar.gz → 0.5.0__tar.gz

{vibecore-0.4.1 → vibecore-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibecore
-Version: 0.4.1
+Version: 0.5.0
 Summary: Build your own AI-powered automation tools in the terminal with this extensible agent framework
 Project-URL: Homepage, https://github.com/serialx/vibecore
 Project-URL: Repository, https://github.com/serialx/vibecore

{vibecore-0.4.1 → vibecore-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vibecore"
-version = "0.4.1"
+version = "0.5.0"
 description = "Build your own AI-powered automation tools in the terminal with this extensible agent framework"
 readme = "README.md"
 authors = [

vibecore-0.5.0/src/vibecore/flow.py

@@ -0,0 +1,345 @@
+import asyncio
+import contextlib
+import datetime
+import sys
+import threading
+from collections.abc import Callable, Coroutine
+from typing import Any, Generic, Protocol, TypeAlias, overload
+
+from agents import (
+    Agent,
+    RunConfig,
+    RunHooks,
+    Runner,
+    Session,
+    TContext,
+    TResponseInputItem,
+)
+from agents.result import RunResultBase
+from agents.run import DEFAULT_MAX_TURNS
+from textual.pilot import Pilot
+from typing_extensions import TypeVar
+
+from vibecore.context import VibecoreContext
+from vibecore.main import AppIsExiting, VibecoreApp
+from vibecore.session import JSONLSession
+from vibecore.settings import settings
+from vibecore.widgets.core import MyTextArea
+from vibecore.widgets.messages import SystemMessage
+
+
+class UserInputFunc(Protocol):
+    """Protocol for user input function with optional prompt parameter."""
+
+    async def __call__(self, prompt: str = "") -> str:
+        """Get user input with optional prompt message.
+
+        Args:
+            prompt: Optional prompt to display before getting input.
+
+        Returns:
+            The user's input string.
+        """
+        ...
+
+
+TWorkflowReturn = TypeVar("TWorkflowReturn", default=RunResultBase)
+DecoratedCallable: TypeAlias = Callable[..., Coroutine[Any, Any, TWorkflowReturn]]
+
+
+class VibecoreRunnerBase(Generic[TWorkflowReturn]):
+    def __init__(self, vibecore: "Vibecore[TWorkflowReturn]") -> None:
+        self.vibecore = vibecore
+
+    @property
+    def session(self) -> Session:
+        raise NotImplementedError("session property implemented.")
+
+    async def user_input(self, prompt: str = "") -> str:
+        raise NotImplementedError("user_input method not implemented.")
+
+    async def print(self, message: str) -> None:
+        print(message, file=sys.stderr)
+
+    async def run_agent(
+        self,
+        starting_agent: Agent[TContext],
+        input: str | list[TResponseInputItem],
+        *,
+        context: TContext | None = None,
+        max_turns: int = DEFAULT_MAX_TURNS,
+        hooks: RunHooks[TContext] | None = None,
+        run_config: RunConfig | None = None,
+        previous_response_id: str | None = None,
+        session: Session | None = None,
+    ) -> RunResultBase:
+        result = await Runner.run(
+            starting_agent=starting_agent,
+            input=input,  # Pass string directly when using session
+            context=context,
+            max_turns=max_turns,
+            hooks=hooks,
+            run_config=run_config,
+            previous_response_id=previous_response_id,
+            session=session,
+        )
+        return result
+
+
+class VibecoreSimpleRunner(VibecoreRunnerBase[TWorkflowReturn]):
+    def __init__(self, vibecore: "Vibecore[TWorkflowReturn]") -> None:
+        super().__init__(vibecore)
+
+        session_id = f"chat-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
+        self._session = JSONLSession(
+            session_id=session_id,
+            project_path=None,  # Will use current working directory
+            base_dir=settings.session.base_dir,
+        )
+
+    @property
+    def session(self) -> Session:
+        return self._session
+
+
+class VibecoreCliRunner(VibecoreSimpleRunner[TWorkflowReturn]):
+    def __init__(self, vibecore: "Vibecore[TWorkflowReturn]") -> None:
+        super().__init__(vibecore)
+
+    async def user_input(self, prompt: str = "") -> str:
+        return input(prompt)
+
+    async def run(self) -> TWorkflowReturn:
+        assert self.vibecore.workflow_logic is not None, (
+            "Workflow logic not defined. Please use the @vibecore.workflow() decorator."
+        )
+        return await self.vibecore.workflow_logic()
+
+
+class VibecoreStaticRunner(VibecoreSimpleRunner[TWorkflowReturn]):
+    def __init__(self, vibecore: "Vibecore[TWorkflowReturn]") -> None:
+        super().__init__(vibecore)
+        self.inputs: list[str] = []
+        self.prints: list[str] = []
+
+    async def user_input(self, prompt: str = "") -> str:
+        assert self.inputs, "No more user inputs available."
+        return self.inputs.pop()
+
+    async def print(self, message: str) -> None:
+        # Capture printed messages instead of displaying them
+        self.prints.append(message)
+
+    async def run(self, inputs: list[str] | None = None) -> TWorkflowReturn:
+        if inputs is None:
+            inputs = []
+        assert self.vibecore.workflow_logic is not None, (
+            "Workflow logic not defined. Please use the @vibecore.workflow() decorator."
+        )
+        self.inputs.extend(inputs)
+        return await self.vibecore.workflow_logic()
+
+
+class VibecoreTextualRunner(VibecoreRunnerBase[TWorkflowReturn]):
+    def __init__(self, vibecore: "Vibecore[TWorkflowReturn]") -> None:
+        super().__init__(vibecore)
+        self.app = VibecoreApp(self.vibecore.context, self.vibecore.starting_agent, show_welcome=False)
+        self.app_ready_event = asyncio.Event()
+
+    @property
+    def session(self) -> Session:
+        return self.app.session
+
+    async def user_input(self, prompt: str = "") -> str:
+        if prompt:
+            await self.print(prompt)
+        self.app.query_one(MyTextArea).disabled = False
+        self.app.query_one(MyTextArea).focus()
+        user_input = await self.app.wait_for_user_input()
+        if self.vibecore.disable_user_input:
+            self.app.query_one(MyTextArea).disabled = True
+        return user_input
+
+    async def print(self, message: str) -> None:
+        await self.app.add_message(SystemMessage(message))
+
+    async def run_agent(
+        self,
+        starting_agent: Agent[TContext],
+        input: str | list[TResponseInputItem],
+        *,
+        context: TContext | None = None,
+        max_turns: int = DEFAULT_MAX_TURNS,
+        hooks: RunHooks[TContext] | None = None,
+        run_config: RunConfig | None = None,
+        previous_response_id: str | None = None,
+        session: Session | None = None,
+    ) -> RunResultBase:
+        result = Runner.run_streamed(
+            starting_agent=starting_agent,
+            input=input,  # Pass string directly when using session
+            context=context,
+            max_turns=max_turns,
+            hooks=hooks,
+            run_config=run_config,
+            previous_response_id=previous_response_id,
+            session=session,
+        )
+
+        self.app.current_worker = self.app.handle_streamed_response(result)
+        await self.app.current_worker.wait()
+        return result
+
+    def on_app_ready(self) -> None:
+        """Called when app is ready to process events."""
+        self.app_ready_event.set()
+
+    async def _run_app(self) -> None:
+        """Run the apps message loop.
+
+        Args:
+            app: App to run.
+        """
+
+        with self.app._context():
+            try:
+                self.app._loop = asyncio.get_running_loop()
+                self.app._thread_id = threading.get_ident()
+                await self.app._process_messages(
+                    ready_callback=self.on_app_ready,
+                    headless=False,
+                )
+            finally:
+                self.app_ready_event.set()
+
+    async def _run_logic(self) -> TWorkflowReturn:
+        assert self.vibecore.workflow_logic is not None, (
+            "Workflow logic not defined. Please use the @vibecore.workflow() decorator."
+        )
+        try:
+            return await self.vibecore.workflow_logic()
+        except AppIsExiting:
+            raise
+
+    async def run(self, shutdown: bool = False) -> TWorkflowReturn:
+        self.app = VibecoreApp(self.vibecore.context, self.vibecore.starting_agent, show_welcome=False)
+        app_task = asyncio.create_task(self._run_app(), name=f"run_app({self.app})")
+        await self.app_ready_event.wait()
+        pilot = Pilot(self.app)
+        logic_task: asyncio.Task[TWorkflowReturn] | None = None
+
+        await pilot._wait_for_screen()
+        if self.vibecore.disable_user_input:
+            self.app.query_one(MyTextArea).disabled = True
+        logic_task = asyncio.create_task(self._run_logic(), name="logic_task")
+        done, pending = await asyncio.wait([logic_task, app_task], return_when=asyncio.FIRST_COMPLETED)
+
+        # If app has exited and logic is still running, cancel logic
+        if app_task in done and logic_task in pending:
+            logic_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await logic_task
+            raise AppIsExiting()
+        # If logic is finished and app is still running
+        elif logic_task in done and app_task in pending:
+            result = logic_task.result()
+            if shutdown:
+                await pilot._wait_for_screen()
+                await asyncio.sleep(1.0)
+                self.app.exit()
+                await app_task
+            else:
+                # Enable text input so users can interact freely
+                self.app.query_one(MyTextArea).disabled = False
+                # Wait until app is exited
+                await app_task
+            return result
+
+        raise RuntimeError("Unexpected state: both tasks completed")
+
+
+class Vibecore(Generic[TWorkflowReturn]):
+    def __init__(self, starting_agent: Agent[TContext], disable_user_input: bool = True) -> None:
+        self.context = VibecoreContext()
+        self.workflow_logic: Callable[..., Coroutine[Any, Any, TWorkflowReturn]] | None = None
+        self.starting_agent = starting_agent
+        self.disable_user_input = disable_user_input
+        self.runner: VibecoreRunnerBase[TWorkflowReturn] = VibecoreRunnerBase(self)
+
+    @property
+    def session(self) -> Session:
+        return self.runner.session
+
+    async def user_input(self, prompt: str = "") -> str:
+        return await self.runner.user_input(prompt)
+
+    async def print(self, message: str) -> None:
+        return await self.runner.print(message)
+
+    def workflow(self) -> Callable[[DecoratedCallable[TWorkflowReturn]], DecoratedCallable[TWorkflowReturn]]:
+        """Decorator to define the workflow logic for the app.
+
+        Returns:
+            A decorator that wraps the workflow logic function.
+        """
+
+        def decorator(
+            func: DecoratedCallable[TWorkflowReturn],
+        ) -> DecoratedCallable[TWorkflowReturn]:
+            self.workflow_logic = func
+            return func
+
+        return decorator
+
+    async def run_agent(
+        self,
+        starting_agent: Agent[TContext],
+        input: str | list[TResponseInputItem],
+        *,
+        context: TContext | None = None,
+        max_turns: int = DEFAULT_MAX_TURNS,
+        hooks: RunHooks[TContext] | None = None,
+        run_config: RunConfig | None = None,
+        previous_response_id: str | None = None,
+        session: Session | None = None,
+    ) -> RunResultBase:
+        return await self.runner.run_agent(
+            starting_agent=starting_agent,
+            input=input,
+            context=context,
+            max_turns=max_turns,
+            hooks=hooks,
+            run_config=run_config,
+            previous_response_id=previous_response_id,
+            session=session,
+        )
+
+    async def run_textual(self, shutdown: bool = False) -> TWorkflowReturn:
+        if self.workflow_logic is None:
+            raise ValueError("Workflow logic not defined. Please use the @vibecore.workflow() decorator.")
+
+        self.runner = VibecoreTextualRunner(self)
+        return await self.runner.run(shutdown=shutdown)
+
+    async def run_cli(self) -> TWorkflowReturn:
+        if self.workflow_logic is None:
+            raise ValueError("Workflow logic not defined. Please use the @vibecore.workflow() decorator.")
+
+        self.runner = VibecoreCliRunner(self)
+        return await self.runner.run()
+
+    @overload
+    async def run(self, inputs: str) -> TWorkflowReturn: ...
+
+    @overload
+    async def run(self, inputs: list[str]) -> TWorkflowReturn: ...
+
+    async def run(self, inputs: str | list[str]) -> TWorkflowReturn:
+        if isinstance(inputs, str):
+            inputs = [inputs]
+
+        if self.workflow_logic is None:
+            raise ValueError("Workflow logic not defined. Please use the @vibecore.workflow() decorator.")
+
+        self.runner = VibecoreStaticRunner(self)
+        return await self.runner.run(inputs=inputs)

{vibecore-0.4.1 → vibecore-0.5.0}/src/vibecore/main.py

@@ -65,6 +65,7 @@ class VibecoreApp(App):
     CSS_PATH: ClassVar = [
         "widgets/core.tcss",
         "widgets/messages.tcss",
+        "widgets/feedback.tcss",
         "widgets/tool_messages.tcss",
         "widgets/expandable.tcss",
         "widgets/info.tcss",
@@ -355,9 +356,6 @@ class VibecoreApp(App):
 
             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
 

{vibecore-0.4.1 → vibecore-0.5.0}/src/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-0.4.1 → vibecore-0.5.0}/src/vibecore/tools/todo/manager.py

@@ -2,7 +2,7 @@
 
 from typing import Any
 
-from .models import TodoItem, TodoPriority, TodoStatus
+from .models import TodoItem
 
 
 class TodoManager:
@@ -20,12 +20,4 @@ class TodoManager:
 
     def write(self, todos: list[dict[str, Any]]) -> None:
         """Replace the entire todo list."""
-        self.todos = [
-            TodoItem(
-                id=todo["id"],
-                content=todo["content"],
-                status=TodoStatus(todo["status"]),
-                priority=TodoPriority(todo["priority"]),
-            )
-            for todo in todos
-        ]
+        self.todos = [TodoItem(**todo) for todo in todos]

{vibecore-0.4.1 → vibecore-0.5.0}/src/vibecore/tools/todo/models.py

@@ -1,10 +1,9 @@
 """Todo data models."""
 
 import uuid
-from dataclasses import dataclass, field
 from enum import Enum
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class TodoStatus(str, Enum):
@@ -19,18 +18,10 @@ class TodoPriority(str, Enum):
     LOW = "low"
 
 
-@dataclass
-class TodoItem:
-    content: str
-    status: TodoStatus
-    priority: TodoPriority
-    id: str = field(default_factory=lambda: str(uuid.uuid4()))
-
-
-class TodoItemModel(BaseModel):
+class TodoItem(BaseModel):
     """Pydantic model for todo items."""
 
-    id: str
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
     content: str
-    status: str
-    priority: str
+    status: TodoStatus
+    priority: TodoPriority

{vibecore-0.4.1 → vibecore-0.5.0}/src/vibecore/tools/todo/tools.py

@@ -6,7 +6,7 @@ from agents import RunContextWrapper, function_tool
 
 from vibecore.context import VibecoreContext
 
-from .models import TodoItemModel
+from .models import TodoItem
 
 
 @function_tool
@@ -38,7 +38,7 @@ async def todo_read(ctx: RunContextWrapper[VibecoreContext]) -> list[dict[str, A
 
 
 @function_tool
-async def todo_write(ctx: RunContextWrapper[VibecoreContext], todos: list[TodoItemModel]) -> str:
+async def todo_write(ctx: RunContextWrapper[VibecoreContext], todos: list[TodoItem]) -> str:
     """Use this tool to create and manage a structured task list for your current coding session. This helps you
     track progress, organize complex tasks, and demonstrate thoroughness to the user. It also helps the user
     understand the progress of the task and overall progress of their requests.
@@ -106,6 +106,6 @@ async def todo_write(ctx: RunContextWrapper[VibecoreContext], todos: list[TodoIt
             Success message.
     """
     # Convert Pydantic models to dicts for the implementation
-    todos_dict = [todo.model_dump() for todo in todos]
+    todos_dict = [todo.model_dump() if isinstance(todo, TodoItem) else TodoItem(**todo).model_dump() for todo in todos]
     ctx.context.todo_manager.write(todos_dict)
     return "Todo list updated successfully."

vibecore-0.5.0/src/vibecore/widgets/feedback.py

@@ -0,0 +1,164 @@
+"""Feedback widget for collecting user feedback."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.content import Content
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widgets import Button, Checkbox, Static, TextArea
+
+from vibecore.widgets.messages import BaseMessage, MessageHeader, MessageStatus
+
+
+class FeedbackWidget(BaseMessage):
+    """A widget to collect user feedback with Good/Bad rating and optional text comment."""
+
+    class FeedbackSubmitted(Message):
+        """Event emitted when feedback is submitted."""
+
+        def __init__(self, rating: str, comment: str, criteria: dict[str, bool]) -> None:
+            """
+            Construct a FeedbackSubmitted message.
+
+            Args:
+                rating: The rating ("good" or "bad").
+                comment: Optional text comment from the user.
+                criteria: Dict of criterion name to boolean value.
+            """
+            super().__init__()
+            self.rating = rating
+            self.comment = comment
+            self.criteria = criteria
+
+    rating: reactive[str | None] = reactive(None)
+    comment: reactive[str] = reactive("")
+    submitted: reactive[bool] = reactive(False)
+    show_comment_input: reactive[bool] = reactive(False)
+    show_criteria: reactive[bool] = reactive(False)
+
+    def __init__(self, prompt: str = "How was this response?", **kwargs) -> None:
+        """
+        Construct a FeedbackWidget.
+
+        Args:
+            prompt: The prompt text to display.
+            **kwargs: Additional keyword arguments for Widget.
+        """
+        super().__init__(status=MessageStatus.IDLE, **kwargs)
+        self.prompt = prompt
+        self.add_class("feedback-widget")
+
+    def get_header_params(self) -> tuple[str, str, bool]:
+        """Get parameters for MessageHeader."""
+        return ("⏺", self.prompt, False)
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets for the feedback widget."""
+        yield MessageHeader("⏺", self.prompt, status=self.status)
+
+        with Horizontal(classes="feedback-controls"):
+            yield Button("👍 Good", id="feedback-good", classes="feedback-button good-button", variant="success")
+            yield Button("👎 Bad", id="feedback-bad", classes="feedback-button bad-button", variant="error")
+
+        # Feedback form containing criteria, comment area, and submit button (shown after rating selection)
+        with Vertical(id="feedback-form", classes="feedback-form"):
+            # Structured feedback criteria checkboxes
+            with Vertical(classes="feedback-criteria"):
+                yield Static("Please check any criteria that apply:", classes="criteria-label")
+                yield Checkbox("Factual accuracy - Was the information correct?", id="criteria-accuracy")
+                yield Checkbox("Task completion - Did it fully address the request?", id="criteria-completion")
+                yield Checkbox(
+                    "Instruction following - Did it follow specific constraints or requirements?",
+                    id="criteria-instructions",
+                )
+                yield Checkbox(
+                    "Good format/structure - Are the format and structure appropriate?", id="criteria-format"
+                )
+
+            # Comment text area
+            with Vertical(classes="feedback-comment-area"):
+                yield Static("Optional comment:", classes="comment-label")
+                yield TextArea(id="feedback-textarea", classes="feedback-textarea", show_line_numbers=False)
+
+            # Submit button
+            yield Button("Submit", id="feedback-submit", classes="feedback-submit-button", variant="primary")
+
+        with Vertical(id="feedback-result", classes="feedback-result"):
+            yield Static("", id="feedback-result-text")
+
+    def on_mount(self) -> None:
+        """Initialize widget state on mount."""
+        # Hide feedback form and result initially
+        self.query_one("#feedback-form").display = False
+        self.query_one("#feedback-result").display = False
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button press events."""
+        button_id = event.button.id
+
+        if self.submitted:
+            return  # Ignore clicks after submission
+
+        if button_id == "feedback-good":
+            self.rating = "good"
+            self._show_feedback_form()
+            event.button.add_class("selected")
+            self.query_one("#feedback-bad").remove_class("selected")
+
+        elif button_id == "feedback-bad":
+            self.rating = "bad"
+            self._show_feedback_form()
+            event.button.add_class("selected")
+            self.query_one("#feedback-good").remove_class("selected")
+
+        elif button_id == "feedback-submit":
+            self._submit_feedback()
+
+    def _show_feedback_form(self) -> None:
+        """Show the feedback form (criteria, comment area, and submit button)."""
+        self.show_criteria = True
+        self.show_comment_input = True
+        feedback_form = self.query_one("#feedback-form")
+        feedback_form.display = True
+        feedback_form.refresh()
+
+    def _get_criteria_values(self) -> dict[str, bool]:
+        """Get the current state of all criteria checkboxes."""
+        return {
+            "accuracy": self.query_one("#criteria-accuracy", Checkbox).value,
+            "completion": self.query_one("#criteria-completion", Checkbox).value,
+            "instructions": self.query_one("#criteria-instructions", Checkbox).value,
+            "format": self.query_one("#criteria-format", Checkbox).value,
+        }
+
+    def _submit_feedback(self) -> None:
+        """Submit the feedback."""
+        if not self.rating:
+            # Require a rating before submission
+            return
+
+        self.submitted = True
+        self.comment = self.query_one("#feedback-textarea", TextArea).text
+        criteria = self._get_criteria_values()
+
+        # Hide controls and form, show result
+        self.query_one(".feedback-controls").display = False
+        self.query_one("#feedback-form").display = False
+
+        # Show result
+        result_container = self.query_one("#feedback-result")
+        result_text = self.query_one("#feedback-result-text", Static)
+
+        rating_emoji = "👍" if self.rating == "good" else "👎"
+        result_msg = f"{rating_emoji} Thank you for your feedback!"
+        if self.comment:
+            result_msg += f"\nComment: {self.comment}"
+
+        result_text.update(Content(result_msg))
+        result_container.display = True
+
+        # Update status to success
+        self.status = MessageStatus.SUCCESS
+
+        # Emit feedback event
+        self.post_message(self.FeedbackSubmitted(self.rating, self.comment, criteria))

vibecore-0.5.0/src/vibecore/widgets/feedback.tcss

@@ -0,0 +1,121 @@
+/* Feedback widget styles */
+
+FeedbackWidget {
+    color: $text;
+
+    .feedback-controls {
+        height: auto;
+        width: 1fr;
+        padding: 0 0 0 4;
+        margin-top: 1;
+
+        .feedback-button {
+            height: 3;
+            min-width: 12;
+            margin-right: 1;
+
+            &.selected {
+                text-style: bold;
+                border: heavy;
+            }
+
+            &.good-button {
+                background: $success;
+                color: $text;
+
+                &:hover {
+                    background: $success-lighten-1;
+                }
+
+                &.selected {
+                    background: $success-darken-1;
+                }
+            }
+
+            &.bad-button {
+                background: $error;
+                color: $text;
+
+                &:hover {
+                    background: $error-lighten-1;
+                }
+
+                &.selected {
+                    background: $error-darken-1;
+                }
+            }
+        }
+
+    }
+
+    .feedback-form {
+        height: auto;
+        width: 1fr;
+        padding: 0 0 0 4;
+        margin-top: 1;
+
+        .feedback-criteria {
+            height: auto;
+            width: 1fr;
+
+            .criteria-label {
+                color: $text-muted;
+                margin-bottom: 0;
+                height: 1;
+            }
+
+            Checkbox {
+                border: none;
+                margin: 0;
+                padding: 0;
+                color: $text;
+
+                &:focus {
+                    background: $panel;
+                }
+            }
+        }
+
+        .feedback-comment-area {
+            height: auto;
+            width: 1fr;
+            margin-top: 1;
+
+            .comment-label {
+                color: $text-muted;
+                margin-bottom: 0;
+                height: 1;
+            }
+
+            .feedback-textarea {
+                height: 6;
+                width: 1fr;
+                border: tall $primary;
+            }
+        }
+
+        .feedback-submit-button {
+            height: 3;
+            min-width: 10;
+            margin-top: 1;
+            background: $primary;
+            color: $text;
+
+            &:hover {
+                background: $primary-lighten-1;
+            }
+        }
+    }
+
+    .feedback-result {
+        height: auto;
+        width: 1fr;
+        padding: 1 0 0 4;
+        margin-top: 1;
+        color: $success;
+
+        #feedback-result-text {
+            color: $success;
+        }
+    }
+}

{vibecore-0.4.1 → vibecore-0.5.0}/src/vibecore/widgets/messages.py

@@ -1,3 +1,4 @@
+import os
 from enum import StrEnum
 
 from textual.app import ComposeResult
@@ -84,11 +85,16 @@ class MessageHeader(Widget):
         # self.query_one(".prefix").visible = self._prefix_visible
 
     def _on_mount(self, event) -> None:
+        disable_blink = bool(os.environ.get("TEXTUAL_SNAPSHOT_TEMPDIR"))
         self.blink_timer = self.set_interval(
             0.5,
             self._toggle_cursor_blink_visible,
-            pause=(self.status != MessageStatus.EXECUTING),
+            pause=(self.status != MessageStatus.EXECUTING) or disable_blink,
         )
+        # Ensure the prefix starts visible for executing statuses so snapshot tests
+        # and initial renders see the indicator before the first timer tick hides it.
+        if self.status == MessageStatus.EXECUTING:
+            self._prefix_visible = True
 
 
 class BaseMessage(Widget):

vibecore-0.4.1/src/vibecore/flow.py

@@ -1,105 +0,0 @@
-import asyncio
-import threading
-from collections.abc import Callable, Coroutine
-from typing import Protocol
-
-from agents import Agent
-from textual.pilot import Pilot
-
-from vibecore.context import VibecoreContext
-from vibecore.main import AppIsExiting, VibecoreApp
-from vibecore.widgets.core import MyTextArea
-from vibecore.widgets.messages import SystemMessage
-
-
-class UserInputFunc(Protocol):
-    """Protocol for user input function with optional prompt parameter."""
-
-    async def __call__(self, prompt: str = "") -> str:
-        """Get user input with optional prompt message.
-
-        Args:
-            prompt: Optional prompt to display before getting input.
-
-        Returns:
-            The user's input string.
-        """
-        ...
-
-
-async def flow(
-    agent: Agent,
-    logic: Callable[[VibecoreApp, VibecoreContext, UserInputFunc], Coroutine],
-    headless: bool = False,
-    shutdown: bool = False,
-    disable_user_input: bool = True,
-):
-    ctx = VibecoreContext()
-    app = VibecoreApp(ctx, agent, show_welcome=False)
-
-    app_ready_event = asyncio.Event()
-
-    def on_app_ready() -> None:
-        """Called when app is ready to process events."""
-        app_ready_event.set()
-
-    async def run_app(app: VibecoreApp) -> None:
-        """Run the apps message loop.
-
-        Args:
-            app: App to run.
-        """
-
-        with app._context():
-            try:
-                app._loop = asyncio.get_running_loop()
-                app._thread_id = threading.get_ident()
-                await app._process_messages(
-                    ready_callback=on_app_ready,
-                    headless=headless,
-                )
-            finally:
-                app_ready_event.set()
-
-    async def user_input(prompt: str = "") -> str:
-        if prompt:
-            await app.add_message(SystemMessage(prompt))
-        app.query_one(MyTextArea).disabled = False
-        app.query_one(MyTextArea).focus()
-        user_input = await app.wait_for_user_input()
-        if disable_user_input:
-            app.query_one(MyTextArea).disabled = True
-        return user_input
-
-    async def run_logic(app: VibecoreApp, ctx: VibecoreContext, user_input: UserInputFunc) -> None:
-        try:
-            await logic(app, ctx, user_input)
-        except AppIsExiting:
-            return
-
-    app_task = asyncio.create_task(run_app(app), name=f"with_app({app})")
-    await app_ready_event.wait()
-    pilot = Pilot(app)
-    logic_task: asyncio.Task | None = None
-
-    await pilot._wait_for_screen()
-    if disable_user_input:
-        app.query_one(MyTextArea).disabled = True
-    logic_task = asyncio.create_task(run_logic(app, ctx, user_input), name="logic_task")
-    done, pending = await asyncio.wait([logic_task, app_task], return_when=asyncio.FIRST_COMPLETED)
-
-    # If app has exited and logic is still running, cancel logic
-    if app_task in done and logic_task in pending:
-        logic_task.cancel()
-    # If logic is finished and app is still running
-    elif logic_task in done and app_task in pending:
-        if shutdown:
-            if not headless:
-                await pilot._wait_for_screen()
-                await asyncio.sleep(1.0)
-            app.exit()
-        else:
-            # Enable text input so users can interact freely
-            app.query_one(MyTextArea).disabled = False
-            # Wait until app is exited
-            await app_task