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

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/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/main.py

@@ -8,7 +8,7 @@ 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
 
@@ -149,14 +149,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/md/__init__.py

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,214 @@
+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

autosh/md/printer.py

@@ -0,0 +1,301 @@
+import os
+from typing import AsyncGenerator, Literal
+import unicodedata
+
+from autosh.md.state import Color, State
+from autosh.md.stream import TextStream
+
+
+class StreamedMarkdownPrinter:
+    def __init__(self, gen: AsyncGenerator[str, None]):
+        self.stream = TextStream(gen)
+        self.state = State()
+
+    def emit(self, s: str):
+        self.state.emit(s)
+
+    def peek(self):
+        return self.stream.peek()
+
+    async def consume(self, n: int = 1):
+        return await self.stream.consume(n)
+
+    async def check(self, s: str, eof: bool | None = None) -> bool:
+        return await self.stream.check(s, eof)
+
+    async def parse_inline(self, consume_trailing_newline: bool = True):
+        from autosh.md.inline_text import InlineTextPrinter
+
+        itp = InlineTextPrinter(self)
+        await itp.parse_inline(consume_trailing_newline)
+
+    async def parse_heading(self):
+        hashes = 0
+        while True:
+            c = await self.consume()
+            if c == "#":
+                hashes += 1
+            else:
+                break
+        match hashes:
+            case 1:
+                with self.state.style(bold=True, bg=Color.MAGENTA):
+                    with self.state.style(dim=True):
+                        self.emit("#" * hashes + " ")
+                    await self.parse_inline(consume_trailing_newline=False)
+            case 2:
+                with self.state.style(bold=True, underline=True, color=Color.MAGENTA):
+                    with self.state.style(dim=True):
+                        self.emit("#" * hashes + " ")
+                    await self.parse_inline(consume_trailing_newline=False)
+            case 3:
+                with self.state.style(bold=True, color=Color.MAGENTA):
+                    with self.state.style(dim=True):
+                        self.emit("#" * hashes + " ")
+                    await self.parse_inline(consume_trailing_newline=False)
+            case 4:
+                with self.state.style(bold=True, italic=True, color=Color.MAGENTA):
+                    with self.state.style(dim=True):
+                        self.emit("#" * hashes + " ")
+                    await self.parse_inline(consume_trailing_newline=False)
+            case _:
+                with self.state.style(bold=True):
+                    with self.state.style(dim=True):
+                        self.emit("#" * hashes + " ")
+                    await self.parse_inline(consume_trailing_newline=False)
+        await self.consume()  # consume the newline
+        self.emit("\n")
+
+    async def parse_paragraph(self):
+        while True:
+            await self.parse_inline()
+            if (
+                self.peek() != "\n"
+                and not await self.stream.non_paragraph_block_start()
+            ):
+                if self.peek() == "\n":
+                    await self.consume()
+                break
+            else:
+                break
+
+    async def parse_multiline_code(self):
+        with self.state.style(dim=True):
+            self.emit("```")
+            await self.consume(3)
+            while not await self.check("\n```"):
+                c = await self.consume()
+                if c is None:
+                    self.emit("\n")
+                    return
+                self.emit(c)
+            self.emit("\n```\n")
+            await self.consume(4)
+
+    async def parse_list(self, ordered: bool):
+        indents = [0]
+        counter = [1]
+        # first item
+        if ordered:
+            self.emit("1. ")
+            await self.consume()
+        else:
+            self.emit("• ")
+        await self.consume()
+        await self.parse_inline()
+        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.consume()
+            if self.peek() is None:
+                return
+            if ordered and not await self.stream.ordered_list_label():
+                return
+            if not ordered and not await self.stream.unordered_list_label():
+                return
+            if not ordered:
+                await self.consume()
+            else:
+                while self.peek() is not None and self.peek() != ".":
+                    await self.consume()
+                await self.consume()
+
+            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.emit("  " * depth + "• ")
+            else:
+                self.emit("   " * depth + str(counter[depth]) + ". ")
+            await self.parse_inline()
+
+    async def parse_blockquote(self):
+        from autosh.md.inline_text import InlineTextPrinter
+
+        while True:
+            while self.peek() in [" ", "\t"]:
+                await self.consume()
+            if self.peek() != ">":
+                break
+            await self.consume()
+            with self.state.style(bold=True, dim=True):
+                self.emit(">")
+            with self.state.style(dim=True):
+                itp = InlineTextPrinter(self)
+                await itp.parse_inline_unformatted()
+            if self.peek() == "\n":
+                self.emit("\n")
+                await self.consume()
+
+    async def parse_table(self):
+        def str_size(s: str) -> int:
+            size = 0
+            for c in s:
+                match unicodedata.east_asian_width(c):
+                    case "F" | "W":
+                        size += 2
+                    case _:
+                        size += 1
+            return size
+
+        rows: list[list[str]] = []
+        while True:
+            if self.peek() != "|":
+                break
+            s = "|"
+            await self.consume()
+            while self.peek() not in ["\n", None]:
+                s += self.peek() or ""
+                await self.consume()
+            if self.peek() == "\n":
+                await self.consume()
+            s = s.strip("|")
+            rows.append([c.strip() for c in s.split("|")])
+        # not enough rows
+        if len(rows) < 2:
+            self.emit("| " + " | ".join(rows[0]) + " |\n")
+        # do some simple formatting
+        cols = len(rows[0])
+        col_widths = [0] * cols
+        aligns: list[Literal["left", "right", "center"]] = ["left"] * cols
+        for i, row in enumerate(rows):
+            if i == 1:
+                # check for alignment
+                for j, c in enumerate(row):
+                    if c.startswith(":") and c.endswith(":"):
+                        aligns[j] = "center"
+                    elif c.startswith(":"):
+                        aligns[j] = "left"
+                    elif c.endswith(":"):
+                        aligns[j] = "right"
+                continue
+            for j, c in enumerate(row):
+                col_widths[j] = max(col_widths[j], str_size(c))
+        # print top border
+        with self.state.style(dim=True):
+            for j, c in enumerate(rows[0]):
+                self.emit("┌" if j == 0 else "┬")
+                self.emit("─" * (col_widths[j] + 2))
+            self.emit("┐\n")
+        # print the table
+        for i, row in enumerate(rows):
+            for j, c in enumerate(row):
+                with self.state.style(dim=True):
+                    self.emit("│" if i != 1 else ("├" if j == 0 else "┼"))
+                if i == 1:
+                    text = "─" * (col_widths[j] + 2)
+                else:
+                    s = str_size(c)
+                    align = aligns[j] if i != 0 else "center"
+                    match align:
+                        case "left":
+                            text = c + " " * (col_widths[j] - s)
+                        case "right":
+                            text = " " * (col_widths[j] - s) + c
+                        case "center":
+                            padding = col_widths[j] - s
+                            text = " " * (padding // 2) + c
+                            text += " " * (padding - padding // 2)
+                    text = f" {text} "
+                with self.state.style(dim=i == 1):
+                    self.emit(text)
+            with self.state.style(dim=True):
+                self.emit("│\n" if i != 1 else "┤\n")
+        # print bottom border
+        with self.state.style(dim=True):
+            for j, c in enumerate(rows[0]):
+                self.emit("└" if j == 0 else "┴")
+                self.emit("─" * (col_widths[j] + 2))
+            self.emit("┘\n")
+
+    async def parse_doc(self):
+        await self.stream.init()
+        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.consume()
+            if self.peek() is None:
+                break
+            if not start:
+                self.emit("\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.consume(3)
+                    width = min(os.get_terminal_size().columns, 80)
+                    with self.state.style(dim=True):
+                        self.emit("─" * width)
+                # Unordered list
+                case _ if await self.stream.unordered_list_label():
+                    await self.parse_list(False)
+                # Ordered list
+                case _ if await self.stream.ordered_list_label():
+                    await self.parse_list(True)
+                # Blockquote
+                case ">":
+                    await self.parse_blockquote()
+                # Table
+                case "|":
+                    await self.parse_table()
+                # Normal paragraph
+                case _:
+                    await self.parse_paragraph()
+        self.emit("\x1b[0m")  # Reset all
+
+    def __await__(self):
+        return self.parse_doc().__await__()

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/session.py

@@ -88,7 +88,7 @@ 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(
@@ -116,7 +116,21 @@ class Session:
         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",
                 )
             )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autosh
-Version: 0.0.2
+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,,

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()

autosh-0.0.2.dist-info/RECORD

@@ -1,17 +0,0 @@
-autosh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autosh/config.py,sha256=KPuXr_MF5Pbdn5pCCgq9AcyDSDlOnCJ4vBetKmhodic,2348
-autosh/main.py,sha256=myRolKqfHyQEgujqmUndDSm9J0C21w3zqA9-SYNX1kY,4961
-autosh/md.py,sha256=qXg5ZFVUwek3rUXb-oEti1soRRbIq8EbDq88lEYRoO4,14267
-autosh/session.py,sha256=kCaD-7tZpozz56sWlMGp0njqwYRf3cZOau1ulWRKJEI,8885
-autosh/plugins/__init__.py,sha256=yOTobuyYFpUWl5BCowGzJG8rZX2Whlagail_QyHVlo4,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.2.dist-info/METADATA,sha256=y9pbK71nuueA11LCv6AsR24MSsnqNut-7-zljpOC5_Y,1720
-autosh-0.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-autosh-0.0.2.dist-info/entry_points.txt,sha256=BV7bzUnxG6Z5InEkrfajGCxjooYORC5tZDDZctOPenQ,67
-autosh-0.0.2.dist-info/licenses/LICENSE,sha256=BnLDJsIJe-Dm18unR9DOoSv7QOfAz6LeIQc1yHAjxp0,1066
-autosh-0.0.2.dist-info/RECORD,,