sid-harness 0.3.0__py3-none-any.whl

sid_harness/local_workspace.py

@@ -0,0 +1,421 @@
+"""Local workspace driver (SUB-54): the loop edits the user's REAL working tree.
+
+SUB-53 (``workspace.py``) loads a read-only, bounded snapshot of ``--dir`` and
+never writes back. This driver adds what SUB-54 requires:
+
+- real file read/write against the user's tree (no sandbox, no copy);
+- real ``git`` status/diff — read-only, never commit, never push;
+- worktree awareness (linked worktree vs main checkout);
+- a ``.gitignore`` filter plus the secret / VCS / dependency denylist.
+
+The denylist IS the shared ``native_agent._safe_path`` — the harness does not
+carry a second safety model, and the selection walk stays in ``workspace.py``.
+By default the harness never commits and never pushes. The only write path is
+the explicit opt-in ``git_write`` module (SUB-95), which refuses main/master,
+never forces, and gates every step behind its own approval.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .gateway import native_agent
+from .workspace import (
+    DEFAULT_MAX_FILE_BYTES,
+    DEFAULT_MAX_FILES,
+    DEFAULT_MAX_WORKSPACE_BYTES,
+    WorkspaceError,
+    WorkspaceSelection,
+    load_workspace,
+)
+
+_GIT_TIMEOUT = 30.0
+
+
+class LocalWorkspaceError(RuntimeError):
+    """A local workspace action was refused or could not complete."""
+
+
+def safe_rel_path(raw: object) -> str:
+    """Gate a caller path through the SHARED ``native_agent._safe_path``.
+
+    One safety model: secrets, private keys, VCS, and dependency directories are
+    refused here exactly as the server-side loop refuses them.
+    """
+    try:
+        return native_agent._safe_path(raw)
+    except native_agent.NativeAgentError as exc:
+        raise LocalWorkspaceError(str(exc)) from exc
+
+
+# --------------------------------------------------------------------------- #
+# .gitignore — a self-contained subset (no git subprocess, so it is testable
+# and deterministic). Covers comments, blank lines, ``!`` negation, trailing
+# ``/`` directory-only, leading ``/`` anchoring, and ``*`` / ``?`` / ``**``.
+# Nested .gitignore files are a documented v1 boundary: only the root file is
+# read.
+# --------------------------------------------------------------------------- #
+def _glob_to_regex(pattern: str) -> re.Pattern[str]:
+    out = ["^"]
+    index = 0
+    length = len(pattern)
+    while index < length:
+        if pattern[index : index + 2] == "**":
+            if pattern[index + 2 : index + 3] == "/":
+                out.append("(?:.*/)?")
+                index += 3
+            else:
+                out.append(".*")
+                index += 2
+        elif pattern[index] == "*":
+            out.append("[^/]*")
+            index += 1
+        elif pattern[index] == "?":
+            out.append("[^/]")
+            index += 1
+        else:
+            out.append(re.escape(pattern[index]))
+            index += 1
+    out.append("$")
+    return re.compile("".join(out))
+
+
+@dataclass(frozen=True)
+class _IgnoreRule:
+    anchored: bool
+    dir_only: bool
+    negate: bool
+    regex: re.Pattern[str]
+
+    def matches(self, prefixes: list[str]) -> bool:
+        # prefixes are every ancestor path plus the path itself; a dir-only rule
+        # may not match the file itself, only a directory prefix.
+        targets = prefixes[:-1] if self.dir_only else prefixes
+        for target in targets:
+            subject = target if self.anchored else target.rsplit("/", 1)[-1]
+            if self.regex.match(subject):
+                return True
+        return False
+
+
+def _parse_rule(line: str) -> _IgnoreRule | None:
+    stripped = line.rstrip("\n").rstrip()
+    if not stripped or stripped.lstrip().startswith("#"):
+        return None
+    negate = stripped.startswith("!")
+    body = stripped[1:] if negate else stripped
+    if not body:
+        return None
+    dir_only = body.endswith("/")
+    core = body.rstrip("/")
+    anchored = core.startswith("/") or "/" in core
+    core = core.lstrip("/")
+    if not core:
+        return None
+    return _IgnoreRule(
+        anchored=anchored,
+        dir_only=dir_only,
+        negate=negate,
+        regex=_glob_to_regex(core),
+    )
+
+
+class GitIgnore:
+    """Root ``.gitignore`` for a local workspace (last matching rule wins)."""
+
+    def __init__(self, rules: tuple[_IgnoreRule, ...] = ()) -> None:
+        self._rules = rules
+
+    @classmethod
+    def load(cls, root: Path) -> GitIgnore:
+        path = Path(root) / ".gitignore"
+        rules: list[_IgnoreRule] = []
+        if path.is_file():
+            try:
+                text = path.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                text = ""
+            for line in text.splitlines():
+                rule = _parse_rule(line)
+                if rule is not None:
+                    rules.append(rule)
+        return cls(tuple(rules))
+
+    def ignored(self, rel: str) -> bool:
+        rel = rel.replace("\\", "/")
+        parts = rel.split("/")
+        prefixes = ["/".join(parts[: index + 1]) for index in range(len(parts))]
+        ignored = False
+        for rule in self._rules:
+            if rule.matches(prefixes):
+                ignored = not rule.negate
+        return ignored
+
+
+# --------------------------------------------------------------------------- #
+# git — read-only. status/diff only; there is no commit and no push here.
+# --------------------------------------------------------------------------- #
+@dataclass(frozen=True)
+class GitInfo:
+    is_repo: bool
+    root: Path | None
+    git_dir: Path | None
+    common_dir: Path | None
+    is_worktree: bool
+    branch: str | None
+    head: str | None
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "is_repo": self.is_repo,
+            "is_worktree": self.is_worktree,
+            "root": str(self.root) if self.root else None,
+            "git_dir": str(self.git_dir) if self.git_dir else None,
+            "common_dir": str(self.common_dir) if self.common_dir else None,
+            "branch": self.branch,
+            "head": self.head,
+        }
+
+
+def _run_git(root: Path, args: list[str]) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", "-C", str(root), *args],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        timeout=_GIT_TIMEOUT,
+    )
+
+
+def _resolve_git_path(base: Path, value: str) -> Path | None:
+    value = value.strip()
+    if not value:
+        return None
+    candidate = Path(value)
+    if not candidate.is_absolute():
+        candidate = base / candidate
+    try:
+        return candidate.resolve()
+    except OSError:  # pragma: no cover - defensive
+        return candidate
+
+
+def git_info(root: str | os.PathLike[str]) -> GitInfo:
+    """Worktree-aware, read-only git metadata for ``root`` (never mutates)."""
+    base = Path(root).expanduser().resolve()
+    probe = _run_git(
+        base,
+        ["rev-parse", "--is-inside-work-tree", "--git-dir", "--git-common-dir", "--show-toplevel"],
+    )
+    if probe.returncode != 0:
+        return GitInfo(False, None, None, None, False, None, None)
+    lines = probe.stdout.splitlines()
+    if len(lines) < 4 or lines[0].strip() != "true":
+        return GitInfo(False, None, None, None, False, None, None)
+    git_dir = _resolve_git_path(base, lines[1])
+    common_dir = _resolve_git_path(base, lines[2])
+    toplevel = _resolve_git_path(base, lines[3])
+    is_worktree = bool(git_dir and common_dir and git_dir != common_dir)
+
+    branch_probe = _run_git(base, ["rev-parse", "--abbrev-ref", "HEAD"])
+    branch = branch_probe.stdout.strip() if branch_probe.returncode == 0 else None
+    head_probe = _run_git(base, ["rev-parse", "HEAD"])
+    head = head_probe.stdout.strip() if head_probe.returncode == 0 else None
+    return GitInfo(True, toplevel, git_dir, common_dir, is_worktree, branch or None, head or None)
+
+
+def git_status(root: str | os.PathLike[str]) -> list[str]:
+    """``git status --porcelain`` (read-only). Empty when ``root`` is not a repo."""
+    base = Path(root).expanduser().resolve()
+    proc = _run_git(base, ["status", "--porcelain"])
+    if proc.returncode != 0:
+        return []
+    return [line for line in proc.stdout.splitlines() if line.strip()]
+
+
+def git_diff(root: str | os.PathLike[str], *, staged: bool = False) -> str:
+    """``git diff`` (read-only). Empty when ``root`` is not a repo."""
+    base = Path(root).expanduser().resolve()
+    args = ["diff"]
+    if staged:
+        args.append("--cached")
+    proc = _run_git(base, args)
+    if proc.returncode != 0:
+        return ""
+    return proc.stdout
+
+
+# --------------------------------------------------------------------------- #
+# The driver
+# --------------------------------------------------------------------------- #
+@dataclass
+class LocalWorkspace:
+    """Real-tree driver: read/write on disk, git status/diff, worktree aware."""
+
+    root: Path
+    git: GitInfo
+    gitignore: GitIgnore = field(repr=False, default_factory=GitIgnore)
+
+    @classmethod
+    def open(cls, directory: str | os.PathLike[str]) -> LocalWorkspace:
+        base = Path(directory).expanduser().resolve()
+        if not base.is_dir():
+            raise LocalWorkspaceError(f"--dir is not a directory: {base}")
+        return cls(root=base, git=git_info(base), gitignore=GitIgnore.load(base))
+
+    def load(
+        self,
+        *,
+        max_files: int = DEFAULT_MAX_FILES,
+        max_bytes: int = DEFAULT_MAX_WORKSPACE_BYTES,
+        max_file_bytes: int = DEFAULT_MAX_FILE_BYTES,
+    ) -> WorkspaceSelection:
+        """Bounded read snapshot; ``.gitignore`` + the shared denylist applied."""
+        return load_workspace(
+            self.root,
+            max_files=max_files,
+            max_bytes=max_bytes,
+            max_file_bytes=max_file_bytes,
+            ignore=lambda rel: self.gitignore.ignored(rel)
+            or (
+                (rel == ".sid" or rel.startswith(".sid/"))
+                and rel != native_agent.PROJECT_CONFIG_PATH
+            ),
+        )
+
+    def _resolve_within_root(self, rel: object) -> tuple[str, Path]:
+        safe = safe_rel_path(rel)
+        root = self.root.resolve()
+        target = (root / safe).resolve()
+        if target != root and root not in target.parents:
+            raise LocalWorkspaceError("path escapes the workspace root")
+        return safe, target
+
+    def read(self, rel: object) -> str:
+        _safe, target = self._resolve_within_root(rel)
+        if not target.is_file():
+            raise LocalWorkspaceError(f"not a file: {rel}")
+        try:
+            return target.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as exc:
+            raise LocalWorkspaceError(f"cannot read {rel}: {exc}") from exc
+
+    def write(self, rel: object, content: object) -> dict[str, object]:
+        safe, target = self._resolve_within_root(rel)
+        if not isinstance(content, str):
+            raise LocalWorkspaceError("content must be a string")
+        size = len(content.encode("utf-8"))
+        if size > DEFAULT_MAX_FILE_BYTES:
+            raise LocalWorkspaceError(
+                f"file exceeds the {DEFAULT_MAX_FILE_BYTES}-byte limit"
+            )
+        target.parent.mkdir(parents=True, exist_ok=True)
+        tmp = target.with_name(target.name + ".sid-tmp")
+        tmp.write_text(content, encoding="utf-8")
+        os.replace(tmp, target)
+        return {"written": safe, "bytes": size, "path": str(target)}
+
+    def plan_apply(self, changed: list[str], files: dict[str, str]) -> dict[str, list[str]]:
+        """Classify a loop result without touching disk.
+
+        ``writes`` are changed paths that exist in the final file set;
+        ``deletions`` are changed paths that disappeared. Nothing is applied
+        here — a deletion needs explicit approval before it reaches the disk.
+        """
+        unique = set(changed)
+        return {
+            "writes": sorted(rel for rel in unique if rel in files),
+            "deletions": sorted(rel for rel in unique if rel not in files),
+        }
+
+    def apply(
+        self,
+        changed: list[str],
+        files: dict[str, str],
+        *,
+        approved_deletions: list[str] | tuple[str, ...] | set[str] | None = None,
+    ) -> list[str]:
+        """Persist the loop's changed files to the real tree.
+
+        Writes are applied as before. Deletions are NEVER silent: a path in
+        ``changed`` that is absent from ``files`` is only removed when it is
+        named in ``approved_deletions``. Use :meth:`plan_apply` to show the
+        caller exactly what would be deleted before approving.
+        """
+        plan = self.plan_apply(changed, files)
+        approved = set(approved_deletions or ())
+        written: list[str] = []
+        for rel in plan["writes"]:
+            self.write(rel, files[rel])
+            written.append(rel)
+        for rel in plan["deletions"]:
+            if rel in approved:
+                self.delete(rel, approved=True)
+        return written
+
+    def delete(self, rel: object, *, approved: bool = False) -> dict[str, object]:
+        """Delete one real file, only behind explicit approval."""
+        safe, target = self._resolve_within_root(rel)
+        if not approved:
+            raise LocalWorkspaceError(
+                f"refusing to delete {safe}: deletions require explicit approval"
+            )
+        if not target.is_file():
+            raise LocalWorkspaceError(f"not a file: {rel}")
+        try:
+            target.unlink()
+        except OSError as exc:
+            raise LocalWorkspaceError(f"cannot delete {rel}: {exc}") from exc
+        return {"deleted": safe, "path": str(target)}
+
+    def move(
+        self,
+        source: object,
+        destination: object,
+        *,
+        approved: bool = False,
+    ) -> dict[str, object]:
+        """Move/rename one real file, only behind explicit approval."""
+        safe_source, src = self._resolve_within_root(source)
+        safe_destination, dst = self._resolve_within_root(destination)
+        if not approved:
+            raise LocalWorkspaceError(
+                f"refusing to move {safe_source}: moves require explicit approval"
+            )
+        if not src.is_file():
+            raise LocalWorkspaceError(f"not a file: {source}")
+        if dst.exists():
+            raise LocalWorkspaceError(f"destination already exists: {destination}")
+        try:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            os.replace(src, dst)
+        except OSError as exc:
+            raise LocalWorkspaceError(f"cannot move {source}: {exc}") from exc
+        return {
+            "moved": {"from": safe_source, "to": safe_destination},
+            "path": str(dst),
+        }
+
+    def status(self) -> list[str]:
+        return git_status(self.root) if self.git.is_repo else []
+
+    def diff(self, *, staged: bool = False) -> str:
+        return git_diff(self.root, staged=staged) if self.git.is_repo else ""
+
+
+__all__ = [
+    "GitIgnore",
+    "GitInfo",
+    "LocalWorkspace",
+    "LocalWorkspaceError",
+    "WorkspaceError",
+    "git_diff",
+    "git_info",
+    "git_status",
+    "safe_rel_path",
+]