aria-code 4.1.3__py3-none-any.whl

workspace/files.py

@@ -0,0 +1,170 @@
+"""Safe workspace file operations for Aria Code."""
+
+from __future__ import annotations
+
+import pathlib
+import re
+import tempfile
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+
+@dataclass(frozen=True)
+class ReadResult:
+    path: str
+    lines: int
+    content: str
+
+
+class WorkspaceSecurity:
+    """Path security policy shared by CLI tools and future runtimes."""
+
+    BLOCKED_ROOTS = (
+        "/etc",
+        "/sys",
+        "/proc",
+        "/dev",
+        "/boot",
+        "/root",
+    )
+
+    def __init__(self, cwd: str | pathlib.Path | None = None) -> None:
+        self.cwd = pathlib.Path(cwd or pathlib.Path.cwd()).expanduser().resolve()
+
+    def allowed_roots(self) -> List[pathlib.Path]:
+        roots = [pathlib.Path.home().resolve(), pathlib.Path("/tmp").resolve(), self.cwd]
+        for tmp_candidate in (
+            "/var/folders",
+            "/private/tmp",
+            "/private/var/folders",
+            "/var/tmp",
+            "/private/var/tmp",
+            tempfile.gettempdir(),
+        ):
+            try:
+                root = pathlib.Path(tmp_candidate).resolve()
+                if root not in roots:
+                    roots.append(root)
+            except Exception:
+                pass
+        return roots
+
+    def resolve(self, path: str | pathlib.Path) -> pathlib.Path:
+        return pathlib.Path(path).expanduser().resolve()
+
+    def is_safe_path(self, path: str | pathlib.Path) -> bool:
+        resolved = self.resolve(path)
+        for blocked in self.BLOCKED_ROOTS:
+            try:
+                resolved.relative_to(pathlib.Path(blocked).resolve())
+                return False
+            except ValueError:
+                pass
+        for root in self.allowed_roots():
+            try:
+                resolved.relative_to(root)
+                return True
+            except ValueError:
+                pass
+        return False
+
+    def require_safe(self, path: str | pathlib.Path) -> pathlib.Path:
+        resolved = self.resolve(path)
+        if not self.is_safe_path(resolved):
+            raise PermissionError(f"Access denied: path '{resolved}' is outside allowed directories")
+        return resolved
+
+
+class WorkspaceFiles:
+    """Read, list, and search files under Aria Code's safety policy."""
+
+    MAX_READ_BYTES = 2_000_000
+    LARGE_FILE_BYTES = 500_000
+    LARGE_FILE_DEFAULT_LINES = 500
+    MAX_SEARCH_BYTES = 5_000_000
+
+    def __init__(self, security: WorkspaceSecurity | None = None) -> None:
+        self.security = security or WorkspaceSecurity()
+
+    def read_file(self, path: str, offset: int = 0, limit: int = 0) -> ReadResult:
+        target = self.security.require_safe(path)
+        if not target.exists():
+            raise FileNotFoundError(f"File not found: {target}")
+        if not target.is_file():
+            raise ValueError(f"Not a file: {target}")
+        size = target.stat().st_size
+        if size > self.MAX_READ_BYTES:
+            raise ValueError(
+                f"File too large: {size:,} bytes (max 2 MB). "
+                "Use offset/limit parameters to read sections."
+            )
+        text = target.read_text(errors="replace")
+        lines = text.splitlines()
+        total_lines = len(lines)
+        if not offset and not limit and size > self.LARGE_FILE_BYTES:
+            limit = self.LARGE_FILE_DEFAULT_LINES
+        if offset or limit:
+            end = offset + limit if limit else total_lines
+            shown = lines[offset:end]
+            content = "\n".join(f"{i + offset + 1:4d}│ {line}" for i, line in enumerate(shown))
+            if limit and end < total_lines:
+                content += f"\n... [{len(shown)} of {total_lines} lines shown — use offset/limit to read more]"
+            return ReadResult(str(target), len(shown), content[:30000])
+        content = "\n".join(f"{i + 1:4d}│ {line}" for i, line in enumerate(lines))
+        return ReadResult(str(target), len(lines), content[:30000])
+
+    def list_files(self, path: str = ".", pattern: str = "*") -> Dict[str, Any]:
+        target = self.security.require_safe(path)
+        if not target.exists():
+            raise FileNotFoundError(f"Path not found: {target}")
+        if target.is_file():
+            read = self.read_file(str(target))
+            return {
+                "path": read.path,
+                "pattern": pattern,
+                "count": 1,
+                "items": [{"name": target.name, "type": "file", "size": target.stat().st_size}],
+                "content": read.content,
+            }
+        matches = sorted(target.glob(pattern))[:100]
+        items = []
+        for match in matches:
+            try:
+                self.security.require_safe(match)
+            except PermissionError:
+                continue
+            rel = match.relative_to(target) if match.is_relative_to(target) else match
+            kind = "dir" if match.is_dir() else "file"
+            size = match.stat().st_size if match.is_file() else 0
+            items.append({"name": str(rel), "type": kind, "size": size})
+        return {"path": str(target), "pattern": pattern, "count": len(items), "items": items}
+
+    def search_code(self, pattern: str, path: str = ".", file_glob: str = "**/*.py") -> Dict[str, Any]:
+        if not pattern:
+            raise ValueError("Missing 'pattern' parameter")
+        target = self.security.require_safe(path)
+        regex = re.compile(pattern, re.IGNORECASE)
+        matches = []
+        for file_path in sorted(target.glob(file_glob))[:200]:
+            try:
+                safe_file = self.security.require_safe(file_path)
+            except PermissionError:
+                continue
+            if not safe_file.is_file() or safe_file.stat().st_size > self.MAX_SEARCH_BYTES:
+                continue
+            try:
+                lines = safe_file.read_text(errors="replace").splitlines()
+            except Exception:
+                continue
+            for line_number, line in enumerate(lines, 1):
+                if regex.search(line):
+                    matches.append({
+                        "file": str(safe_file.relative_to(target) if safe_file.is_relative_to(target) else safe_file),
+                        "line": line_number,
+                        "content": line.strip()[:200],
+                    })
+                    if len(matches) >= 50:
+                        break
+            if len(matches) >= 50:
+                break
+        return {"pattern": pattern, "path": str(target), "count": len(matches), "matches": matches}

workspace/verify.py

@@ -0,0 +1,113 @@
+"""Verification planning for Aria Code workspaces."""
+
+from __future__ import annotations
+
+import json
+import pathlib
+import shlex
+import subprocess
+from dataclasses import dataclass
+from typing import Iterable, List
+
+
+@dataclass(frozen=True)
+class VerificationPlan:
+    commands: List[str]
+    reason: str
+
+
+class VerificationPlanner:
+    """Infer focused verification commands from changed files and project files."""
+
+    def __init__(self, root: str | pathlib.Path = ".") -> None:
+        self.root = pathlib.Path(root).expanduser().resolve()
+
+    def infer(self, paths: Iterable[str] | None = None) -> VerificationPlan:
+        changed = [p for p in (paths or []) if p]
+        if not changed:
+            changed = self._git_changed_files()
+        commands: List[str] = []
+        reasons: List[str] = []
+
+        py_files = [p for p in changed if p.endswith(".py")]
+        if py_files:
+            quoted = " ".join(shlex.quote(p) for p in py_files[:20])
+            commands.append(f"python3 -m py_compile {quoted}")
+            reasons.append("Python files changed")
+            if self._has_any("pytest.ini", "pyproject.toml", "setup.cfg", "tox.ini") or (self.root / "tests").exists():
+                commands.append("python3 -m pytest -q")
+
+        frontend_files = [
+            p for p in changed
+            if p.endswith((".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".css"))
+        ]
+        if frontend_files and (self.root / "package.json").exists():
+            scripts = self._package_scripts()
+            reasons.append("Node/TypeScript files changed")
+            if "test" in scripts:
+                commands.append("npm test")
+            if "build" in scripts:
+                commands.append("npm run build")
+            elif (self.root / "tsconfig.json").exists():
+                commands.append("npx tsc --noEmit")
+
+        if not commands:
+            if (self.root / "pyproject.toml").exists() or (self.root / "tests").exists():
+                commands.append("python3 -m pytest -q")
+                reasons.append("Python project detected")
+            elif (self.root / "package.json").exists():
+                scripts = self._package_scripts()
+                if "test" in scripts:
+                    commands.append("npm test")
+                    reasons.append("Node project detected")
+                elif "build" in scripts:
+                    commands.append("npm run build")
+                    reasons.append("Node project detected")
+
+        deduped = list(dict.fromkeys(commands))
+        reason = "; ".join(dict.fromkeys(reasons)) if reasons else "No focused check inferred"
+        return VerificationPlan(deduped, reason)
+
+    def _has_any(self, *names: str) -> bool:
+        return any((self.root / name).exists() for name in names)
+
+    def _package_scripts(self) -> dict:
+        try:
+            data = json.loads((self.root / "package.json").read_text(encoding="utf-8"))
+            return data.get("scripts", {}) if isinstance(data.get("scripts", {}), dict) else {}
+        except Exception:
+            return {}
+
+    def _git_changed_files(self) -> List[str]:
+        try:
+            proc = subprocess.run(
+                ["git", "diff", "--name-only", "HEAD"],
+                cwd=self.root,
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if proc.returncode == 0 and proc.stdout.strip():
+                return [line.strip() for line in proc.stdout.splitlines() if line.strip()]
+        except Exception:
+            pass
+        try:
+            proc = subprocess.run(
+                ["git", "status", "--short"],
+                cwd=self.root,
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if proc.returncode != 0:
+                return []
+            files = []
+            for line in proc.stdout.splitlines():
+                if not line.strip():
+                    continue
+                files.append(line[3:].strip())
+            return files
+        except Exception:
+            return []