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

autosh/md/state.py

@@ -0,0 +1,136 @@
+from dataclasses import dataclass
+from contextlib import contextmanager
+from enum import Enum
+
+HIGHLIGHT_COLOR_START = "35"
+HIGHLIGHT_COLOR_END = "0"
+ESC = "\x1b"
+
+
+class Color(Enum):
+    BLACK = 30, 40
+    RED = 31, 41
+    GREEN = 32, 42
+    YELLOW = 33, 43
+    BLUE = 34, 44
+    MAGENTA = 35, 45
+    CYAN = 36, 46
+    WHITE = 37, 47
+
+    BRIGHT_BLACK = 90, 100
+    BRIGHT_RED = 91, 101
+    BRIGHT_GREEN = 92, 102
+    BRIGHT_YELLOW = 93, 103
+    BRIGHT_BLUE = 94, 104
+    BRIGHT_MAGENTA = 95, 105
+    BRIGHT_CYAN = 96, 106
+    BRIGHT_WHITE = 97, 107
+
+    def __init__(self, foreground: int, background: int):
+        self.foreground = foreground
+        self.background = background
+
+
+@dataclass
+class State:
+    is_bold: bool = False
+    is_dim: bool = False
+    is_italic: bool = False
+    is_underline: bool = False
+    is_strike: bool = False
+    foreground_color: Color | None = None
+    background_color: Color | None = None
+
+    def emit(self, text: str):
+        print(text, end="", flush=True)
+
+    def _enter_scope(
+        self,
+        bold: bool | None = None,
+        dim: bool | None = None,
+        italic: bool | None = None,
+        underline: bool | None = None,
+        strike: bool | None = None,
+        color: Color | None = None,
+        bg: Color | None = None,
+    ) -> "State":
+        old_state = State(
+            is_bold=self.is_bold,
+            is_dim=self.is_dim,
+            is_italic=self.is_italic,
+            is_underline=self.is_underline,
+            is_strike=self.is_strike,
+            foreground_color=self.foreground_color,
+            background_color=self.background_color,
+        )
+        if bold is not None:
+            self.is_bold = bold
+        if dim is not None:
+            self.is_dim = dim
+        if italic is not None:
+            self.is_italic = italic
+        if underline is not None:
+            self.is_underline = underline
+        if strike is not None:
+            self.is_strike = strike
+        if color is not None:
+            self.foreground_color = color
+        if bg is not None:
+            self.background_color = bg
+        self.__apply_all()
+        return old_state
+
+    def _exit_scope(self, old_state: "State"):
+        self.is_bold = old_state.is_bold
+        self.is_dim = old_state.is_dim
+        self.is_italic = old_state.is_italic
+        self.is_underline = old_state.is_underline
+        self.is_strike = old_state.is_strike
+        self.foreground_color = old_state.foreground_color
+        self.background_color = old_state.background_color
+        self.__apply_all()
+
+    @contextmanager
+    def style(
+        self,
+        bold: bool | None = None,
+        dim: bool | None = None,
+        italic: bool | None = None,
+        underline: bool | None = None,
+        strike: bool | None = None,
+        color: Color | None = None,
+        bg: Color | None = None,
+    ):
+        old_state = self._enter_scope(
+            bold=bold,
+            dim=dim,
+            italic=italic,
+            underline=underline,
+            strike=strike,
+            color=color,
+            bg=bg,
+        )
+        yield
+        self._exit_scope(old_state)
+
+    def __apply_all(self):
+        self.emit(f"{ESC}[0m")
+        codes = []
+        if self.is_bold:
+            codes.append(1)
+        if self.is_dim:
+            codes.append(2)
+        if self.is_italic:
+            codes.append(3)
+        if self.is_underline:
+            codes.append(4)
+        if self.is_strike:
+            codes.append(9)
+        if self.foreground_color:
+            codes.append(self.foreground_color.foreground)
+        if self.background_color:
+            codes.append(self.background_color.background)
+
+        codes = ";".join(map(str, codes))
+        if len(codes) > 0:
+            self.emit(f"{ESC}[{codes}m")

autosh/md/stream.py

@@ -0,0 +1,107 @@
+from typing import AsyncGenerator
+
+
+class TextStream:
+    def __init__(self, gen: AsyncGenerator[str, None]):
+        self.__stream = gen
+        self.__buf: str = ""
+        self.__eof = False
+
+    async def init(self):
+        try:
+            self.__buf = await anext(self.__stream)
+        except StopAsyncIteration:
+            self.__eof = True
+
+    async def __ensure_length(self, n: int):
+        while (not self.__eof) and len(self.__buf) < n:
+            try:
+                self.__buf += await anext(self.__stream)
+            except StopAsyncIteration:
+                self.__eof = True
+
+    def peek(self):
+        c = self.__buf[0] if len(self.__buf) > 0 else None
+        return c
+
+    async def check(self, s: str, eof: bool | None = None) -> bool:
+        if len(s) == 0:
+            return True
+        await self.__ensure_length(len(s) + 1)
+        if len(self.__buf) < len(s):
+            return False
+        matched = self.__buf[0 : len(s)] == s
+        if matched:
+            if eof is not None:
+                if eof:
+                    # return false if there is more data
+                    if len(self.__buf) > len(s):
+                        return False
+                else:
+                    # return false if there is no more data
+                    if len(self.__buf) == len(s):
+                        return False
+        return matched
+
+    async def consume(self, n: int = 1):
+        await self.__ensure_length(n)
+        if len(self.__buf) < n:
+            raise ValueError("Not enough data to consume")
+        s = self.__buf[:n]
+        self.__buf = self.__buf[n:]
+        await self.__ensure_length(1)
+        return s
+
+    async def 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 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 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.ordered_list_label():
+            return True
+        if await self.unordered_list_label():
+            return True
+        return False

autosh/plugins/__init__.py

@@ -29,8 +29,8 @@ def confirm(message: str):
 
 
 def cmd_preview_panel(title: str, content: RenderableType, short: str | None = None):
-    if CLI_OPTIONS.quiet and not CLI_OPTIONS.yes:
-        if short:
+    if CLI_OPTIONS.quiet:
+        if short and not CLI_OPTIONS.yes:
             rich.print(f"[magenta]{short}[/magenta]\n")
         return
     panel = Panel.fit(content, title=f"[magenta]{title}[/magenta]", title_align="left")

autosh/plugins/cli.py

@@ -82,6 +82,48 @@ class CLIPlugin(Plugin):
             "args": CLI_OPTIONS.args,
         }
 
+    @tool
+    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
+    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
+    def update_env(
+        self,
+        key: Annotated[str, "The environment variable to set"],
+        value: Annotated[
+            str | None,
+            "The value to set the environment variable to, or None to delete it",
+        ],
+    ):
+        """
+        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
     def read(
         self,

autosh/session.py

@@ -1,3 +1,4 @@
+import asyncio
 from pathlib import Path
 import sys
 from agentia import Agent
@@ -10,6 +11,7 @@ from autosh.md import stream_md
 from .plugins import create_plugins
 import rich
 import platform
+from rich.prompt import Prompt
 
 
 INSTRUCTIONS = f"""
@@ -86,11 +88,11 @@ class Session:
     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(
-            content=f"PROGRAM NAME: {cmd}\n\nCOMMAND LINE ARGS: {args}",
+            content=f"PROGRAM NAME: {cmd}\n\nCOMMAND LINE ARGS: {args}\n\nCWD: {str(Path.cwd())}",
             role="user",
         )
 
@@ -108,19 +110,37 @@ class Session:
         ):
             await self._print_help_and_exit(prompt)
         # Execute the prompt
+        loading = self.__create_loading_indicator()
         CLI_OPTIONS.prompt = prompt
         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",
+                )
+            )
+        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)
         async for stream in completion:
-            if await self.__render_streamed_markdown(stream):
+            if not loading:
+                loading = self.__create_loading_indicator()
+            if await self.__render_streamed_markdown(stream, loading=loading):
                 print()
+            loading = None
 
     async def exec_from_stdin(self):
         if sys.stdin.isatty():
@@ -141,19 +161,60 @@ class Session:
         console = rich.console.Console()
         while True:
             try:
-                prompt = console.input("[bold]>[/bold] ").strip()
+                prompt = console.input("[bold blue]>[/bold blue] ").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 await self.__render_streamed_markdown(stream):
+                    if not loading:
+                        loading = self.__create_loading_indicator()
+                    if await self.__render_streamed_markdown(stream, loading=loading):
                         print()
+                    loading = None
             except KeyboardInterrupt:
                 break
 
-    async def __render_streamed_markdown(self, stream: MessageStream):
+    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
+
+    async def __render_streamed_markdown(
+        self, stream: MessageStream, loading: asyncio.Task[None] | None = None
+    ):
         if sys.stdout.isatty():
             # buffer first few chars so we don't need to launch glow if there is no output
             chunks = aiter(stream)
@@ -163,8 +224,14 @@ class Session:
                     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": ""}
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autosh
-Version: 0.0.1
+Version: 0.0.3
 Summary: Add your description here
 License-File: LICENSE
 Requires-Python: >=3.13
@@ -31,7 +31,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 +74,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.3.dist-info/RECORD

@@ -0,0 +1,22 @@
+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=ov8lBOUb7GOa3-WBW00gqKaYrTG3NFYQgIXP3-6Eki4,4975
+autosh/session.py,sha256=pU3AAqI3vEEFdtsXK_1ZV6uXzjkzIG8q3Yo01K-Q6dw,9615
+autosh/md/__init__.py,sha256=0SK4rkynUwR77E8IU-ORJmWou_aTxC6xzQQo-IfAsaM,213
+autosh/md/inline_text.py,sha256=I8CaxksvOpTr1mlUtnk50TVVgF9CLnLsth2ux0cdTM4,6422
+autosh/md/printer.py,sha256=qD3AcGosnPMRAf-KiRw1PUixtP-kS5xFIPFjzGLLT0g,11099
+autosh/md/state.py,sha256=OEp0kUb63HrAN5BPcPx9mxWogofayumH9GZGqLdOoEA,3792
+autosh/md/stream.py,sha256=zaVJR6Kog6EZcuVaGszwgywpysHcn8fRZ0KItmKRhiA,3224
+autosh/plugins/__init__.py,sha256=NXq27wvS97NEH6hTtWRyp-ut0BE9fq5QyKBjXOj39zY,2487
+autosh/plugins/calc.py,sha256=qo0EajIpNPv9PtLNLygyEjVaxo1F6_S62kmoJZq5oLM,581
+autosh/plugins/cli.py,sha256=D6S_QHPmjBBB9gwgXeJrwxUs3u0TNty_tHVICbEPGbs,8522
+autosh/plugins/clock.py,sha256=GGi0HAG6f6-FP1qqGoyCcUj11q_VnkaGArumsMk0CkY,542
+autosh/plugins/code.py,sha256=0JwFzq6ejgbisCqBm_RG1r1WEVNou64ue-siVIpvZqs,2291
+autosh/plugins/search.py,sha256=1d3Gqq6uXu0ntTBpw44Ab_haAySvZLMj3e2MQd3DHO0,2736
+autosh/plugins/web.py,sha256=lmD2JnsqVI1qKgSFrk39851jCZoPyPRaVvHeEFYXylA,2597
+autosh-0.0.3.dist-info/METADATA,sha256=M2wVPjOWoiCXWbYzs216oQ4eUSE_s5-b67-qTufmnRE,1897
+autosh-0.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+autosh-0.0.3.dist-info/entry_points.txt,sha256=BV7bzUnxG6Z5InEkrfajGCxjooYORC5tZDDZctOPenQ,67
+autosh-0.0.3.dist-info/licenses/LICENSE,sha256=BnLDJsIJe-Dm18unR9DOoSv7QOfAz6LeIQc1yHAjxp0,1066
+autosh-0.0.3.dist-info/RECORD,,