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

vibecore/flow.py

@@ -1,13 +1,29 @@
 import asyncio
+import contextlib
+import datetime
+import sys
 import threading
 from collections.abc import Callable, Coroutine
-from typing import Protocol
+from typing import Any, Generic, Protocol, TypeAlias, overload
 
-from agents import Agent
+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
 
@@ -27,79 +43,303 @@ class UserInputFunc(Protocol):
         ...
 
 
-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)
+TWorkflowReturn = TypeVar("TWorkflowReturn", default=RunResultBase)
+DecoratedCallable: TypeAlias = Callable[..., Coroutine[Any, Any, TWorkflowReturn]]
 
-    app_ready_event = asyncio.Event()
 
-    def on_app_ready() -> None:
+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."""
-        app_ready_event.set()
+        self.app_ready_event.set()
 
-    async def run_app(app: VibecoreApp) -> None:
+    async def _run_app(self) -> None:
         """Run the apps message loop.
 
         Args:
             app: App to run.
         """
 
-        with app._context():
+        with self.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,
+                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:
-                app_ready_event.set()
+                self.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:
+    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:
-            await logic(app, ctx, user_input)
+            return await self.vibecore.workflow_logic()
         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:
+            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)
-            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
+                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/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.2.dist-info → vibecore-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibecore
-Version: 0.4.2
+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.2.dist-info → vibecore-0.5.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 vibecore/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vibecore/cli.py,sha256=HU2cjvEDzMWlauoArUItBlTpsVAdgVuKFMLshtaqvUE,7119
 vibecore/context.py,sha256=SZdWOOBKOPBRVC66Y3NohkWdxR5dbAycCHynuqhmEFo,2577
-vibecore/flow.py,sha256=ZaKzMsz4YBvgelVzJOIHnTJzMWTmvkfvudwW_hllq6U,3384
+vibecore/flow.py,sha256=1Tcbnox4UwDHFJ3i0hBGu7TZsBfjLkEsGFuJVhJjmcY,12205
 vibecore/main.py,sha256=JeUhWOoWZDmvFrufMHe01DiUlTNsovcmpH9w8uudTm8,20127
 vibecore/main.tcss,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vibecore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -29,7 +29,7 @@ vibecore/models/anthropic_auth.py,sha256=_hRGbPHTs6IrkSc5mDI7mshdOZYCyqu82HX9WdQ
 vibecore/prompts/common_system_prompt.txt,sha256=L-YlOfTJSQLtVg6d0r9lcD5FrgOLzoSWjGzVfQjcDBg,4916
 vibecore/session/__init__.py,sha256=FXbtw8DZVBw8e3qCA2cQharMzozblhwA0yU4U0JRSkM,121
 vibecore/session/file_lock.py,sha256=vCuDdfaOGDeVpTjJP6yBJx7onIT7JkkAeAuWAtuLJb8,3739
-vibecore/session/jsonl_session.py,sha256=vWITGBugf5ZDkI00abwsD_lyi6LwHYXzX9JrwavS9hE,8734
+vibecore/session/jsonl_session.py,sha256=hS03fbgPzKEKdUesdg_8OHCoD1nnMFjHe54K2Psh3SY,8771
 vibecore/session/loader.py,sha256=vmDwzjtedFEeWhaFa6HbygjL32-bSNXM6KccQC9hyJs,6880
 vibecore/session/path_utils.py,sha256=_meng4PnOR59ekPWp_WICkt8yVkokt8c6oePZvk3m-4,2544
 vibecore/tools/__init__.py,sha256=nppfKiflvkQRUotBrj9nFU0veWex1DE_YX1fg67SRlw,37
@@ -81,8 +81,8 @@ vibecore/widgets/messages.tcss,sha256=Dhz6X1Fkj2XN9bVGVH_hBelDF7WXNE6hHMkGQRQy1Q
 vibecore/widgets/tool_message_factory.py,sha256=yrZorT4HKo5b6rWUc0dgQle7q7cvLyq8JllE772RZS0,5730
 vibecore/widgets/tool_messages.py,sha256=hJOolN3iLTAjqfotfH1elXqsdDo1r_UHjsyRVH0GAeo,29415
 vibecore/widgets/tool_messages.tcss,sha256=gdChmHClURqn_sD9GkcOGQcQVYvUUl75mLUYp85sKz8,8442
-vibecore-0.4.2.dist-info/METADATA,sha256=jakWk2i8UVQ9fIECmTH6tyDr3DLVR5h6A-svdfuDMlk,19550
-vibecore-0.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-vibecore-0.4.2.dist-info/entry_points.txt,sha256=i9mOKvpz07ciV_YYisxNCYZ53_Crjkn9mciiQ3aA6QM,51
-vibecore-0.4.2.dist-info/licenses/LICENSE,sha256=KXxxifvrcreHrZ4aOYgP-vA8DRHHueW389KKOeEbtjc,1069
-vibecore-0.4.2.dist-info/RECORD,,
+vibecore-0.5.0.dist-info/METADATA,sha256=Ow2rN0Iwmim2skl99Og1fYZEz1VTd_c4GS8crTl6P_0,19550
+vibecore-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+vibecore-0.5.0.dist-info/entry_points.txt,sha256=i9mOKvpz07ciV_YYisxNCYZ53_Crjkn9mciiQ3aA6QM,51
+vibecore-0.5.0.dist-info/licenses/LICENSE,sha256=KXxxifvrcreHrZ4aOYgP-vA8DRHHueW389KKOeEbtjc,1069
+vibecore-0.5.0.dist-info/RECORD,,