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

autosh/session.py

@@ -0,0 +1,246 @@
+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.plugins import PluginInitError
+
+from autosh.config import CLI_OPTIONS, CONFIG
+from autosh.md import stream_md
+from .plugins import create_plugins
+import rich
+import platform
+from rich.prompt import Prompt
+
+
+INSTRUCTIONS = f"""
+You are now acting as a AI-powered terminal shell, operating on the user's real computer.
+
+The user will send you questions, prompts, or descriptions of the tasks.
+You should take the prompts, and either answer the user's questions, or fullfill the tasks.
+When necessary, generate the system commands, and execute them to fullfill the tasks.
+
+Don't do anything else that the user doesn't ask for, or not relevant to the tasks.
+The system command output are displayed to the user directly, so don't repeat the output in your response.
+Just respond with the text if you want to simply print something to the terminal, no need to use `echo` or `print`.
+
+If the prompt mentions it requires some arguments/options/flags, look for then in the command line arguments list and use them to complete the tasks.
+
+You may use markdown to format your responses.
+
+YOUR HOST OS INFO: {platform.platform()}
+"""
+
+
+class Session:
+    def __init__(self):
+        self.agent = Agent(
+            model=CONFIG.model if not CLI_OPTIONS.think else CONFIG.think_model,
+            api_key=CONFIG.api_key,
+            instructions=INSTRUCTIONS,
+            tools=create_plugins(),
+        )
+
+    async def init(self):
+        try:
+            await self.agent.init()
+        except PluginInitError as e:
+            rich.print(
+                f"[bold red]Error:[/bold red] [red]Plugin [bold italic]{e.plugin}[/bold italic] failed to initialize: {str(e.original)}[/red]"
+            )
+            sys.exit(1)
+
+    def _exit_with_error(self, msg: str):
+        rich.print(f"[bold red]Error:[/bold red] [red]{msg}")
+        sys.exit(1)
+
+    async def _print_help_and_exit(self, prompt: str):
+        agent = Agent(
+            model="openai/gpt-4o-mini",
+            api_key=CONFIG.api_key,
+            instructions=f"""
+            This is a CLI program logic written in natural language.
+            Please help me to generate the CLI --help message for this CLI app.
+            Just output the help message, no need to add any other text.
+
+            RESPONSE FORMAT:
+
+            **Usage:** ...
+
+            The description of the program.
+
+            **Options:**
+
+                * -f, --foo     Description of foo
+                * -b, --bar     Description of bar
+                * --baz         Description of baz
+                ...
+                * -h, --help     Show this message and exit.
+            """,
+        )
+        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):
+        args = str(CLI_OPTIONS.args)
+        if not CLI_OPTIONS.script:
+            cmd = "PROMPT"
+        else:
+            cmd = CLI_OPTIONS.script.name
+        return UserMessage(
+            content=f"PROGRAM NAME: {cmd}\n\nCOMMAND LINE ARGS: {args}\n\nCWD: {str(Path.cwd())}",
+            role="user",
+        )
+
+    async def exec_prompt(self, prompt: str):
+        # Clean up the prompt
+        if prompt is not None:
+            prompt = prompt.strip()
+            if not prompt:
+                sys.exit(0)
+        # skip shebang line
+        if prompt.startswith("#!"):
+            prompt = prompt.split("\n", 1)[1]
+        if len(CLI_OPTIONS.args) == 1 and (
+            CLI_OPTIONS.args[0] == "-h" or CLI_OPTIONS.args[0] == "--help"
+        ):
+            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.",
+                    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
+
+    async def exec_from_stdin(self):
+        if sys.stdin.isatty():
+            self._exit_with_error("No prompt is piped to stdin.")
+        prompt = sys.stdin.read()
+        if not prompt:
+            sys.exit(0)
+        CLI_OPTIONS.stdin_is_script = True
+        await self.exec_prompt(prompt)
+
+    async def exec_script(self, script: Path):
+        CLI_OPTIONS.script = script
+        with open(script, "r") as f:
+            prompt = f.read()
+        await self.exec_prompt(prompt)
+
+    async def run_repl(self):
+        console = rich.console.Console()
+        while True:
+            try:
+                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 not loading:
+                        loading = self.__create_loading_indicator()
+                    if await self.__render_streamed_markdown(stream, loading=loading):
+                        print()
+                    loading = None
+            except KeyboardInterrupt:
+                break
+
+    def __create_loading_indicator(self, newline: bool = False):
+        return (
+            asyncio.create_task(self.__loading(newline))
+            if sys.stdout.isatty()
+            else None
+        )
+
+    async def __loading(self, newline: bool = False):
+        chars = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+        char_width = 1
+        msg = "Loading..."
+        count = 0
+        print("\x1b[2m", end="", flush=True)
+        while True:
+            try:
+                print(chars[count], end="", flush=True)
+                print(" " + msg, end="", flush=True)
+                count += 1
+                await asyncio.sleep(0.1)
+                length = char_width + len(msg) + 1
+                print("\b" * length, end="", flush=True)
+                print(" " * length, end="", flush=True)
+                print("\b" * length, end="", flush=True)
+                if count == len(chars):
+                    count = 0
+            except asyncio.CancelledError:
+                length = char_width + len(msg) + 1
+                print("\b" * length, end="", flush=True)
+                print(" " * length, end="", flush=True)
+                print("\b" * length, end="", flush=True)
+                print("\x1b[0m", end="", flush=True)
+                if newline:
+                    print()
+                break
+
+    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)
+            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())
+            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.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: autosh
+Version: 0.0.2
+Summary: Add your description here
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: agentia>=0.0.5
+Requires-Dist: asyncio>=3.4.3
+Requires-Dist: markdownify>=1.1.0
+Requires-Dist: pydantic>=2.11.3
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: rich>=14.0.0
+Requires-Dist: tavily-python>=0.5.4
+Requires-Dist: typer>=0.12.5
+Requires-Dist: tzlocal>=5.3.1
+Description-Content-Type: text/markdown
+
+# `autosh` - The AI-powered, noob-friendly interactive shell
+
+# Getting Started
+
+## Install
+
+```bash
+uv tool install autosh
+```
+
+## Usage
+
+As an interactive shell: `ash` (alternatively, `autosh`)
+
+Execute a single prompt: `ash "list current directory"`
+
+Process piped data: `cat README.md | ash "summarise"`
+
+## Scripting
+
+Write AI-powered shell scripts in Markdown using natural language!
+
+Example script ([simple.a.md](examples/simple.a.md)):
+
+```markdown
+#!/usr/bin/env ash
+
+# This is a simple file manipulation script
+
+First, please display a welcome message:)
+
+Write "Hello, world" to _test.log
+```
+
+* Run the script: `ash simple.a.md` or `chmod +x simple.a.md && simple.a.md`
+* Auto generate help messages:
+
+    ```console
+    $ ash simple.a.md -h
+
+    Usage: simple.a.md [OPTIONS]
+
+    This is a simple file manipulation script that writes "Hello, world" to a log file named _x.log.
+
+    Options:
+
+    • -h, --help     Show this message and exit.
+    ```
+
+## Plugins
+
+`autosh` is equipped with several plugins to expand its potential:
+
+* `ash "Create a directory "my-news", list the latest news, for each news, put the summary in a separate markdown file in this directory"`
+
+# TODO
+
+- [ ] Image generation
+- [ ] Image input
+- [ ] RAG for non-text files

autosh-0.0.2.dist-info/RECORD

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

{autosh-0.0.0.dist-info → autosh-0.0.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

autosh-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+ash = autosh.main:main
+autosh = autosh.main:main

{autosh-0.0.0.dist-info → autosh-0.0.2.dist-info/licenses}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Arnaud Blois
+Copyright (c) 2024 Wenyu Zhao
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

autosh-0.0.0.dist-info/METADATA

@@ -1,16 +0,0 @@
-Metadata-Version: 2.1
-Name: autosh
-Version: 0.0.0
-Summary: reserved
-License: MIT
-Author: Wenyu Zhao
-Author-email: wenyu.zhao@anu.edu.au
-Requires-Python: >=3.10
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Description-Content-Type: text/markdown
-
-reserved

autosh-0.0.0.dist-info/RECORD

@@ -1,5 +0,0 @@
-reserved/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autosh-0.0.0.dist-info/LICENSE,sha256=XKJuERnF3YCXg9ujPMNx1yOhChxe6bBmoHnPZBl7o2I,1068
-autosh-0.0.0.dist-info/METADATA,sha256=6bD3KcuY6YsLtrAKPnA6R_i0xBeaynkq-cKR0V5nppo,462
-autosh-0.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-autosh-0.0.0.dist-info/RECORD,,