autosh 0.0.3__py3-none-any.whl → 0.0.4__py3-none-any.whl

autosh/session.py

@@ -1,17 +1,24 @@
 import asyncio
 from pathlib import Path
 import sys
-from agentia import Agent
-from agentia.chat_completion import MessageStream
-from agentia.message import UserMessage
+from agentia import (
+    Agent,
+    UserMessage,
+    Event,
+    ToolCallEvent,
+    MessageStream,
+    ChatCompletion,
+    UserConsentEvent,
+)
 from agentia.plugins import PluginInitError
+from neongrid.loading import Loading
 
 from autosh.config import CLI_OPTIONS, CONFIG
-from autosh.md import stream_md
+import neongrid as ng
 from .plugins import create_plugins
 import rich
 import platform
-from rich.prompt import Prompt
+from rich.prompt import Confirm
 
 
 INSTRUCTIONS = f"""
@@ -79,13 +86,13 @@ class Session:
                 * -h, --help     Show this message and exit.
             """,
         )
-        agent.history.add(self._get_argv_message())
+        agent.history.add(self.__get_argv_message())
         completion = agent.chat_completion(prompt, stream=True)
         async for stream in completion:
             await self.__render_streamed_markdown(stream)
         sys.exit(0)
 
-    def _get_argv_message(self):
+    def __get_argv_message(self):
         args = str(CLI_OPTIONS.args)
         if not CLI_OPTIONS.script:
             cmd = Path(sys.argv[0]).name
@@ -112,7 +119,7 @@ class Session:
         # Execute the prompt
         loading = self.__create_loading_indicator()
         CLI_OPTIONS.prompt = prompt
-        self.agent.history.add(self._get_argv_message())
+        self.agent.history.add(self.__get_argv_message())
         if CLI_OPTIONS.stdin_has_data():
             self.agent.history.add(
                 UserMessage(
@@ -134,13 +141,8 @@ class Session:
                     role="user",
                 )
             )
-        completion = self.agent.chat_completion(prompt, stream=True)
-        async for stream in completion:
-            if not loading:
-                loading = self.__create_loading_indicator()
-            if await self.__render_streamed_markdown(stream, loading=loading):
-                print()
-            loading = None
+        completion = self.agent.chat_completion(prompt, stream=True, events=True)
+        await self.__process_completion(completion, loading)
 
     async def exec_from_stdin(self):
         if sys.stdin.isatty():
@@ -157,104 +159,65 @@ class Session:
             prompt = f.read()
         await self.exec_prompt(prompt)
 
+    async def __process_event(self, e: Event):
+        if isinstance(e, UserConsentEvent):
+            e.response = await self.__confirm(e.message)
+        if isinstance(e, ToolCallEvent) and e.result is None:
+            if banner := (e.metadata or {}).get("banner"):
+                banner(e.arguments)
+
+    async def __confirm(self, message: str) -> bool:
+        if CLI_OPTIONS.yes:
+            return True
+        result = Confirm.ask(
+            f"[magenta]{message}[/magenta]", default=True, case_sensitive=False
+        )
+        if not CLI_OPTIONS.quiet:
+            rich.print()
+        return result
+
+    async def __process_completion(
+        self, completion: ChatCompletion[Event | MessageStream], loading: Loading
+    ):
+        async for stream in completion:
+            await loading.finish()
+
+            if isinstance(stream, Event):
+                await self.__process_event(stream)
+            else:
+                print()
+                await self.__render_streamed_markdown(stream)
+                print()
+
+            loading = self.__create_loading_indicator()
+
+        await loading.finish()
+
     async def run_repl(self):
-        console = rich.console.Console()
         while True:
             try:
-                prompt = console.input("[bold blue]>[/bold blue] ").strip()
+                prompt = (
+                    await ng.input("> ", sync=False, persist="/tmp/autosh-history")
+                ).strip()
                 if prompt in ["exit", "quit"]:
                     break
                 if len(prompt) == 0:
                     continue
-                loading = self.__create_loading_indicator(newline=True)
-                completion = self.agent.chat_completion(prompt, stream=True)
-                async for stream in completion:
-                    if not loading:
-                        loading = self.__create_loading_indicator()
-                    if await self.__render_streamed_markdown(stream, loading=loading):
-                        print()
-                    loading = None
+                loading = self.__create_loading_indicator()
+                completion = self.agent.chat_completion(
+                    prompt, stream=True, events=True
+                )
+                await self.__process_completion(completion, loading)
             except KeyboardInterrupt:
                 break
 
-    def __create_loading_indicator(self, newline: bool = False):
-        return (
-            asyncio.create_task(self.__loading(newline))
-            if sys.stdout.isatty()
-            else None
-        )
-
-    async def __loading(self, newline: bool = False):
-        chars = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
-        char_width = 1
-        msg = "Loading..."
-        count = 0
-        print("\x1b[2m", end="", flush=True)
-        while True:
-            try:
-                print(chars[count], end="", flush=True)
-                print(" " + msg, end="", flush=True)
-                count += 1
-                await asyncio.sleep(0.1)
-                length = char_width + len(msg) + 1
-                print("\b" * length, end="", flush=True)
-                print(" " * length, end="", flush=True)
-                print("\b" * length, end="", flush=True)
-                if count == len(chars):
-                    count = 0
-            except asyncio.CancelledError:
-                length = char_width + len(msg) + 1
-                print("\b" * length, end="", flush=True)
-                print(" " * length, end="", flush=True)
-                print("\b" * length, end="", flush=True)
-                print("\x1b[0m", end="", flush=True)
-                if newline:
-                    print()
-                break
+    def __create_loading_indicator(self):
+        return ng.loading.kana()
 
-    async def __render_streamed_markdown(
-        self, stream: MessageStream, loading: asyncio.Task[None] | None = None
-    ):
+    async def __render_streamed_markdown(self, stream: MessageStream):
         if sys.stdout.isatty():
-            # buffer first few chars so we don't need to launch glow if there is no output
-            chunks = aiter(stream)
-            buf = ""
-            while len(buf) < 8:
-                try:
-                    buf += await anext(chunks)
-                except StopAsyncIteration:
-                    if len(buf) == 0:
-                        if loading:
-                            loading.cancel()
-                            await loading
-                        return False
-                    break
-            if loading:
-                loading.cancel()
-                await loading
-
-            content = {"v": ""}
-
-            async def gen():
-                content["v"] = buf
-                if buf:
-                    yield buf
-                while True:
-                    try:
-                        s = await anext(chunks)
-                        content["v"] += s
-                        for c in s:
-                            yield c
-                    except StopAsyncIteration:
-                        break
-
-            await stream_md(gen())
+            await ng.stream.markdown(aiter(stream))
             return True
         else:
-            has_content = False
             async for chunk in stream:
-                if chunk == "":
-                    continue
-                has_content = True
                 print(chunk, end="", flush=True)
-            return has_content

{autosh-0.0.3.dist-info → autosh-0.0.4.dist-info}/METADATA

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: autosh
-Version: 0.0.3
+Version: 0.0.4
 Summary: Add your description here
 License-File: LICENSE
 Requires-Python: >=3.13
-Requires-Dist: agentia>=0.0.5
+Requires-Dist: agentia>=0.0.7
 Requires-Dist: asyncio>=3.4.3
 Requires-Dist: markdownify>=1.1.0
+Requires-Dist: neongrid
+Requires-Dist: prompt-toolkit>=3.0.51
 Requires-Dist: pydantic>=2.11.3
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=14.0.0

autosh-0.0.4.dist-info/RECORD

@@ -0,0 +1,17 @@
+autosh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autosh/config-template.toml,sha256=iLdCBHIK0czWgNHtwAgvuhV670aiNc-IOmaPHP12i0Y,269
+autosh/config.py,sha256=7DXUSsqHm8dPsXln-NTu8D0_Uwcs2h4sT8pFtQM8tso,2654
+autosh/main.py,sha256=bgWkYpU9cmyU2AyWt4o8Mcj6LH_UGYSYrFx4Qkl8vqk,5117
+autosh/session.py,sha256=fOJySGU9abjFReNOyvQf-s9rFQdGy8Pv01GgplqrRuw,7943
+autosh/plugins/__init__.py,sha256=oUtO7M1AuZKshbaS-kO0fbV4CYal0uOvg-GpYVFE16I,2996
+autosh/plugins/calc.py,sha256=x_fZW3kkStlAAQEhejcD2_MQnpqCd5ghU72CNSjqIsg,672
+autosh/plugins/cli.py,sha256=G4WqTWeCi7OxdB36lAUiR1OBdtSvxmKRcQGGLdMcxms,9230
+autosh/plugins/clock.py,sha256=gIrYBz3GmnAJTujzd3B8ewuThXpF-OvWYBugcZMYGTQ,570
+autosh/plugins/code.py,sha256=HK7cd7gNit2yZAukaCnTGXb6BAh31cPh0EHCx6msOWc,2457
+autosh/plugins/search.py,sha256=aWbIDJ7E5m-Xrw2A1DB6w53oGiFe1Uc3EuZikIH5eTs,2984
+autosh/plugins/web.py,sha256=LxE7ed7IS9B4spWCm-3aBMLfC9ghcNnmJzMiD6ayLdc,2648
+autosh-0.0.4.dist-info/METADATA,sha256=cv69lLqKHEFwz5AZWEmmL0scvhzYv8-ECPdEiRzOaus,1959
+autosh-0.0.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+autosh-0.0.4.dist-info/entry_points.txt,sha256=BV7bzUnxG6Z5InEkrfajGCxjooYORC5tZDDZctOPenQ,67
+autosh-0.0.4.dist-info/licenses/LICENSE,sha256=BnLDJsIJe-Dm18unR9DOoSv7QOfAz6LeIQc1yHAjxp0,1066
+autosh-0.0.4.dist-info/RECORD,,

autosh/md/__init__.py

@@ -1,8 +0,0 @@
-from typing import AsyncGenerator
-
-from autosh.md.printer import StreamedMarkdownPrinter
-
-
-async def stream_md(stream: AsyncGenerator[str, None]):
-    mp = StreamedMarkdownPrinter(stream)
-    await mp.parse_doc()

autosh/md/inline_text.py

@@ -1,214 +0,0 @@
-from dataclasses import dataclass, field
-from autosh.md.printer import StreamedMarkdownPrinter
-from autosh.md.state import State
-
-
-@dataclass
-class Keyword:
-    token: str
-
-    def is_bold(self) -> bool:
-        return self.token[0] in ["*", "_"] and len(self.token) == 2
-
-    def is_italic(self) -> bool:
-        return self.token[0] in ["*", "_"] and len(self.token) == 1
-
-    def is_bold_and_italic(self) -> bool:
-        return self.token[0] in ["*", "_"] and len(self.token) > 2
-
-    def is_bold_or_italic(self) -> bool:
-        return self.token[0] in ["*", "_"]
-
-
-class InvalidState(Exception):
-    def __init__(self, token: str):
-        super().__init__(token)
-        self.token = token
-
-
-@dataclass
-class InlineScope:
-    state: State
-
-    stack: list[tuple[Keyword, State]] = field(default_factory=list)
-
-    @property
-    def last(self) -> str | None:
-        return self.stack[-1][0].token if len(self.stack) > 0 else None
-
-    @property
-    def strike(self) -> bool:
-        return self.last == "~~"
-
-    @property
-    def code(self) -> bool:
-        return self.last == "`"
-
-    def enter(self, kind: Keyword):
-        match kind:
-            case "`":
-                state = self.state._enter_scope(dim=True)
-            case "~~":
-                state = self.state._enter_scope(strike=True)
-            case _ if kind.is_bold():
-                state = self.state._enter_scope(bold=True)
-            case _ if kind.is_italic():
-                state = self.state._enter_scope(italic=True)
-            case _ if kind.is_bold_and_italic():
-                state = self.state._enter_scope(bold=True, italic=True)
-            case _:
-                state = self.state._enter_scope()
-        self.stack.append((kind, state))
-
-    def exit(self):
-        t = self.stack.pop()
-        state = t[1]
-        self.state._exit_scope(state)
-
-
-class InlineTextPrinter:
-    def __init__(self, p: StreamedMarkdownPrinter, table: bool = False):
-        self.p = p
-        self.terminator = ["\n", None]
-        if table:
-            self.terminator.append("|")
-
-    def emit(self, s: str):
-        self.p.emit(s)
-
-    def peek(self):
-        return self.p.peek()
-
-    async def consume(self, n: int = 1):
-        return await self.p.consume(n)
-
-    async def check(self, s: str, eof: bool | None = None) -> bool:
-        return await self.p.check(s, eof)
-
-    async def parse_inline_unformatted(self):
-        # Parse until another "`" or a newline, or EOF
-        while not self.peek() in self.terminator:
-            c = await self.p.consume()
-            self.emit(c)
-
-    async def parse_inline_code(self):
-        self.emit("`")
-        # Parse until another "`" or a newline, or EOF
-        while not await self.check("`"):
-            c = await self.p.consume()
-            if c in self.terminator:
-                return
-            self.emit(c)
-            if c == "\\":
-                c = await self.p.consume()
-                if c in self.terminator:
-                    return
-                self.emit(c)
-        self.emit("`")
-        await self.p.consume()
-
-    async def get_next_token(self) -> str | Keyword | None:
-        c = self.peek()
-        if c in self.terminator:
-            return None
-        if c == "`":
-            await self.consume()
-            return Keyword("`")
-        if c == "*":
-            s = ""
-            while self.peek() == "*":
-                s += c
-                await self.consume()
-            return Keyword(s)
-        if c == "_":
-            s = ""
-            while self.peek() == "_":
-                s += c
-                await self.consume()
-            return Keyword(s)
-        if c == "~" and await self.check("~~"):
-            s = ""
-            while self.peek() == "~":
-                s += c
-                await self.consume()
-            return Keyword(s)
-        if c == " " or c == "\t":
-            s = ""
-            while self.peek() == " " or self.peek() == "\t":
-                s += c
-                await self.consume()
-            return s
-        s = c or ""
-        if c == "\\":
-            await self.consume()
-            c = self.peek()
-            if c in self.terminator:
-                return None if len(s) == 0 else s
-            s += c or ""
-            await self.consume()
-        else:
-            await self.consume()
-        if len(s) == 0:
-            return None
-        return s
-
-    async def parse_inline(self, consume_trailing_newline: bool = True):
-        last_is_space = False
-        start = True
-        scope = InlineScope(self.p.state)
-
-        while True:
-            t = await self.get_next_token()
-            curr_is_space = False
-
-            if t is None:
-                if consume_trailing_newline:
-                    if self.peek() == "\n":
-                        await self.consume()
-                    self.emit("\n")
-                return
-            elif isinstance(t, str):
-                # Space or normal text
-                if t[0] == " ":
-                    curr_is_space = True
-                    self.emit(" ")
-                else:
-                    self.emit(t)
-            elif t.token == "`":
-                # Inline code
-                scope.enter(t)
-                with self.p.state.style(dim=True):
-                    await self.parse_inline_code()
-                scope.exit()
-            elif t.token == "~~":
-                # Strike through
-                if not scope.strike:
-                    scope.enter(t)
-                    self.emit("~~")
-                else:
-                    self.emit("~~")
-                    scope.exit()
-            elif (
-                t.is_bold_or_italic()
-                and (last_is_space or start)
-                and scope.last != t.token
-            ):
-                # Start bold or italics
-                scope.enter(t)
-                self.emit(t.token)
-            elif (
-                t.is_bold_or_italic()
-                and self.peek() in [" ", "\t", *self.terminator]
-                and scope.last == t.token
-            ):
-                # End bold or italics
-                self.emit(t.token)
-                scope.exit()
-            else:
-                # print(
-                #     "Invalid token:", t.token, f"[{self.peek()}]", scope.last == t.token
-                # )
-                raise InvalidState(t.token)
-
-            last_is_space = curr_is_space
-            start = False