autosh 0.0.2__tar.gz → 0.0.4__tar.gz

{autosh-0.0.2 → autosh-0.0.4}/.gitignore

@@ -16,3 +16,4 @@ wheels/
 
 # Other files
 /_*
+.DS_Store

{autosh-0.0.2 → autosh-0.0.4}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: autosh
-Version: 0.0.2
+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
@@ -31,7 +33,9 @@ As an interactive shell: `ash` (alternatively, `autosh`)
 
 Execute a single prompt: `ash "list current directory"`
 
-Process piped data: `cat README.md | ash "summarise"`
+Process piped data:
+* `cat README.md | ash -y "summarise"`
+* `cat in.csv | ash -y -q "double the first numeric column" > out.csv`
 
 ## Scripting
 
@@ -72,6 +76,8 @@ Write "Hello, world" to _test.log
 
 # TODO
 
-- [ ] Image generation
-- [ ] Image input
+- [ ] Image input, generation, and editing
 - [ ] RAG for non-text files
+- [ ] Plugin system
+- [ ] MCP support
+- [ ] A better input widget with history and auto completion

{autosh-0.0.2 → autosh-0.0.4}/README.md

@@ -14,7 +14,9 @@ As an interactive shell: `ash` (alternatively, `autosh`)
 
 Execute a single prompt: `ash "list current directory"`
 
-Process piped data: `cat README.md | ash "summarise"`
+Process piped data:
+* `cat README.md | ash -y "summarise"`
+* `cat in.csv | ash -y -q "double the first numeric column" > out.csv`
 
 ## Scripting
 
@@ -55,6 +57,8 @@ Write "Hello, world" to _test.log
 
 # TODO
 
-- [ ] Image generation
-- [ ] Image input
+- [ ] Image input, generation, and editing
 - [ ] RAG for non-text files
+- [ ] Plugin system
+- [ ] MCP support
+- [ ] A better input widget with history and auto completion

autosh-0.0.4/autosh/config-template.toml

@@ -0,0 +1,13 @@
+# autosh configuration file
+[autosh]
+api_key = "sk-or-v1-..."
+# model = "openai/gpt-4.1"
+# think_model = "openai/o4-mini-high"
+
+[plugins]
+calc = {}
+cli = {}
+clock = {}
+code = {}
+# search = { tavily_api_key = "tvly-dev-..." }
+# web = { tavily_api_key = "tvly-dev-..." }

{autosh-0.0.2 → autosh-0.0.4}/autosh/config.py

@@ -43,6 +43,11 @@ class Config(BaseModel):
 
     @staticmethod
     def load() -> "Config":
+        if not USER_CONFIG_PATH.is_file():
+            # Copy config.template.toml to USER_CONFIG_PATH
+            USER_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+            template = Path(__file__).parent / "config.template.toml"
+            USER_CONFIG_PATH.write_text(template.read_text())
         if USER_CONFIG_PATH.is_file():
             try:
                 doc = tomllib.loads(USER_CONFIG_PATH.read_text())

{autosh-0.0.2 → autosh-0.0.4}/autosh/main.py

@@ -1,14 +1,16 @@
 import os
+
+os.environ["AGENTIA_DISABLE_PLUGINS"] = "1"
+
 from pathlib import Path
 import rich
 import typer
 import asyncio
-import dotenv
 from rich.columns import Columns
 from rich.panel import Panel
 import argparse
 
-from autosh.config import CLI_OPTIONS, CONFIG
+from autosh.config import CLI_OPTIONS, CONFIG, USER_CONFIG_PATH
 from .session import Session
 import sys
 
@@ -26,6 +28,8 @@ app = typer.Typer(
 async def start_session(prompt: str | None, args: list[str]):
     CLI_OPTIONS.args = args
     session = Session()
+    os.environ["OPENROUTER_HAS_REASONING"] = "false"
+    os.environ["OPENROUTER_INCLUDE_REASONING"] = "false"
     await session.init()
     piped_stdin = not sys.stdin.isatty()
     if piped_stdin and not CLI_OPTIONS.yes:
@@ -149,14 +153,13 @@ def main():
     # dotenv.load_dotenv()
     prompt, args = parse_args()
 
+    if key := os.getenv("OPENROUTER_API_KEY"):
+        CONFIG.api_key = key
     if CONFIG.api_key is None:
-        if key := os.getenv("OPENROUTER_API_KEY"):
-            CONFIG.api_key = key
-        else:
-            rich.print(
-                "[bold red]Error:[/bold red] [red]No API key found. Please set the OPENROUTER_API_KEY environment variable or add it to your config file.[/red]"
-            )
-            sys.exit(1)
+        rich.print(
+            f"[bold red]Error:[/bold red] [red]OpenRouter API key not found.\nPlease set the OPENROUTER_API_KEY environment variable or add it to your config file: {USER_CONFIG_PATH}.[/red]"
+        )
+        sys.exit(1)
     try:
         asyncio.run(start_session(prompt, args))
     except (KeyboardInterrupt, EOFError):

{autosh-0.0.2 → autosh-0.0.4}/autosh/plugins/__init__.py

@@ -1,3 +1,4 @@
+from typing import Any, Callable
 import rich
 from rich.prompt import Confirm
 from rich.panel import Panel
@@ -5,40 +6,55 @@ from rich.console import RenderableType
 from autosh.config import CLI_OPTIONS, CONFIG
 
 
-def banner(tag: str, text: str | None = None, dim: str | None = None):
+def __print_simple_banner(tag: str, text: str | None = None, dim: str | None = None):
     if CLI_OPTIONS.quiet:
         return
-    s = f"[bold magenta]{tag}[/bold magenta]"
+    s = f"\n[bold on magenta] {tag} [/bold on magenta]"
     if text:
         s += f" [italic magenta]{text}[/italic magenta]"
     if dim:
         s += f" [italic dim]{dim}[/italic dim]"
-    s += "\n"
     rich.print(s)
 
 
-def confirm(message: str):
-    if CLI_OPTIONS.yes:
-        return True
-    result = Confirm.ask(
-        f"[magenta]{message}[/magenta]", default=True, case_sensitive=False
+def simple_banner(
+    tag: str | Callable[[Any], str],
+    text: Callable[[Any], str] | None = None,
+    dim: Callable[[Any], str] | None = None,
+):
+    return lambda x: __print_simple_banner(
+        tag if isinstance(tag, str) else tag(x),
+        text(x) if text else None,
+        dim(x) if dim else None,
     )
-    if not CLI_OPTIONS.quiet:
-        rich.print()
-    return result
 
 
-def cmd_preview_panel(title: str, content: RenderableType, short: str | None = None):
-    if CLI_OPTIONS.quiet and not CLI_OPTIONS.yes:
-        if short:
-            rich.print(f"[magenta]{short}[/magenta]\n")
+def __print_code_preview_banner(
+    title: str, content: RenderableType, short: str | None = None
+):
+    if CLI_OPTIONS.quiet:
+        if short and not CLI_OPTIONS.yes:
+            rich.print(f"\n[magenta]{short}[/magenta]\n")
         return
     panel = Panel.fit(content, title=f"[magenta]{title}[/magenta]", title_align="left")
+    rich.print()
     rich.print(panel)
     rich.print()
 
 
-def cmd_result_panel(
+def code_preview_banner(
+    title: str | Callable[[Any], str],
+    short: str | Callable[[Any], str],
+    content: Callable[[Any], RenderableType],
+):
+    return lambda x: __print_code_preview_banner(
+        title=title if isinstance(title, str) else title(x),
+        content=content(x),
+        short=short if isinstance(short, str) else short(x),
+    )
+
+
+def code_result_panel(
     title: str,
     out: str | None = None,
     err: str | None = None,

{autosh-0.0.2 → autosh-0.0.4}/autosh/plugins/calc.py

@@ -1,12 +1,16 @@
 from agentia.plugins import tool, Plugin
 from typing import Annotated
-from . import banner
+from . import simple_banner
 
 
 class CalculatorPlugin(Plugin):
     NAME = "calc"
 
-    @tool
+    @tool(
+        metadata={
+            "banner": simple_banner("CALC", dim=lambda a: a.get("expression", ""))
+        }
+    )
     def evaluate(
         self,
         expression: Annotated[
@@ -16,7 +20,6 @@ class CalculatorPlugin(Plugin):
         """
         Execute a math expression and return the result. The expression must be an valid python expression that can be execuated by `eval()`.
         """
-        banner("CALC", expression)
 
         result = eval(expression)
         return result

{autosh-0.0.2 → autosh-0.0.4}/autosh/plugins/cli.py

@@ -1,14 +1,14 @@
 import os
 import sys
 from typing import Annotated
-from agentia.plugins import Plugin, tool
+from agentia import Plugin, tool, UserConsentEvent
 import rich
 import subprocess
 from enum import StrEnum
 
 from autosh.config import CLI_OPTIONS
 
-from . import banner, confirm, cmd_result_panel, cmd_preview_panel
+from . import code_result_panel, code_preview_banner, simple_banner
 
 
 class Color(StrEnum):
@@ -59,22 +59,20 @@ class CLIPlugin(Plugin):
         rich.print(text, file=sys.stderr if stderr else sys.stdout, end=end)
         return "DONE. You can continue and no need to repeat the text"
 
-    @tool
+    @tool(metadata={"banner": simple_banner("CWD", dim=lambda a: a.get("path", ""))})
     def chdir(self, path: Annotated[str, "The path to the new working directory"]):
         """
         Changes the current working directory of the terminal to another directory.
         """
-        banner("CWD", path)
         if not os.path.exists(path):
             raise FileNotFoundError(f"Path `{path}` does not exist.")
         os.chdir(path)
 
-    @tool
+    @tool(metadata={"banner": simple_banner("GET ARGV")})
     def get_argv(self):
         """
         Get the command line arguments.
         """
-        banner("GET ARGV")
         if not CLI_OPTIONS.script:
             return CLI_OPTIONS.args
         return {
@@ -82,28 +80,34 @@ class CLIPlugin(Plugin):
             "args": CLI_OPTIONS.args,
         }
 
-    @tool
+    @tool(metadata={"banner": simple_banner("GET ENV", dim=lambda a: a.get("key", ""))})
     def get_env(self, key: Annotated[str, "The environment variable to get"]):
         """
         Get an environment variable.
         """
-        banner("GET ENV", key)
         if key not in os.environ:
             raise KeyError(f"Environment variable `{key}` does not exist.")
         return os.environ[key]
 
-    @tool
+    @tool(metadata={"banner": simple_banner("GET ALL ENVS")})
     def get_all_envs(self):
         """
         Get all environment variables.
         """
-        banner("GET ALL ENVS")
         envs = {}
         for key, value in os.environ.items():
             envs[key] = value
         return {"envs": envs}
 
-    @tool
+    @tool(
+        metadata={
+            "banner": simple_banner(
+                tag=lambda a: "SET ENV" if a.get("value") else "DEL ENV",
+                text=lambda a: a.get("key", ""),
+                dim=lambda a: a.get("value", "") or "",
+            ),
+        }
+    )
     def update_env(
         self,
         key: Annotated[str, "The environment variable to set"],
@@ -116,15 +120,13 @@ class CLIPlugin(Plugin):
         Set or delete an environment variable.
         """
         if value is None:
-            banner("DEL ENV", key)
             if key in os.environ:
                 del os.environ[key]
         else:
-            banner("SET ENV", key, value)
             os.environ[key] = value
         return f"DONE"
 
-    @tool
+    @tool(metadata={"banner": simple_banner("READ", dim=lambda a: a.get("path", ""))})
     def read(
         self,
         path: Annotated[str, "The path to the file to read"],
@@ -132,7 +134,6 @@ class CLIPlugin(Plugin):
         """
         Read a file and print its content.
         """
-        banner("READ", path)
         if not os.path.exists(path):
             raise FileNotFoundError(f"File `{path}` does not exist.")
         if not os.path.isfile(path):
@@ -141,7 +142,15 @@ class CLIPlugin(Plugin):
             content = f.read()
         return content
 
-    @tool
+    @tool(
+        metadata={
+            "banner": simple_banner(
+                tag=lambda a: "WRITE" if not a.get("append") else "APPEND",
+                text=lambda a: a.get("path", ""),
+                dim=lambda a: f"({len(a.get('content', ''))} bytes)",
+            ),
+        }
+    )
     def write(
         self,
         path: Annotated[str, "The path to the file to write"],
@@ -154,8 +163,6 @@ class CLIPlugin(Plugin):
         """
         Write or append text content to a file.
         """
-        banner("WRITE" if not append else "APPEND", path, f"({len(content)} bytes)")
-
         if not create and not os.path.exists(path):
             raise FileNotFoundError(f"File `{path}` does not exist.")
         if not create and not os.path.isfile(path):
@@ -164,7 +171,7 @@ class CLIPlugin(Plugin):
             raise FileExistsError(
                 f"No, you cannot overwrite the script file `{path}`. You're likely writing to it by mistake."
             )
-        if not confirm("Write file?"):
+        if not (yield UserConsentEvent("Write file?")):
             return {"error": "The user declined the write operation."}
         flag = "a" if append else "w"
         if create:
@@ -200,7 +207,15 @@ class CLIPlugin(Plugin):
             raise RuntimeError("No piped input from stdin")
         return sys.stdin.read()
 
-    @tool
+    @tool(
+        metadata={
+            "banner": code_preview_banner(
+                title="Run Command",
+                short=lambda a: f"[magenta][bold]➜[/bold] [italic]{a.get("command", "")}[/italic][/magenta]",
+                content=lambda a: f"[magenta][bold]➜[/bold] [italic]{a.get("command", "")}[/italic][/magenta]\n\n[dim]{a.get("explanation", "")}[/dim]",
+            )
+        }
+    )
     def exec(
         self,
         command: Annotated[
@@ -220,15 +235,8 @@ class CLIPlugin(Plugin):
             cmd = ["bash", "-c", command]
             return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
-        # Print the command and explanation
-        cmd_preview_panel(
-            title="Run Command",
-            content=f"[magenta][bold]➜[/bold] [italic]{command}[/italic][/magenta]\n\n[dim]{explanation}[/dim]",
-            short=f"[magenta][bold]➜[/bold] [italic]{command}[/italic][/magenta]",
-        )
-
         # Ask for confirmation
-        if not confirm("Execute this command?"):
+        if not (yield UserConsentEvent("Execute this command?")):
             return {"error": "The user declined to execute the command."}
 
         # Execute the command
@@ -245,7 +253,7 @@ class CLIPlugin(Plugin):
                     title = f"[red][bold]✘[/bold] Command Failed [{proc_result.returncode}][/red]"
                 else:
                     title = "[green][bold]✔[/bold] Command Finished[/green]"
-            cmd_result_panel(title, out, err)
+            code_result_panel(title, out, err)
 
         result = {
             "stdout": proc_result.stdout.decode("utf-8"),
@@ -255,10 +263,9 @@ class CLIPlugin(Plugin):
         }
         return result
 
-    @tool
+    @tool(metadata={"banner": simple_banner("EXIT")})
     def exit(self, exitcode: Annotated[int, "The exit code of this shell session"] = 0):
         """
         Exit the current shell session with an optional exit code.
         """
-        banner("EXIT", str(exitcode))
         sys.exit(exitcode)

{autosh-0.0.2 → autosh-0.0.4}/autosh/plugins/clock.py

@@ -2,14 +2,13 @@ import datetime
 from agentia.plugins import tool, Plugin
 import tzlocal
 
-from autosh.plugins import banner
+from autosh.plugins import simple_banner
 
 
 class ClockPlugin(Plugin):
-    @tool
+    @tool(metadata={"banner": simple_banner("GET TIME")})
     def get_current_time(self):
         """Get the current UTC time in ISO format"""
-        banner("GET TIME")
         utc = datetime.datetime.now(datetime.timezone.utc).isoformat()
         local = datetime.datetime.now().isoformat()
         timezone = tzlocal.get_localzone_name()

{autosh-0.0.2 → autosh-0.0.4}/autosh/plugins/code.py

@@ -1,15 +1,32 @@
-from agentia.plugins import tool, Plugin
+from agentia import tool, Plugin, UserConsentEvent
 from typing import Annotated
 import traceback
 from rich.syntax import Syntax
 from rich.console import group
 from contextlib import redirect_stdout, redirect_stderr
 import io
-from . import confirm, cmd_result_panel, cmd_preview_panel
+from . import code_preview_banner, code_result_panel
+
+
+@group()
+def code_with_explanation(code: str, explanation: str):
+    yield Syntax(code.strip(), "python")
+    yield "\n[dim]───[/dim]\n"
+    yield f"[dim]{explanation}[/dim]"
 
 
 class CodePlugin(Plugin):
-    @tool
+    @tool(
+        metadata={
+            "banner": code_preview_banner(
+                title="Run Python",
+                short="[bold]RUN[/bold] [italic]Python Code[/italic]",
+                content=lambda a: code_with_explanation(
+                    a.get("python_code", ""), a.get("explanation", "")
+                ),
+            )
+        }
+    )
     def execute(
         self,
         python_code: Annotated[str, "The python code to run."],
@@ -22,20 +39,7 @@ class CodePlugin(Plugin):
         The python code must be a valid python source file that accepts no inputs.
         Print results to stdout or stderr.
         """
-
-        @group()
-        def code_with_explanation():
-            yield Syntax(python_code.strip(), "python")
-            yield "\n[dim]───[/dim]\n"
-            yield f"[dim]{explanation}[/dim]"
-
-        cmd_preview_panel(
-            title="Run Python",
-            content=code_with_explanation(),
-            short=f"[bold]RUN[/bold] [italic]Python Code[/italic]",
-        )
-
-        if not confirm("Execute this code?"):
+        if not (yield UserConsentEvent("Execute this code?")):
             return {"error": "The user declined to execute the command."}
 
         out = io.StringIO()
@@ -64,5 +68,5 @@ class CodePlugin(Plugin):
                         "traceback": repr(traceback.format_exc()),
                     }
 
-        cmd_result_panel(title, o, e)
+        code_result_panel(title, o, e)
         return result

{autosh-0.0.2 → autosh-0.0.4}/autosh/plugins/search.py

@@ -3,7 +3,7 @@ from typing import Annotated, override
 import os
 from tavily import TavilyClient
 
-from autosh.plugins import banner
+from autosh.plugins import simple_banner
 
 
 class SearchPlugin(Plugin):
@@ -17,7 +17,11 @@ class SearchPlugin(Plugin):
             raise ValueError("Please set the TAVILY_API_KEY environment variable.")
         self.__tavily = TavilyClient(api_key=key)
 
-    @tool
+    @tool(
+        metadata={
+            "banner": simple_banner("WEB SEARCH", dim=lambda a: a.get("query", "")),
+        }
+    )
     async def web_search(
         self,
         query: Annotated[
@@ -29,8 +33,6 @@ class SearchPlugin(Plugin):
         Returning the top related search results in json format.
         When necessary, you need to combine this tool with the get_webpage_content tools (if available), to browse the web in depth by jumping through links.
         """
-        banner("WEB SEARCH", dim=query)
-
         tavily_results = self.__tavily.search(
             query=query,
             search_depth="advanced",
@@ -41,7 +43,11 @@ class SearchPlugin(Plugin):
         )
         return tavily_results
 
-    @tool
+    @tool(
+        metadata={
+            "banner": simple_banner("NEWS SEARCH", dim=lambda a: a.get("query", "")),
+        }
+    )
     async def news_search(
         self,
         query: Annotated[
@@ -52,7 +58,6 @@ class SearchPlugin(Plugin):
         Perform news search on the given query.
         Returning the top related results in json format.
         """
-        banner("NEWS SEARCH", dim=query)
 
         tavily_results = self.__tavily.search(
             query=query,
@@ -65,7 +70,11 @@ class SearchPlugin(Plugin):
         )
         return tavily_results
 
-    @tool
+    @tool(
+        metadata={
+            "banner": simple_banner("FINANCE SEARCH", dim=lambda a: a.get("query", ""))
+        }
+    )
     async def finance_search(
         self,
         query: Annotated[
@@ -76,7 +85,6 @@ class SearchPlugin(Plugin):
         Search for finance-related news and information on the given query.
         Returning the top related results in json format.
         """
-        banner("FINANCE SEARCH", dim=query)
 
         tavily_results = self.__tavily.search(
             query=query,

{autosh-0.0.2 → autosh-0.0.4}/autosh/plugins/web.py

@@ -7,7 +7,7 @@ from markdownify import markdownify
 import uuid
 from tavily import TavilyClient
 
-from autosh.plugins import banner
+from autosh.plugins import simple_banner
 
 
 class WebPlugin(Plugin):
@@ -47,7 +47,7 @@ class WebPlugin(Plugin):
         md = markdownify(res.text)
         return {"content": md}
 
-    @tool
+    @tool(metadata={"banner": simple_banner("BROWSE", dim=lambda a: a.get("url", ""))})
     def get_webpage_content(
         self,
         url: Annotated[str, "The URL of the web page to get the content of"],
@@ -57,7 +57,6 @@ class WebPlugin(Plugin):
         You can always use this tool to directly access web content or access external sites.
         Use it at any time when you think you may need to access the internet.
         """
-        banner("BROWSE", dim=url)
 
         result = self.__tavily.extract(
             urls=url,

{autosh-0.0.2 → autosh-0.0.4}/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,16 +86,16 @@ 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 = "PROMPT"
+            cmd = Path(sys.argv[0]).name
         else:
             cmd = CLI_OPTIONS.script.name
         return UserMessage(
@@ -112,21 +119,30 @@ 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(
-                    content="IMPORTANT: The user is using piped stdin to feed additional data to you. Please use tools to read when necessary.",
+                    content="IMPORTANT: You are acting as an intermediate tool of a workflow. Input data is fed to you through piped stdin. Please use tools to read when necessary.",
                     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
+        if not sys.stdout.isatty():
+            self.agent.history.add(
+                UserMessage(
+                    content="IMPORTANT: You are acting as an intermediate tool of a workflow. Your output should only contain the user expected output, nothing else. Don't ask user questions or print anything else since the user cannot see it.",
+                    role="user",
+                )
+            )
+        else:
+            self.agent.history.add(
+                UserMessage(
+                    content="IMPORTANT: This is a one-off run, so don't ask user questions since the user cannot reply.",
+                    role="user",
+                )
+            )
+        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():
@@ -143,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
-        )
+    def __create_loading_indicator(self):
+        return ng.loading.kana()
 
-    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
-
-    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.2 → autosh-0.0.4}/pyproject.toml

@@ -1,19 +1,21 @@
 [project]
 name = "autosh"
-version = "0.0.2"
+version = "0.0.4"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
-    "agentia>=0.0.5",
     "asyncio>=3.4.3",
     "markdownify>=1.1.0",
+    "prompt-toolkit>=3.0.51",
     "pydantic>=2.11.3",
     "python-dotenv>=1.1.0",
     "rich>=14.0.0",
     "tavily-python>=0.5.4",
     "typer>=0.12.5",
     "tzlocal>=5.3.1",
+    "neongrid",
+    "agentia>=0.0.7",
 ]
 
 [project.scripts]
@@ -26,8 +28,11 @@ include = ["autosh"]
 [tool.hatch.build.targets.wheel]
 include = ["autosh"]
 
-# [tool.uv.sources]
-# agentia = { path = "../agentia", editable = true }
+[tool.uv.sources]
+neongrid = { workspace = true }
+
+[tool.uv.workspace]
+members = ["packages/neongrid"]
 
 [build-system]
 requires = ["hatchling"]

autosh-0.0.2/autosh/md.py

@@ -1,408 +0,0 @@
-import os
-from typing import AsyncGenerator, Literal
-
-
-HIGHLIGHT_COLOR_START = "35"
-HIGHLIGHT_COLOR_END = "0"
-
-
-class MarkdowmPrinter:
-    def __init__(self, stream: AsyncGenerator[str, None]):
-        async def char_stream(stream: AsyncGenerator[str, None]):
-            async for chunk in stream:
-                for char in chunk:
-                    yield char
-
-        self.stream = char_stream(stream)
-        self.__buf: str = ""
-        self.__eof = False
-
-    def peek(self):
-        c = self.__buf[0] if len(self.__buf) > 0 else None
-        return c
-
-    async def __ensure_length(self, n: int):
-        while (not self.__eof) and len(self.__buf) < n:
-            try:
-                self.__buf += await self.stream.__anext__()
-            except StopAsyncIteration:
-                self.__eof = True
-
-    async def __check_unordered_list_label(self) -> bool:
-        if self.__eof:
-            return False
-        await self.__ensure_length(2)
-        buf = self.__buf
-        if len(buf) < 2:
-            return False
-        if buf[0] in ["-", "+", "*"] and buf[1] == " ":
-            return True
-        return False
-
-    async def __check_ordered_list_label(self) -> bool:
-        if self.__eof:
-            return False
-        await self.__ensure_length(5)
-        buf = self.__buf
-        # \d+\.
-        if len(buf) == 0:
-            return False
-        if not buf[0].isnumeric():
-            return False
-        has_dot = False
-        for i in range(1, 5):
-            if i >= len(buf):
-                return False
-            c = buf[i]
-            if c == ".":
-                if has_dot:
-                    return False
-                has_dot = True
-                continue
-            if c == " ":
-                if has_dot:
-                    return True
-                return False
-            if c.isnumeric():
-                continue
-        return False
-
-    async def check(self, s: str):
-        if len(s) == 0:
-            return True
-        await self.__ensure_length(len(s))
-        if len(self.__buf) < len(s):
-            return False
-        return self.__buf[0 : len(s)] == s
-
-    async def check_non_paragraph_block_start(self):
-        await self.__ensure_length(3)
-        buf = self.__buf[:3] if len(self.__buf) >= 3 else self.__buf
-        if buf.startswith("```"):
-            return True
-        if buf.startswith("---"):
-            return True
-        if buf.startswith("> "):
-            return True
-        if await self.__check_ordered_list_label():
-            return True
-        if await self.__check_unordered_list_label():
-            return True
-        return False
-
-    async def next(self):
-        c = self.__buf[0] if len(self.__buf) > 0 else None
-        self.__buf = self.__buf[1:] if len(self.__buf) > 0 else ""
-        if c is None:
-            return None
-        if not self.__eof:
-            try:
-                self.__buf += await self.stream.__anext__()
-            except StopAsyncIteration:
-                self.__eof = True
-        return c
-
-    def print(self, s: str):
-        print(s, end="", flush=True)
-
-    async def parse_single_line_text(
-        self,
-        outer_is_italic: bool = False,
-        outer_is_bold: bool = False,
-        outer_is_dim: bool = False,
-    ):
-        styles: list[Literal["code", "bold", "italic", "strike"]] = []
-
-        def find(s: Literal["code", "bold", "italic", "strike"]):
-            for i in range(len(styles) - 1, -1, -1):
-                if styles[i] == s:
-                    return i
-            return None
-
-        def find_italic_first():
-            for i in range(len(styles) - 1, -1, -1):
-                if styles[i] == "bold":
-                    return False
-                if styles[i] == "italic":
-                    return True
-            return False
-
-        # Remove leading spaces
-        while self.peek() in [" ", "\t"]:
-            await self.next()
-
-        while True:
-            not_code = find("code") is None
-            c = self.peek()
-            if c == "\n" or c is None:
-                await self.next()
-                self.print("\x1b[0m\n")  # Reset all and newline
-                return
-            match c:
-                case "`":
-                    await self.next()
-                    if (i := find("code")) is not None:
-                        self.print(c)
-                        if not outer_is_dim:
-                            self.print("\x1b[22m")
-                            if find("bold") is not None or outer_is_bold:
-                                self.print("\x1b[1m")
-                        styles = styles[:i]
-                    else:
-                        self.print("\x1b[2m")
-                        styles.append("code")
-                        self.print(c)
-                # Bold
-                case "*" if (
-                    not_code and await self.check("**") and not find_italic_first()
-                ):
-                    await self.next()
-                    await self.next()
-                    # print(">", styles, find("bold"))
-                    if (i := find("bold")) is not None:
-                        self.print(c)
-                        self.print(c)
-                        if not outer_is_bold:
-                            self.print("\x1b[22m")
-                        styles = styles[:i]
-                    else:
-                        self.print("\x1b[1m")
-                        styles.append("bold")
-                        self.print(c)
-                        self.print(c)
-                case "_" if (
-                    not_code and await self.check("__") and not find_italic_first()
-                ):
-                    await self.next()
-                    await self.next()
-                    if (i := find("bold")) is not None:
-                        self.print(c)
-                        self.print(c)
-                        if not outer_is_bold:
-                            self.print("\x1b[22m")
-                        styles = styles[:i]
-                    else:
-                        self.print("\x1b[1m")
-                        styles.append("bold")
-                        self.print(c)
-                        self.print(c)
-                # Italic
-                case "*" | "_" if (
-                    not_code
-                    and not await self.check("* ")
-                    and not await self.check("_ ")
-                ):
-                    await self.next()
-                    if (i := find("italic")) is not None:
-                        self.print(c)
-                        if not outer_is_italic:
-                            self.print("\x1b[23m")
-                        styles = styles[:i]
-                        # print(styles, await self.check("**"))
-                    else:
-                        self.print("\x1b[3m")
-                        styles.append("italic")
-                        self.print(c)
-                # Strike through
-                case "~" if not_code and await self.check("~~"):
-                    await self.next()
-                    await self.next()
-                    if (i := find("strike")) is not None:
-                        self.print("~~")
-                        self.print("\x1b[29m")
-                        styles = styles[:i]
-                    else:
-                        self.print("\x1b[9m")
-                        styles.append("strike")
-                        self.print("~~")
-                case _:
-                    self.print(c)
-                    await self.next()
-
-    async def parse_heading(self):
-        hashes = 0
-        while True:
-            c = await self.next()
-            if c == "#":
-                hashes += 1
-            else:
-                break
-        # Start control
-        match hashes:
-            case 1:
-                self.print("\x1b[45;1;2m")  # Magenta background, bold, dim
-                self.print("#" * hashes)
-                self.print(" \x1b[22;1m")  # Reset dim
-                await self.parse_single_line_text(outer_is_bold=True)
-            case 2:
-                self.print("\x1b[35;1;2;4m")  # Magenta foreground, bold, dim, underline
-                self.print("#" * hashes)
-                self.print(" \x1b[22m\x1b[1m")  # Reset dim
-                await self.parse_single_line_text(outer_is_bold=True)
-            case 3:
-                self.print("\x1b[35;1;2m")  # Magenta foreground, bold, dim
-                self.print("#" * hashes)
-                self.print(" \x1b[22m\x1b[1m")  # Reset dim
-                await self.parse_single_line_text(outer_is_bold=True)
-            case 4:
-                self.print("\x1b[35;2;3m")  # Magenta foreground, dim, italic
-                self.print("#" * hashes)
-                self.print(" \x1b[22m")  # Reset dim
-                await self.parse_single_line_text(outer_is_italic=True)
-            case _:
-                self.print("\x1b[2m")  # dim
-                self.print("#" * hashes)
-                self.print(" \x1b[22m")  # Reset dim
-                await self.parse_single_line_text()
-        # Stream title
-
-    async def parse_paragraph(self):
-        while True:
-            await self.parse_single_line_text()
-            if self.peek() != "\n" and not await self.check_non_paragraph_block_start():
-                await self.next()
-                break
-            else:
-                break
-
-    async def parse_multiline_code(self):
-        # dim
-        self.print("\x1b[2m")
-        self.print("```")
-        await self.next()
-        await self.next()
-        await self.next()
-        while not await self.check("\n```"):
-            c = await self.next()
-            if c is None:
-                self.print("\n")
-                return
-            self.print(c)
-        self.print("\n```\n")
-        await self.next()
-        await self.next()
-        await self.next()
-        await self.next()
-
-    async def parse_list(self, ordered: bool):
-        indents = [0]
-        counter = [1]
-        # first item
-        if ordered:
-            self.print("1. ")
-            await self.next()
-        else:
-            self.print("• ")
-        await self.next()
-        await self.parse_single_line_text()
-        while True:
-            indent = 0
-            while self.peek() in [" ", "\t", "\n"]:
-                if self.peek() in [" ", "\t"]:
-                    indent += 1
-                if self.peek() == "\n":
-                    indent = 0
-                await self.next()
-            if self.peek() is None:
-                return
-            if ordered and not await self.__check_ordered_list_label():
-                return
-            if not ordered and not await self.__check_unordered_list_label():
-                return
-            if not ordered:
-                await self.next()
-            else:
-                while self.peek() is not None and self.peek() != ".":
-                    await self.next()
-                await self.next()
-
-            depth = None
-            for i in range(len(indents) - 1):
-                if indents[i] <= indent and indents[i + 1] > indent:
-                    depth = i
-                    break
-            if depth is None and indents[-1] + 2 <= indent:
-                # indent one more level
-                indents.append(indent)
-                depth = len(indents) - 1
-                counter.append(1)
-            elif depth is None:
-                # same as last level
-                depth = len(indents) - 1
-                counter[depth] += 1
-            else:
-                # dedent
-                indents = indents[: depth + 1]
-                counter = counter[: depth + 1]
-                counter[depth] += 1
-            if not ordered:
-                self.print("  " * depth + "• ")
-            else:
-                self.print("   " * depth + str(counter[depth]) + ". ")
-            await self.parse_single_line_text()
-
-    async def parse_blockquote(self):
-        while True:
-            while self.peek() in [" ", "\t"]:
-                await self.next()
-            if self.peek() != ">":
-                break
-            await self.next()
-            self.print("\x1b[1;2m|\x1b[22;2m ")
-            await self.parse_single_line_text(outer_is_dim=True)
-
-    async def parse_doc(self):
-        self.__buf = await self.stream.__anext__()
-        start = True
-        while True:
-            # Remove leading spaces and empty lines
-            indent = 0
-            while self.peek() in [" ", "\t", "\n"]:
-                if self.peek() in [" ", "\t"]:
-                    indent += 1
-                if self.peek() == "\n":
-                    indent = 0
-                await self.next()
-            if self.peek() is None:
-                break
-            if not start:
-                self.print("\n")
-            start = False
-            match c := self.peek():
-                case None:
-                    break
-                # Heading
-                case "#":
-                    await self.parse_heading()
-                # Code
-                case "`" if await self.check("```"):
-                    await self.parse_multiline_code()
-                # Separator
-                case _ if await self.check("---"):
-                    await self.next()
-                    await self.next()
-                    await self.next()
-                    width = min(os.get_terminal_size().columns, 80)
-                    self.print("\x1b[2m" + "─" * width + "\x1b[22m\n")
-                # Unordered list
-                case _ if await self.__check_unordered_list_label():
-                    await self.parse_list(False)
-                # Ordered list
-                case _ if await self.__check_ordered_list_label():
-                    await self.parse_list(True)
-                # Blockquote
-                case ">":
-                    await self.parse_blockquote()
-                # Normal paragraph
-                case _:
-                    await self.parse_paragraph()
-            self.print("\x1b[0m\x1b[0m\x1b[0m")  # Reset all
-        self.print("\x1b[0m")  # Reset all
-
-    def __await__(self):
-        return self.parse_doc().__await__()
-
-
-async def stream_md(stream: AsyncGenerator[str, None]):
-    mp = MarkdowmPrinter(stream)
-    await mp.parse_doc()