termdeck-agents 0.12.3__py3-none-any.whl

filebrowser/__init__.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+
+STATIC_DIR = Path(__file__).resolve().parent / "static"

filebrowser/static/file_browser_shared.css

@@ -0,0 +1,4 @@
+/* Tree rows scale with --tree-scale (the tree's own size setting), not --ui-scale: the file tree has
+   a dedicated size control, so global chrome sizing must not re-space it. */
+.file-browser-tree-row { cursor: pointer; min-height: calc(22px * var(--tree-scale, 1)); padding: calc(1px * var(--tree-scale, 1)) calc(6px * var(--tree-scale, 1)); gap: calc(6px * var(--tree-scale, 1)); }
+.tree-children-wrap { margin-left: calc(1px * var(--tree-scale, 1)); padding-left: calc(3px * var(--tree-scale, 1)); }

filebrowser/static/file_browser_shared.js

@@ -0,0 +1,81 @@
+window.TermDeckFileBrowser = (() => {
+  const materialIconsBase = "/static/vendor/material-icons/icons/";
+  const termdeckIconsBase = "/static/icons/";
+  const alwaysExcluded = [".git", "node_modules", "__pycache__", ".venv", ".idea", "_"];
+  const fileIconNames = { py: "python", js: "javascript", ts: "typescript", json: "json", md: "markdown", css: "css", html: "html", yaml: "yaml", yml: "yaml", sh: "console", sql: "database", csv: "table", png: "image", jpg: "image", jpeg: "image", svg: "svg", rs: "rust", go: "go", java: "java", cpp: "cpp", c: "c", h: "h" };
+  const gitStatusLabels = { "?": "untracked", M: "modified", A: "added", D: "deleted", R: "renamed", C: "copied", U: "conflicted" };
+
+  function fileIconElement(fileName, className = "tree-type-icon") {
+    const extension = String(fileName || "").split(".").pop().toLowerCase();
+    const image = document.createElement("img");
+    image.className = className;
+    image.src = `${materialIconsBase}${fileIconNames[extension] || "file"}.svg`;
+    image.onerror = () => { image.src = `${materialIconsBase}file.svg`; image.onerror = null; };
+    return image;
+  }
+
+  function formatMtime(epochSeconds) {
+    const minutes = Math.max(0, Math.floor((Date.now() - Number(epochSeconds) * 1000) / 60000));
+    const hours = Math.floor(minutes / 60), days = Math.floor(hours / 24), weeks = Math.floor(days / 7), months = Math.floor(weeks / 4);
+    const values = months >= 12 ? [[Math.floor(months / 12), "y"], [months % 12, "m"]] : months ? [[months, "m"], [weeks % 4, "w"]] : weeks ? [[weeks, "w"], [days % 7, "d"]] : days ? [[days, "d"], [hours % 24, "h"]] : hours ? [[hours, "h"], [minutes % 60, "m"]] : [[minutes, "m"]];
+    return values.filter(([value]) => value > 0).map(([value, suffix]) => `${value}${suffix}`).join(" ") || "0m";
+  }
+
+  function appendEntryMetadata(row, entry, { showMtime = true, showGitStatus = true } = {}) {
+    if (showMtime && entry.mtime) {
+      const mtime = document.createElement("span");
+      mtime.className = "tree-mtime";
+      mtime.textContent = formatMtime(entry.mtime);
+      mtime.title = `modified ${new Date(Number(entry.mtime) * 1000).toLocaleString()}`;
+      row.appendChild(mtime);
+    }
+    if (!showGitStatus) return;
+    const status = String(entry.git_status || "").trim().toUpperCase();
+    if (!status) return;
+    const statusClass = status === "?" ? "untracked" : status.toLowerCase();
+    row.dataset.gitStatus = status;
+    row.classList.add("git-row", `git-row-${statusClass}`);
+    const badge = document.createElement("span");
+    badge.className = "git-status";
+    badge.textContent = status;
+    row.appendChild(badge);
+    row.title = `${row.title}\ngit: ${gitStatusLabels[status] || status}`;
+  }
+
+  function createTreeEntryRow({ root, relativePath, entry, excluded = false, showMtime = true, showGitStatus = true, fileIcon = fileIconElement, onDirectory, onFile, onDoubleClick, onAuxClick, onContextMenu }) {
+    const childPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+    const row = document.createElement("div");
+    row.className = `tree-row file-browser-tree-row ${entry.is_dir ? "dir" : "file"}${excluded ? " excluded" : ""}`;
+    row.dataset.rel = childPath;
+    row.dataset.path = childPath;
+    row.dataset.kind = entry.is_dir ? "dir" : "file";
+    row.tabIndex = 0;
+    row.title = `${root}/${childPath}`;
+    const name = document.createElement("span");
+    name.className = "tree-name";
+    name.textContent = entry.name;
+    if (entry.is_dir) {
+      const chevron = document.createElement("span");
+      chevron.className = "codicon codicon-chevron-right tree-chevron";
+      const icon = document.createElement("img");
+      icon.className = "tree-type-icon tree-folder-icon";
+      // Neutral grey outline, matching the main file tree -- colour belongs to the file icons.
+      icon.src = `${termdeckIconsBase}folder.svg`;
+      icon.onerror = () => { icon.src = `${materialIconsBase}folder.svg`; };
+      row.append(chevron, icon, name);
+      row.onclick = () => onDirectory?.(row, childPath);
+    } else {
+      const spacer = document.createElement("span");
+      spacer.className = "tree-file-spacer";
+      row.append(spacer, fileIcon(entry.name), name);
+      row.onclick = (event) => onFile?.(event, row, childPath);
+      row.ondblclick = () => onDoubleClick?.(row, childPath);
+      row.onauxclick = (event) => onAuxClick?.(event, row, childPath);
+    }
+    appendEntryMetadata(row, entry, { showMtime, showGitStatus });
+    row.oncontextmenu = (event) => onContextMenu?.(event, row, childPath);
+    return row;
+  }
+
+  return { materialIconsBase, alwaysExcluded, fileIconElement, formatMtime, appendEntryMetadata, createTreeEntryRow };
+})();

filedeck/__init__.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+
+STATIC_DIR = Path(__file__).resolve().parent / "static"

filedeck/git_history_service.py

@@ -0,0 +1,191 @@
+import subprocess
+from pathlib import Path
+from typing import TypedDict
+
+
+class GitReference(TypedDict):
+    name: str
+    full_name: str
+    kind: str
+    commit_id: str
+    current: bool
+
+
+class GitComparisonFile(TypedDict):
+    path: str
+    previous_path: str
+    status: str
+
+
+class GitComparison(TypedDict):
+    base: str
+    target: str
+    base_id: str
+    target_id: str
+    files: list[GitComparisonFile]
+
+
+class GitDivergenceCommit(TypedDict):
+    commit_id: str
+    short_id: str
+    subject: str
+    author: str
+    committed_at: int
+
+
+class GitDivergence(TypedDict):
+    upstream: str
+    incoming: list[GitDivergenceCommit]
+    outgoing: list[GitDivergenceCommit]
+
+
+class GitComparisonReview(TypedDict):
+    path: str
+    scope: str
+    original: str
+    modified: str
+    original_label: str
+    modified_label: str
+
+
+class GitHistoryService:
+    MAX_REFS = 500
+    MAX_COMMITS = 200
+    MAX_REVIEW_BYTES = 2 * 1024 * 1024
+
+    def list_references(self, requested_root: Path) -> list[GitReference]:
+        repository_root = self.repository_root(requested_root)
+        result = self._run_git(repository_root, ["for-each-ref", "--format=%(refname)%00%(refname:short)%00%(objectname)%00%(HEAD)%00%(*objectname)",
+                                                    "refs/heads", "refs/remotes", "refs/tags"])
+        references: list[GitReference] = []
+        for line in result.stdout.decode("utf-8", errors="replace").splitlines()[:self.MAX_REFS]:
+            fields = (line.split("\x00", 4) + ["", "", "", ""])[:5]
+            if fields[1].endswith("/HEAD"):
+                continue
+            kind = "tag" if fields[0].startswith("refs/tags/") else "remote" if fields[0].startswith("refs/remotes/") else "branch"
+            commit_id = fields[4] or fields[2]
+            references.append({"name": fields[1], "full_name": fields[0], "kind": kind, "commit_id": commit_id,
+                               "current": fields[3].strip() == "*"})
+        return references
+
+    def compare_revisions(self, requested_root: Path, base: str, target: str) -> GitComparison:
+        repository_root = self.repository_root(requested_root)
+        base_id = self.validated_revision(repository_root, base)
+        target_id = self.validated_revision(repository_root, target)
+        result = self._run_git(repository_root, ["diff", "--name-status", "-z", "--find-renames", base_id, target_id])
+        return {"base": base.strip(), "target": target.strip(), "base_id": base_id, "target_id": target_id,
+                "files": self._parse_name_status(result.stdout)}
+
+    def review_comparison_file(self, requested_root: Path, path: str, previous_path: str, base: str,
+                               target: str) -> GitComparisonReview:
+        repository_root = self.repository_root(requested_root)
+        base_id = self.validated_revision(repository_root, base)
+        target_id = self.validated_revision(repository_root, target)
+        selected_path = self.validated_path(repository_root, path)
+        original_path = self.validated_path(repository_root, previous_path or path)
+        original = self._revision_content(repository_root, base_id, original_path)
+        modified = self._revision_content(repository_root, target_id, selected_path)
+        return {"path": selected_path, "scope": "compare", "original": original, "modified": modified,
+                "original_label": base.strip(), "modified_label": target.strip()}
+
+    def incoming_outgoing(self, requested_root: Path, remote: str = "", branch: str = "") -> GitDivergence:
+        repository_root = self.repository_root(requested_root)
+        upstream = f"{self.validated_reference_component(remote)}/{self.validated_reference_component(branch)}" if remote and branch else "@{upstream}"
+        upstream_result = self._run_git(repository_root, ["rev-parse", "--verify", f"{upstream}^{{commit}}"], {0, 128})
+        if upstream_result.returncode != 0:
+            if remote and branch:
+                return {"upstream": upstream, "incoming": [], "outgoing": self._log_range(repository_root, "HEAD")}
+            detail = upstream_result.stderr.decode("utf-8", errors="replace").strip()
+            raise OSError(detail or "the current branch has no upstream")
+        upstream_id = upstream_result.stdout.decode("utf-8", errors="replace").strip()
+        incoming = self._log_range(repository_root, f"HEAD..{upstream_id}")
+        outgoing = self._log_range(repository_root, f"{upstream_id}..HEAD")
+        return {"upstream": upstream, "incoming": incoming, "outgoing": outgoing}
+
+    def repository_root(self, requested_root: Path) -> Path:
+        requested = requested_root.expanduser().resolve()
+        result = self._run_git(requested, ["rev-parse", "--show-toplevel"])
+        repository_root = Path(result.stdout.decode("utf-8", errors="replace").strip()).resolve()
+        if not repository_root.is_dir():
+            raise FileNotFoundError(str(repository_root))
+        return repository_root
+
+    @classmethod
+    def validated_revision(cls, repository_root: Path, revision: str) -> str:
+        normalized = revision.strip()
+        if not normalized or len(normalized) > 200 or normalized.startswith("-") or any(character in normalized for character in "\x00\r\n"):
+            raise ValueError(f"invalid Git revision: {revision}")
+        result = cls._run_git(repository_root, ["rev-parse", "--verify", f"{normalized}^{{commit}}"])
+        return result.stdout.decode("utf-8", errors="replace").strip()
+
+    @staticmethod
+    def validated_reference_component(value: str) -> str:
+        normalized = value.strip()
+        if not normalized or len(normalized) > 200 or normalized.startswith("-") or ".." in normalized or any(
+                character in normalized for character in "\x00\r\n ~^:?*[\\"):
+            raise ValueError(f"invalid Git reference: {value}")
+        return normalized
+
+    @staticmethod
+    def validated_path(repository_root: Path, path: str) -> str:
+        if not path.strip() or any(character in path for character in "\x00\r\n"):
+            raise ValueError(f"invalid Git path: {path}")
+        target = (repository_root / path).resolve()
+        if not target.is_relative_to(repository_root):
+            raise ValueError(f"path outside repository: {path}")
+        return str(target.relative_to(repository_root))
+
+    @classmethod
+    def _revision_content(cls, repository_root: Path, revision: str, path: str) -> str:
+        result = cls._run_git(repository_root, ["show", f"{revision}:{path}"], {0, 128})
+        if result.returncode != 0:
+            return ""
+        if len(result.stdout) > cls.MAX_REVIEW_BYTES:
+            raise ValueError(f"file exceeds the {cls.MAX_REVIEW_BYTES // (1024 * 1024)} MB Git review limit")
+        if b"\x00" in result.stdout:
+            raise ValueError("binary files cannot be reviewed in the text diff editor")
+        return result.stdout.decode("utf-8", errors="replace")
+
+    @classmethod
+    def _log_range(cls, repository_root: Path, revision_range: str) -> list[GitDivergenceCommit]:
+        result = cls._run_git(repository_root, ["log", f"--max-count={cls.MAX_COMMITS}",
+                                                "--format=%H%x00%h%x00%s%x00%an%x00%ct", revision_range])
+        commits: list[GitDivergenceCommit] = []
+        for line in result.stdout.decode("utf-8", errors="replace").splitlines():
+            fields = line.split("\x00", 4)
+            if len(fields) == 5:
+                commits.append({"commit_id": fields[0], "short_id": fields[1], "subject": fields[2],
+                                "author": fields[3], "committed_at": int(fields[4])})
+        return commits
+
+    @staticmethod
+    def _parse_name_status(raw_files: bytes) -> list[GitComparisonFile]:
+        tokens = [token.decode("utf-8", errors="replace") for token in raw_files.split(b"\x00") if token]
+        files: list[GitComparisonFile] = []
+        token_index = 0
+        while token_index < len(tokens):
+            status = tokens[token_index]
+            token_index += 1
+            if token_index >= len(tokens):
+                raise OSError("invalid Git comparison file list")
+            previous_path = ""
+            path = tokens[token_index]
+            token_index += 1
+            if status.startswith(("R", "C")):
+                if token_index >= len(tokens):
+                    raise OSError("invalid Git comparison rename list")
+                previous_path, path = path, tokens[token_index]
+                token_index += 1
+            files.append({"path": path, "previous_path": previous_path, "status": status[:1]})
+        return files
+
+    @staticmethod
+    def _run_git(repository_root: Path, arguments: list[str], allow_return_codes: set[int] | None = None,
+                 timeout: int = 30) -> subprocess.CompletedProcess[bytes]:
+        result = subprocess.run(["git", "-C", str(repository_root), *arguments], capture_output=True,
+                                timeout=timeout, check=False)
+        if result.returncode not in (allow_return_codes or {0}):
+            detail = result.stderr.decode("utf-8", errors="replace").strip()
+            output = result.stdout.decode("utf-8", errors="replace").strip()
+            raise OSError(detail or output or "git command failed")
+        return result

filedeck/git_hunk_service.py

@@ -0,0 +1,144 @@
+import hashlib
+import re
+import subprocess
+from pathlib import Path
+from typing import TypedDict
+
+
+class GitDiffHunk(TypedDict):
+    hunk_id: str
+    scope: str
+    path: str
+    old_start: int
+    old_count: int
+    new_start: int
+    new_count: int
+    kind: str
+    heading: str
+
+
+class GitFileHunks(TypedDict):
+    path: str
+    working: list[GitDiffHunk]
+    staged: list[GitDiffHunk]
+
+
+class GitHunkService:
+    HUNK_HEADER_PATTERN = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$")
+    MAX_PATCH_BYTES = 2 * 1024 * 1024
+
+    def file_hunks(self, requested_root: Path, path: str) -> GitFileHunks:
+        repository_root = self.repository_root(requested_root)
+        selected_path = self.validated_path(repository_root, path)
+        working_patch = self._run_git(repository_root, ["diff", "--no-ext-diff", "--binary", "--unified=3", "--", selected_path]).stdout
+        staged_patch = self._run_git(repository_root, ["diff", "--cached", "--no-ext-diff", "--binary", "--unified=3",
+                                                        "--", selected_path]).stdout
+        return {"path": selected_path, "working": self._parse_patch(selected_path, "working", working_patch),
+                "staged": self._parse_patch(selected_path, "staged", staged_patch)}
+
+    def apply_hunk_action(self, requested_root: Path, path: str, scope: str, hunk_id: str, action: str) -> GitFileHunks:
+        repository_root = self.repository_root(requested_root)
+        selected_path = self.validated_path(repository_root, path)
+        patch_bytes, hunk = self._current_hunk_patch(repository_root, selected_path, scope, hunk_id)
+        if action == "stage" and scope == "working":
+            self._apply_patch(repository_root, ["apply", "--cached", "--whitespace=nowarn", "-"], patch_bytes)
+        elif action == "unstage" and scope == "staged":
+            self._apply_patch(repository_root, ["apply", "--cached", "--reverse", "--whitespace=nowarn", "-"], patch_bytes)
+        elif action == "revert" and scope == "working":
+            self._apply_patch(repository_root, ["apply", "--reverse", "--whitespace=nowarn", "-"], patch_bytes)
+        elif action == "revert" and scope == "staged":
+            self._apply_patch(repository_root, ["apply", "--reverse", "--check", "-"], patch_bytes)
+            self._apply_patch(repository_root, ["apply", "--cached", "--reverse", "--check", "-"], patch_bytes)
+            self._apply_patch(repository_root, ["apply", "--reverse", "--whitespace=nowarn", "-"], patch_bytes)
+            self._apply_patch(repository_root, ["apply", "--cached", "--reverse", "--whitespace=nowarn", "-"], patch_bytes)
+        else:
+            raise ValueError(f"unsupported {action} action for {scope} hunk {hunk['hunk_id']}")
+        return self.file_hunks(repository_root, selected_path)
+
+    def repository_root(self, requested_root: Path) -> Path:
+        requested = requested_root.expanduser().resolve()
+        result = self._run_git(requested, ["rev-parse", "--show-toplevel"])
+        repository_root = Path(result.stdout.decode("utf-8", errors="replace").strip()).resolve()
+        if not repository_root.is_dir():
+            raise FileNotFoundError(str(repository_root))
+        return repository_root
+
+    @staticmethod
+    def validated_path(repository_root: Path, path: str) -> str:
+        if not path.strip() or any(character in path for character in "\x00\r\n"):
+            raise ValueError(f"invalid Git path: {path}")
+        target = (repository_root / path).resolve()
+        if not target.is_relative_to(repository_root):
+            raise ValueError(f"path outside repository: {path}")
+        return str(target.relative_to(repository_root))
+
+    def _current_hunk_patch(self, repository_root: Path, path: str, scope: str,
+                            hunk_id: str) -> tuple[bytes, GitDiffHunk]:
+        if scope not in {"working", "staged"}:
+            raise ValueError(f"invalid Git hunk scope: {scope}")
+        arguments = ["diff"]
+        if scope == "staged":
+            arguments.append("--cached")
+        arguments.extend(["--no-ext-diff", "--binary", "--unified=3", "--", path])
+        patch = self._run_git(repository_root, arguments).stdout
+        for parsed_patch, hunk in self._parse_patch_with_content(path, scope, patch):
+            if hunk["hunk_id"] == hunk_id:
+                return parsed_patch, hunk
+        raise ValueError("the selected Git hunk is stale; refresh the file and try again")
+
+    def _parse_patch(self, path: str, scope: str, patch: bytes) -> list[GitDiffHunk]:
+        return [hunk for _, hunk in self._parse_patch_with_content(path, scope, patch)]
+
+    def _parse_patch_with_content(self, path: str, scope: str, patch: bytes) -> list[tuple[bytes, GitDiffHunk]]:
+        if len(patch) > self.MAX_PATCH_BYTES:
+            raise ValueError(f"Git diff exceeds the {self.MAX_PATCH_BYTES // (1024 * 1024)} MB hunk limit")
+        lines = patch.decode("utf-8", errors="replace").splitlines(keepends=True)
+        first_hunk_index = next((index for index, line in enumerate(lines) if line.startswith("@@ ")), -1)
+        if first_hunk_index < 0:
+            return []
+        file_header = "".join(lines[:first_hunk_index])
+        hunk_starts = [index for index, line in enumerate(lines) if line.startswith("@@ ")]
+        parsed: list[tuple[bytes, GitDiffHunk]] = []
+        for position, start_index in enumerate(hunk_starts):
+            end_index = hunk_starts[position + 1] if position + 1 < len(hunk_starts) else len(lines)
+            hunk_lines = lines[start_index:end_index]
+            match = self.HUNK_HEADER_PATTERN.match(hunk_lines[0].rstrip("\r\n"))
+            if not match:
+                raise OSError(f"invalid Git hunk header: {hunk_lines[0].strip()}")
+            old_start, old_count = int(match.group(1)), int(match.group(2) or "1")
+            new_start, new_count = int(match.group(3)), int(match.group(4) or "1")
+            patch_text = file_header + "".join(hunk_lines)
+            hunk_id = hashlib.sha256(f"{scope}\x00{patch_text}".encode()).hexdigest()[:20]
+            kind = "added" if old_count == 0 else "deleted" if new_count == 0 else "modified"
+            heading = match.group(5).strip() or self._first_changed_line(hunk_lines[1:])
+            parsed.append((patch_text.encode(), {"hunk_id": hunk_id, "scope": scope, "path": path,
+                                                 "old_start": old_start, "old_count": old_count,
+                                                 "new_start": new_start, "new_count": new_count,
+                                                 "kind": kind, "heading": heading}))
+        return parsed
+
+    @staticmethod
+    def _first_changed_line(lines: list[str]) -> str:
+        for line in lines:
+            if line.startswith(("+", "-")) and not line.startswith(("+++", "---")):
+                return line[1:].strip()[:120]
+        return "Changed lines"
+
+    @staticmethod
+    def _apply_patch(repository_root: Path, arguments: list[str], patch: bytes) -> None:
+        result = subprocess.run(["git", "-C", str(repository_root), *arguments], input=patch, capture_output=True,
+                                timeout=30, check=False)
+        if result.returncode != 0:
+            detail = result.stderr.decode("utf-8", errors="replace").strip()
+            output = result.stdout.decode("utf-8", errors="replace").strip()
+            raise OSError(detail or output or "Git hunk operation failed")
+
+    @staticmethod
+    def _run_git(repository_root: Path, arguments: list[str], timeout: int = 30) -> subprocess.CompletedProcess[bytes]:
+        result = subprocess.run(["git", "-C", str(repository_root), *arguments], capture_output=True,
+                                timeout=timeout, check=False)
+        if result.returncode != 0:
+            detail = result.stderr.decode("utf-8", errors="replace").strip()
+            output = result.stdout.decode("utf-8", errors="replace").strip()
+            raise OSError(detail or output or "git command failed")
+        return result