aiscript 1.0.0__tar.gz → 1.1.0__tar.gz

{aiscript-1.0.0 → aiscript-1.1.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: aiscript
-Version: 1.0.0
-Summary: JIT-compile plain-English intents into cached, reviewed shell scripts via an LLM.
+Version: 1.1.0
+Summary: JIT-compile plain-English intents into cached, reviewed shell or Python scripts via an LLM.
 Author: Daniel Illescas Romero
 Author-email: Daniel Illescas Romero <illescas.daniel@protonmail.com>
 License-Expression: MIT
@@ -17,8 +17,10 @@ Description-Content-Type: text/markdown
 [![PyPI version](https://img.shields.io/pypi/v/aiscript)](https://pypi.org/project/aiscript/)
 [![Python versions](https://img.shields.io/pypi/pyversions/aiscript)](https://pypi.org/project/aiscript/)
 
-Describe what you want in plain English and `aiscript` asks an LLM to write a shell script
-(Bash on Linux/macOS, PowerShell on Windows), caches it, and runs it. The next run is instant:
+Describe what you want in plain English and `aiscript` asks an LLM to write a script, caches
+it, and runs it. The model picks the language: your native shell (Bash on Linux/macOS, PowerShell
+on Windows) or Python when that fits better. Python scripts that need third-party packages get
+their own virtual environment. The next run is instant:
 no network, no config. Before anything risky is saved or run, every generated script is checked
 by a built-in static scan and, optionally, by a decision model: [Jev](https://docs.typesafe.ai)
 by TypeSafe AI (hosted) or a local model served by [Ollaya](https://ollaya.dev). Risky scripts
@@ -34,7 +36,19 @@ pipx install aiscript
 pip install aiscript
 ```
 
-Requires Python 3.10+. To work on aiscript itself, see [docs/development.md](docs/development.md).
+Requires Python 3.10+.
+
+To upgrade to the latest version, use the same tool you installed with:
+
+```sh
+uv tool upgrade aiscript
+# or
+pipx upgrade aiscript
+# or
+pip install --upgrade aiscript
+```
+
+Your config, prompts and cached scripts in `~/.config/aiscript/` are kept. To work on aiscript itself, see [docs/development.md](docs/development.md).
 
 ## Quickstart
 
@@ -135,17 +149,43 @@ variable, the legacy `secrets.yaml`): [docs/configuration.md](docs/configuration
 
 Command names must match `[A-Za-z0-9][A-Za-z0-9_-]*`.
 
+## Shell or Python
+
+The model is told your OS, architecture, native shell, the Python version it will run under and
+whether [uv](https://docs.astral.sh/uv/) is installed, and chooses the language: the shell for thin
+wrappers around CLI tools and pipelines, Python for parsing JSON/CSV/HTML, data processing, HTTP
+APIs and anything that would be fragile in shell. Say "in python" or "as a shell script" in your
+description to ask for one; the model follows it unless it is clearly a poor fit (and then notes
+why in the script header). `aiscript --list` shows each command's language.
+
+- **Standard-library Python** is saved as `functions/NAME.py` and run with the system `python3`
+  (`py -3` on Windows), or with aiscript's own interpreter if there is none.
+- **Python with dependencies** declares them in an inline
+  [PEP 723](https://peps.python.org/pep-0723/) block. After you approve (any dependency requires a
+  `[y/N]` approval that lists the packages), aiscript creates `functions/NAME/` with `main.py` and
+  a private `.venv`: with uv (`pyproject.toml` + `uv.lock`, `uv sync`) or otherwise with
+  `python -m venv` + `pip install -r requirements.txt`. The script always runs with that venv's
+  interpreter, so later runs are offline. A rebuild with the same dependencies reuses the venv; a
+  failed install keeps the previous version. Without uv, Debian/Ubuntu need `python3-venv`.
+
 ## How it works
 
 ```
 ~/.config/aiscript/          # or $XDG_CONFIG_HOME/aiscript, or $AISCRIPT_HOME
 ├── config.yaml              # providers and keys
 ├── prompts/<name>.txt       # your intent for each command
-└── functions/<name>.sh      # generated, reviewed scripts (.ps1 on Windows)
+└── functions/
+    ├── <name>.sh            # generated, reviewed scripts (.ps1 on Windows)
+    ├── <name>.py            # standard-library Python
+    └── <name>/              # Python with dependencies
+        ├── main.py
+        ├── .venv/
+        └── pyproject.toml + uv.lock  (or requirements.txt)
 ```
 
 The first run of `NAME` saves your description to `prompts/NAME.txt`, asks the LLM for a script,
-reviews it, and stores it in `functions/`. Later runs just execute the cached script. If the
+reviews it, and stores it in `functions/` (only one build per command: switching language
+replaces the old one). Later runs just execute the cached script. If the
 prompt is newer than the script (after `--edit` or a manual change), the script is rebuilt on the
 next run. A `--rebuild` that fails or is rejected keeps the previous script.
 

{aiscript-1.0.0 → aiscript-1.1.0}/README.md

@@ -3,8 +3,10 @@
 [![PyPI version](https://img.shields.io/pypi/v/aiscript)](https://pypi.org/project/aiscript/)
 [![Python versions](https://img.shields.io/pypi/pyversions/aiscript)](https://pypi.org/project/aiscript/)
 
-Describe what you want in plain English and `aiscript` asks an LLM to write a shell script
-(Bash on Linux/macOS, PowerShell on Windows), caches it, and runs it. The next run is instant:
+Describe what you want in plain English and `aiscript` asks an LLM to write a script, caches
+it, and runs it. The model picks the language: your native shell (Bash on Linux/macOS, PowerShell
+on Windows) or Python when that fits better. Python scripts that need third-party packages get
+their own virtual environment. The next run is instant:
 no network, no config. Before anything risky is saved or run, every generated script is checked
 by a built-in static scan and, optionally, by a decision model: [Jev](https://docs.typesafe.ai)
 by TypeSafe AI (hosted) or a local model served by [Ollaya](https://ollaya.dev). Risky scripts
@@ -20,7 +22,19 @@ pipx install aiscript
 pip install aiscript
 ```
 
-Requires Python 3.10+. To work on aiscript itself, see [docs/development.md](docs/development.md).
+Requires Python 3.10+.
+
+To upgrade to the latest version, use the same tool you installed with:
+
+```sh
+uv tool upgrade aiscript
+# or
+pipx upgrade aiscript
+# or
+pip install --upgrade aiscript
+```
+
+Your config, prompts and cached scripts in `~/.config/aiscript/` are kept. To work on aiscript itself, see [docs/development.md](docs/development.md).
 
 ## Quickstart
 
@@ -121,17 +135,43 @@ variable, the legacy `secrets.yaml`): [docs/configuration.md](docs/configuration
 
 Command names must match `[A-Za-z0-9][A-Za-z0-9_-]*`.
 
+## Shell or Python
+
+The model is told your OS, architecture, native shell, the Python version it will run under and
+whether [uv](https://docs.astral.sh/uv/) is installed, and chooses the language: the shell for thin
+wrappers around CLI tools and pipelines, Python for parsing JSON/CSV/HTML, data processing, HTTP
+APIs and anything that would be fragile in shell. Say "in python" or "as a shell script" in your
+description to ask for one; the model follows it unless it is clearly a poor fit (and then notes
+why in the script header). `aiscript --list` shows each command's language.
+
+- **Standard-library Python** is saved as `functions/NAME.py` and run with the system `python3`
+  (`py -3` on Windows), or with aiscript's own interpreter if there is none.
+- **Python with dependencies** declares them in an inline
+  [PEP 723](https://peps.python.org/pep-0723/) block. After you approve (any dependency requires a
+  `[y/N]` approval that lists the packages), aiscript creates `functions/NAME/` with `main.py` and
+  a private `.venv`: with uv (`pyproject.toml` + `uv.lock`, `uv sync`) or otherwise with
+  `python -m venv` + `pip install -r requirements.txt`. The script always runs with that venv's
+  interpreter, so later runs are offline. A rebuild with the same dependencies reuses the venv; a
+  failed install keeps the previous version. Without uv, Debian/Ubuntu need `python3-venv`.
+
 ## How it works
 
 ```
 ~/.config/aiscript/          # or $XDG_CONFIG_HOME/aiscript, or $AISCRIPT_HOME
 ├── config.yaml              # providers and keys
 ├── prompts/<name>.txt       # your intent for each command
-└── functions/<name>.sh      # generated, reviewed scripts (.ps1 on Windows)
+└── functions/
+    ├── <name>.sh            # generated, reviewed scripts (.ps1 on Windows)
+    ├── <name>.py            # standard-library Python
+    └── <name>/              # Python with dependencies
+        ├── main.py
+        ├── .venv/
+        └── pyproject.toml + uv.lock  (or requirements.txt)
 ```
 
 The first run of `NAME` saves your description to `prompts/NAME.txt`, asks the LLM for a script,
-reviews it, and stores it in `functions/`. Later runs just execute the cached script. If the
+reviews it, and stores it in `functions/` (only one build per command: switching language
+replaces the old one). Later runs just execute the cached script. If the
 prompt is newer than the script (after `--edit` or a manual change), the script is rebuilt on the
 next run. A `--rebuild` that fails or is rejected keeps the previous script.
 

{aiscript-1.0.0 → aiscript-1.1.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "aiscript"
-version = "1.0.0"
-description = "JIT-compile plain-English intents into cached, reviewed shell scripts via an LLM."
+version = "1.1.0"
+description = "JIT-compile plain-English intents into cached, reviewed shell or Python scripts via an LLM."
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]

{aiscript-1.0.0 → aiscript-1.1.0}/pyproject.toml.orig

@@ -1,7 +1,7 @@
 [project]
 name = "aiscript"
-version = "1.0.0"
-description = "JIT-compile plain-English intents into cached, reviewed shell scripts via an LLM."
+version = "1.1.0"
+description = "JIT-compile plain-English intents into cached, reviewed shell or Python scripts via an LLM."
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]

{aiscript-1.0.0 → aiscript-1.1.0}/src/aiscript/__init__.py

@@ -1,3 +1,3 @@
 """aiscript: JIT-compile plain-English intents into cached shell scripts."""
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"

{aiscript-1.0.0 → aiscript-1.1.0}/src/aiscript/builder.py

@@ -4,11 +4,12 @@ from __future__ import annotations
 
 import contextlib
 import os
+import shutil
 import sys
 import tempfile
 from pathlib import Path
 
-from aiscript import llm, paths, reviewer
+from aiscript import llm, paths, pysetup, reviewer
 from aiscript.config import Settings
 from aiscript.errors import AiscriptError
 
@@ -44,17 +45,26 @@ def build(name: str, settings: Settings) -> Path:
     print(f"Generating {name!r} with {gen.name}/{gen.model}...", file=sys.stderr)
     script = llm.generate_script(gen, name, intent)
 
-    shell = paths.shell_kind()
-    result = reviewer.review(script, shell, settings.reviewer)
-    if not reviewer.confirm(script, result):
+    result = reviewer.review(script.code, script.language, settings.reviewer, script.dependencies)
+    if not reviewer.confirm(script.code, result):
         raise AiscriptError("Script rejected; nothing saved.")
 
     paths.ensure_dirs()
-    target = paths.function_path(name)
+    if script.dependencies:
+        target = pysetup.install(name, script.code, script.dependencies)
+    else:
+        target = paths.function_target(name, script.language, has_deps=False)
+        _write_file(name, target, script.code)
+    _remove_other_artifacts(name, target)
+    print(f"Saved {target}", file=sys.stderr)
+    return target
+
+
+def _write_file(name: str, target: Path, code: str) -> None:
     fd, tmp_name = tempfile.mkstemp(dir=paths.functions_dir(), prefix=f".{name}.", suffix=".tmp")
     try:
         with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as fh:
-            fh.write(script)
+            fh.write(code)
         if not paths.is_windows():
             os.chmod(tmp_name, 0o755)
         os.replace(tmp_name, target)
@@ -62,5 +72,17 @@ def build(name: str, settings: Settings) -> Path:
         with contextlib.suppress(OSError):
             os.unlink(tmp_name)
         raise
-    print(f"Saved {target}", file=sys.stderr)
-    return target
+
+
+def _remove_other_artifacts(name: str, target: Path) -> None:
+    """Drop builds of ``name`` in another language or layout, so only ``target`` remains."""
+    for path in paths.function_artifacts(name):
+        if path == target or path in target.parents:
+            continue
+        try:
+            if path.is_dir():
+                shutil.rmtree(path)
+            else:
+                path.unlink()
+        except OSError as exc:
+            print(f"aiscript: warning: could not remove old build {path}: {exc}", file=sys.stderr)

{aiscript-1.0.0 → aiscript-1.1.0}/src/aiscript/cli.py

@@ -22,7 +22,7 @@ usage: aiscript NAME [args...]       run a command (created/built on first use)
        aiscript --list               list commands
        aiscript --edit NAME          edit a command's prompt (rebuilds on next run)
        aiscript --rebuild NAME       regenerate a command's script (does not run it)
-       aiscript --remove NAME        delete a command's prompt and script
+       aiscript --remove NAME        delete a command's prompt and script(s)
        aiscript --help | --version
 
 Everything after NAME is passed untouched to the generated script.
@@ -92,12 +92,15 @@ def _rebuild(name: str) -> int:
 
 def _remove(name: str) -> int:
     paths.validate_command_name(name)
-    targets = [p for p in (paths.prompt_path(name), paths.function_path(name)) if p.exists()]
+    targets = [p for p in (paths.prompt_path(name), *paths.function_artifacts(name)) if p.exists()]
     if not targets:
         raise AiscriptError(f"No command named {name!r}.")
     for path in targets:
         try:
-            path.unlink()
+            if path.is_dir():
+                shutil.rmtree(path)
+            else:
+                path.unlink()
         except OSError as exc:
             raise AiscriptError(f"Could not remove {path}: {exc}") from exc
         _err(f"Removed {path}")

aiscript-1.1.0/src/aiscript/env.py

@@ -0,0 +1,120 @@
+"""Host environment detection for the generator prompt and the runner."""
+
+from __future__ import annotations
+
+import functools
+import platform
+import re
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+_MIN_PYTHON = (3, 8)
+_VERSION_TIMEOUT_SECONDS = 5.0
+_VERSION_RE = re.compile(r"Python (\d+)\.(\d+)\.(\d+)")
+
+
+@dataclass(frozen=True)
+class PythonInfo:
+    command: list[str]  # argv prefix that runs it, e.g. ["/usr/bin/python3"] or ["py", "-3"]
+    version: str  # e.g. "3.13.1"
+    is_system: bool  # False when falling back to aiscript's own interpreter (sys.executable)
+
+
+def _is_windows() -> bool:
+    return platform.system() == "Windows"
+
+
+def _candidates() -> list[list[str]]:
+    """Argv prefixes to try, best first (only those whose executable is on PATH)."""
+    names = [["py", "-3"], ["python"]] if _is_windows() else [["python3"], ["python"]]
+    found: list[list[str]] = []
+    for argv in names:
+        exe = shutil.which(argv[0])
+        if exe:
+            found.append([exe, *argv[1:]])
+    return found
+
+
+def python_command() -> list[str]:
+    """Fast (PATH lookup only, no subprocess): argv prefix for running a stdlib-only script."""
+    candidates = _candidates()
+    return candidates[0] if candidates else [sys.executable]
+
+
+def _probe(command: list[str]) -> str | None:
+    """Return the ``X.Y.Z`` version of ``command`` if it is a working Python >= 3.8."""
+    try:
+        result = subprocess.run(
+            [*command, "--version"],
+            capture_output=True,
+            text=True,
+            timeout=_VERSION_TIMEOUT_SECONDS,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:  # e.g. the Windows Store stub
+        return None
+    match = _VERSION_RE.search(f"{result.stdout}\n{result.stderr}")
+    if not match:
+        return None
+    major, minor, patch = (int(g) for g in match.groups())
+    if (major, minor) < _MIN_PYTHON:
+        return None
+    return f"{major}.{minor}.{patch}"
+
+
+@functools.cache
+def find_python() -> PythonInfo:
+    """System Python with its version (runs ``--version``); falls back to sys.executable."""
+    for command in _candidates():
+        version = _probe(command)
+        if version:
+            return PythonInfo(command, version, True)
+    return PythonInfo([sys.executable], platform.python_version(), False)
+
+
+def uv_path() -> str | None:
+    """Path to the ``uv`` executable, or None."""
+    return shutil.which("uv")
+
+
+def _os_description() -> str:
+    system = platform.system() or "Unknown"
+    desc = f"{system} {platform.release()}".strip()
+    if system == "Linux":
+        try:
+            for line in Path("/etc/os-release").read_text(encoding="utf-8").splitlines():
+                if line.startswith("PRETTY_NAME="):
+                    pretty = line.split("=", 1)[1].strip().strip("\"'")
+                    desc += f" ({pretty})"
+                    break
+        except OSError:
+            pass
+    elif system == "Darwin":
+        mac_version = platform.mac_ver()[0]
+        if mac_version:
+            desc += f" (macOS {mac_version})"
+    return desc
+
+
+def describe() -> str:
+    """Multi-line TARGET ENVIRONMENT block for the generator's system prompt."""
+    py = find_python()
+    if py.is_system:
+        shown = " ".join([Path(py.command[0]).name.removesuffix(".exe"), *py.command[1:]])
+        python_line = f"{py.version} ({shown})"
+    else:
+        python_line = f"{py.version} (aiscript's own interpreter; no suitable system Python found)"
+    shell = "PowerShell" if _is_windows() else "Bash"
+    lines = [
+        f"- Host OS: {_os_description()}",
+        f"- Architecture: {platform.machine() or 'unknown'}",
+        f"- Native shell: {shell}",
+        f"- Python: {python_line}",
+        f"- uv: {'available' if uv_path() else 'not installed'}",
+    ]
+    return "\n".join(lines)

{aiscript-1.0.0 → aiscript-1.1.0}/src/aiscript/listing.py

@@ -50,7 +50,13 @@ def _command_names() -> list[str]:
     if pdir.is_dir():
         names.update(p.stem for p in pdir.glob("*.txt"))
     if fdir.is_dir():
-        names.update(p.stem for p in fdir.glob(f"*.{paths.script_ext()}"))
+        for p in fdir.iterdir():
+            if p.name.startswith("."):
+                continue
+            if p.is_file() and p.suffix in (".sh", ".ps1", ".py"):
+                names.add(p.stem)
+            elif p.is_dir() and (p / "main.py").is_file():
+                names.add(p.name)
     valid = []
     for n in names:
         try:
@@ -61,14 +67,24 @@ def _command_names() -> list[str]:
     return sorted(valid, key=str.lower)
 
 
+def _lang(fpath: Path) -> str:
+    """LANG column: sh, ps1, py or py+deps (project dir); blank when not built."""
+    if not fpath.exists():
+        return ""
+    if paths.is_project_main(fpath):
+        return "py+deps"
+    return fpath.suffix.lstrip(".")
+
+
 def list_commands() -> int:
     """Print a table of commands to stdout; return 0."""
-    rows: list[tuple[str, str, str]] = []
+    rows: list[tuple[str, str, str, str]] = []
     any_stale = False
     for name in _command_names():
         ppath = paths.prompt_path(name)
         fpath = paths.function_path(name)
         label = name
+        lang = _lang(fpath)
         if fpath.exists():
             header = parse_header(fpath)
             desc, usage = header["description"], header["usage"]
@@ -77,7 +93,7 @@ def list_commands() -> int:
                 any_stale = True
         else:
             desc, usage = _NOT_BUILT, ""
-        rows.append((label, desc, usage))
+        rows.append((label, lang, desc, usage))
 
     if not rows:
         print("No commands yet. Try: aiscript <name>", file=sys.stderr)
@@ -85,16 +101,17 @@ def list_commands() -> int:
 
     cols = shutil.get_terminal_size(fallback=(100, 24)).columns
     name_w = max(len("NAME"), *(len(r[0]) for r in rows))
-    usage_w = min(max(len("USAGE"), *(len(r[2]) for r in rows)), 40)
-    desc_w = max(20, cols - name_w - usage_w - 4)
-    desc_w = min(desc_w, max(len("DESCRIPTION"), *(len(r[1]) for r in rows)))
+    lang_w = max(len("LANG"), *(len(r[1]) for r in rows))
+    usage_w = min(max(len("USAGE"), *(len(r[3]) for r in rows)), 40)
+    desc_w = max(20, cols - name_w - lang_w - usage_w - 6)
+    desc_w = min(desc_w, max(len("DESCRIPTION"), *(len(r[2]) for r in rows)))
 
-    def fmt(a: str, b: str, c: str) -> str:
-        return f"{a:<{name_w}}  {b:<{desc_w}}  {c}".rstrip()
+    def fmt(a: str, b: str, c: str, d: str) -> str:
+        return f"{a:<{name_w}}  {b:<{lang_w}}  {c:<{desc_w}}  {d}".rstrip()
 
-    lines = [fmt("NAME", "DESCRIPTION", "USAGE")]
-    for label, desc, usage in rows:
-        lines.append(fmt(label, _truncate(desc, desc_w), _truncate(usage, usage_w)))
+    lines = [fmt("NAME", "LANG", "DESCRIPTION", "USAGE")]
+    for label, lang, desc, usage in rows:
+        lines.append(fmt(label, lang, _truncate(desc, desc_w), _truncate(usage, usage_w)))
     print("\n".join(lines))
     if any_stale:
         print(