axio-tools-local 0.1.0__py3-none-any.whl

axio_tools_local/__init__.py

@@ -0,0 +1,6 @@
+from typing import Any
+
+
+def _short(value: Any, limit: int = 60) -> str:
+    s = str(value)
+    return s if len(s) <= limit else s[:limit] + "..."

axio_tools_local/list_files.py

@@ -0,0 +1,36 @@
+import asyncio
+import os
+import stat as stat_module
+from datetime import datetime
+from pathlib import Path
+
+from axio.tool import ToolHandler
+
+
+class ListFiles(ToolHandler):
+    """List files and directories. Shows permissions, size, modification time,
+    and name for each entry. Directories are listed first and marked with
+    a trailing slash. Use this to explore the project structure before
+    reading or editing files."""
+
+    directory: str = "."
+
+    def __repr__(self) -> str:
+        return f"ListFiles(directory={self.directory!r})"
+
+    def _blocking(self) -> str:
+        path = Path(os.getcwd()) / self.directory
+        if not path.is_dir():
+            raise FileNotFoundError(f"{self.directory} is not a valid directory")
+        lines: list[str] = []
+        for fpath in sorted(path.glob("*"), key=lambda p: (not p.is_dir(), p.name)):
+            st = fpath.stat()
+            mode = stat_module.filemode(st.st_mode)
+            size = st.st_size
+            mtime = datetime.fromtimestamp(st.st_mtime).strftime("%b %d %H:%M")
+            name = fpath.name + ("/" if fpath.is_dir() else "")
+            lines.append(f"{mode} {size:>8} {mtime} {name}")
+        return "\n".join(lines) or "(empty directory)"
+
+    async def __call__(self) -> str:
+        return await asyncio.to_thread(self._blocking)

axio_tools_local/patch_file.py

@@ -0,0 +1,46 @@
+import asyncio
+import os
+from pathlib import Path
+
+from axio.tool import ToolHandler
+
+
+class PatchFile(ToolHandler):
+    """Replace a range of lines in an existing file. Lines are 0-indexed:
+    from_line is inclusive, to_line is exclusive. The content string replaces
+    lines[from_line:to_line]. Always read the file first to get correct
+    line numbers. Use this for surgical edits instead of rewriting the
+    whole file with write_file."""
+
+    file_path: str
+    mode: int = 0o644
+    from_line: int
+    to_line: int
+    content: str
+
+    def __repr__(self) -> str:
+        return (
+            f"PatchFile(file_path={self.file_path!r},"
+            f" lines={self.from_line}:{self.to_line}, content=<{len(self.content)} chars>)"
+        )
+
+    def _blocking(self) -> str:
+        path = Path(os.getcwd()) / self.file_path
+        if not path.is_file():
+            raise FileNotFoundError(f"{self.file_path} is not a valid file")
+
+        # read all lines
+        with path.open("r") as f:
+            lines = f.readlines()
+
+        # content lines
+        content = self.content.splitlines()
+
+        # patch lines
+        new_lines = lines[: self.from_line] + content + lines[self.to_line :]
+        with path.open("w") as f:
+            f.writelines(new_lines)
+            return f"{f.tell()} bytes written to {self.file_path}"
+
+    async def __call__(self) -> str:
+        return await asyncio.to_thread(self._blocking)

axio_tools_local/read_file.py

@@ -0,0 +1,41 @@
+import asyncio
+import os
+
+from axio.tool import ToolHandler
+
+
+class ReadFile(ToolHandler):
+    """Read file contents. Returns text for text files, hex for binaries.
+    Use start_line/end_line to read a specific range of lines (0-indexed).
+    Large files are truncated to max_chars. Always read the file before
+    editing it with write_file or patch_file."""
+
+    filename: str
+    max_chars: int = 32768
+    binary_as_hex: bool = True
+    start_line: int | None = None
+    end_line: int | None = None
+
+    def __repr__(self) -> str:
+        return f"ReadFile(filename={self.filename!r})"
+
+    def _blocking(self) -> str:
+        path = os.path.join(os.getcwd(), self.filename)
+        if self.start_line is None and self.end_line is None:
+            with open(path, "rb") as f:
+                result = f.read(self.max_chars)
+            try:
+                return result.decode()
+            except UnicodeDecodeError:
+                if self.binary_as_hex:
+                    return "Encoded binary data HEX: " + result.hex()
+                raise
+        with open(path) as f:
+            lines = f.readlines()[self.start_line : self.end_line]
+            content = "".join(lines)
+            if len(content) > self.max_chars:
+                return content[: self.max_chars] + "\n...[truncated]"
+            return content.strip()
+
+    async def __call__(self) -> str:
+        return await asyncio.to_thread(self._blocking)

axio_tools_local/run_python.py

@@ -0,0 +1,56 @@
+import asyncio
+import os
+import subprocess
+import sys
+import tempfile
+
+from axio.tool import ToolHandler
+
+from . import _short
+
+
+class RunPython(ToolHandler):
+    """Run a Python code snippet in a subprocess and return stdout/stderr.
+    The code is written to a temp file and executed with the current
+    interpreter. Use for calculations, data processing, or testing
+    small scripts. Optionally pass stdin data. Non-zero exit codes
+    and tracebacks are returned as-is."""
+
+    code: str
+    cwd: str = "."
+    timeout: int = 5
+    stdin: str | None = None
+
+    def __repr__(self) -> str:
+        return f"RunPython(code={_short(self.code)!r}, cwd={self.cwd!r})"
+
+    def _blocking(self) -> str:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py") as f:
+            f.write(self.code)
+            f.flush()
+
+            path = f.name
+
+            try:
+                result = subprocess.run(
+                    [sys.executable, path],
+                    capture_output=True,
+                    text=True,
+                    timeout=self.timeout,
+                    cwd=self.cwd,
+                    input=self.stdin if self.stdin is not None else None,
+                    stdin=subprocess.DEVNULL if self.stdin is None else None,
+                )
+                output = ""
+                if result.stdout:
+                    output += result.stdout
+                if result.stderr:
+                    output += f"\n[stderr]\n{result.stderr}"
+                if result.returncode != 0:
+                    output += f"\n[exit code: {result.returncode}]"
+                return output.strip() or "(no output)"
+            finally:
+                os.unlink(path)
+
+    async def __call__(self) -> str:
+        return await asyncio.to_thread(self._blocking)

axio_tools_local/shell.py

@@ -0,0 +1,44 @@
+import asyncio
+import subprocess
+
+from axio.tool import ToolHandler
+
+from . import _short
+
+
+class Shell(ToolHandler):
+    """Run a shell command and return combined stdout/stderr. Use for git,
+    build tools, grep, tests, or any CLI operation. Non-zero exit codes
+    are reported. Optionally pass stdin data for commands that read from
+    standard input. Prefer short timeouts and avoid interactive commands."""
+
+    command: str
+    timeout: int = 5
+    cwd: str = "."
+    stdin: str | None = None
+
+    def __repr__(self) -> str:
+        return f"Shell(command={_short(self.command)!r}, cwd={self.cwd!r})"
+
+    def _blocking(self) -> str:
+        result = subprocess.run(
+            self.command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=self.timeout,
+            cwd=self.cwd,
+            input=self.stdin if self.stdin is not None else None,
+            stdin=subprocess.DEVNULL if self.stdin is None else None,
+        )
+        output = ""
+        if result.stdout:
+            output += result.stdout
+        if result.stderr:
+            output += f"\n[stderr]\n{result.stderr}"
+        if result.returncode != 0:
+            output += f"\n[exit code: {result.returncode}]"
+        return output.strip() or "(no output)"
+
+    async def __call__(self) -> str:
+        return await asyncio.to_thread(self._blocking)

axio_tools_local/write_file.py

@@ -0,0 +1,28 @@
+import asyncio
+import os
+
+from axio.tool import ToolHandler
+
+
+class WriteFile(ToolHandler):
+    """Create or overwrite a file with the given content. Parent directories
+    are created automatically. Use this for new files or full rewrites.
+    For partial edits prefer patch_file instead."""
+
+    file_path: str
+    content: str
+    mode: int = 0o644
+
+    def __repr__(self) -> str:
+        return f"WriteFile(file_path={self.file_path!r}, content=<{len(self.content)} chars>)"
+
+    def _blocking(self) -> str:
+        path = os.path.join(os.getcwd(), self.file_path)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w") as f:
+            f.write(self.content)
+        os.chmod(path, mode=self.mode)
+        return f"Wrote {len(self.content)} bytes to {self.file_path}"
+
+    async def __call__(self) -> str:
+        return await asyncio.to_thread(self._blocking)

axio_tools_local-0.1.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: axio-tools-local
+Version: 0.1.0
+Summary: Core filesystem and execution tools for Axio
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: axio

axio_tools_local-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+axio_tools_local/__init__.py,sha256=RqCgDU1C7_KlwEACwF_f2aFMopGcvh-uBp6VZVBL9_I,147
+axio_tools_local/list_files.py,sha256=L6edDkJmsogw7fzFDcNGrf9Scu3iqtkmuPGhvzoGVBA,1322
+axio_tools_local/patch_file.py,sha256=wsG4XvDgZfAlUQ-qC4908IKR7ZuEjCqgiWdujDJKkh0,1433
+axio_tools_local/read_file.py,sha256=81qi1wequ_n-AJj7jfPSheNjaYyQ7YEByw7mufaFcfQ,1434
+axio_tools_local/run_python.py,sha256=EJRJnrIvJIA3IBZlndPFyBI901FM5Ztlgow5SYonrHw,1787
+axio_tools_local/shell.py,sha256=2XD8UaoUebO8ourbXXf9SjFbLPqT5WsYi1_MhkI42Lw,1384
+axio_tools_local/write_file.py,sha256=dEEJ68AviTPsjsfajTKrZ7Z2CfmO9W1c_r1tgasg5_U,898
+axio_tools_local-0.1.0.dist-info/METADATA,sha256=r4nszt9GDu6d0YPubbw61Qscs0cUBkTMjOlRTaOjQBs,193
+axio_tools_local-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+axio_tools_local-0.1.0.dist-info/entry_points.txt,sha256=WnS5AeRJ53M_cOaY1bDFsXO025EvUQz49mAAL3veYUs,302
+axio_tools_local-0.1.0.dist-info/licenses/LICENSE,sha256=ddOkAXgIM2QzvUDPydeis3tJXfhHxt1wKnmGjbwPPxQ,1074
+axio_tools_local-0.1.0.dist-info/RECORD,,

axio_tools_local-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

axio_tools_local-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[axio.tools]
+list_files = axio_tools_local.list_files:ListFiles
+patch_file = axio_tools_local.patch_file:PatchFile
+read_file = axio_tools_local.read_file:ReadFile
+run_python = axio_tools_local.run_python:RunPython
+shell = axio_tools_local.shell:Shell
+write_file = axio_tools_local.write_file:WriteFile

axio_tools_local-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Axio contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.