commandertui 1.0.0__py3-none-any.whl

commandertui/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

commandertui/app.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import os
+
+from textual.app import App
+
+from .boot import BootScreen
+from .main_screen import MainScreen
+from .theme import css_for
+
+
+class CommanderApp(App):
+    """Owns only the screen stack. All pane behavior lives in MainScreen --
+    see its docstring for why that split matters for key bindings.
+    """
+
+    CSS = css_for("green")
+
+    def __init__(self, left_path: str | None = None, right_path: str | None = None) -> None:
+        super().__init__()
+        self.left_path = os.path.abspath(left_path or os.path.expanduser("~"))
+        self.right_path = os.path.abspath(right_path or os.path.expanduser("~"))
+
+    def on_mount(self) -> None:
+        self.push_screen(MainScreen(self.left_path, self.right_path))
+        self.push_screen(BootScreen())
+
+    # Convenience passthroughs so existing tests/tools that poke at the app
+    # directly (e.g. app._panel("left")) keep working without knowing about
+    # the MainScreen split.
+    def _panel(self, side: str):
+        return self.main_screen._panel(side)
+
+    @property
+    def main_screen(self) -> MainScreen:
+        return next(s for s in self.screen_stack if isinstance(s, MainScreen))
+
+    @property
+    def active_side(self) -> str:
+        return self.main_screen.active_side

commandertui/ascii_font.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+# A minimal 5x5 block-letter font, just enough for "COMMANDER". Handwritten
+# once here rather than pulled from a figlet dependency -- it's nine glyphs,
+# not worth a library.
+_FONT: dict[str, list[str]] = {
+    "A": [" ### ", "#   #", "#####", "#   #", "#   #"],
+    "C": [" ####", "#    ", "#    ", "#    ", " ####"],
+    "D": ["#### ", "#   #", "#   #", "#   #", "#### "],
+    "E": ["#####", "#    ", "#### ", "#    ", "#####"],
+    "M": ["#   #", "## ##", "# # #", "#   #", "#   #"],
+    "N": ["#   #", "##  #", "# # #", "#  ##", "#   #"],
+    "O": [" ### ", "#   #", "#   #", "#   #", " ### "],
+    "R": ["#### ", "#   #", "#### ", "#  # ", "#   #"],
+}
+
+BLOCK = "█"  # solid block, swapped in for the '#' placeholders above
+
+
+def banner(word: str, gap: int = 1) -> str:
+    """Render `word` as 5 lines of block letters."""
+    letters = [_FONT[ch] for ch in word.upper()]
+    sep = " " * gap
+    rows = []
+    for row_index in range(5):
+        rows.append(sep.join(letter[row_index] for letter in letters).replace("#", BLOCK))
+    return "\n".join(rows)

commandertui/bookmarks.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+
+CONFIG_DIR = os.path.expanduser("~/.config/commandertui")
+BOOKMARKS_FILE = os.path.join(CONFIG_DIR, "bookmarks.json")
+
+# Where Linux desktops mount removable/network drives.
+MOUNT_ROOTS = ("/run/media", "/media", "/mnt")
+
+# Nautilus (and GNOME apps generally) mount network shares -- SMB, FTP,
+# SFTP -- through GVFS rather than udisks2, so they never show up under
+# MOUNT_ROOTS. They land here instead, one FUSE directory per connection.
+GVFS_ROOT = f"/run/user/{os.getuid()}/gvfs"
+
+
+@dataclass(frozen=True)
+class Place:
+    label: str
+    path: str
+    kind: str  # "mounted" | "saved" | "home"
+
+
+def detect_mounted() -> list[Place]:
+    places: list[Place] = []
+    for root in MOUNT_ROOTS:
+        if not os.path.isdir(root):
+            continue
+        try:
+            for user_dir in os.scandir(root):
+                if not user_dir.is_dir():
+                    continue
+                # /run/media/<user>/<Label> vs /mnt/<Label> (no user subdir)
+                candidates = list(os.scandir(user_dir.path)) if root == "/run/media" else [user_dir]
+                for c in candidates:
+                    # An on-demand mount point (e.g. /mnt/i7server) exists as
+                    # an empty directory even when nothing is mounted there --
+                    # os.path.ismount() is what actually tells them apart.
+                    if c.is_dir() and os.path.ismount(c.path):
+                        places.append(Place(label=c.name, path=c.path, kind="mounted"))
+        except PermissionError:
+            continue
+    return places
+
+
+def _label_for_gvfs_entry(name: str) -> str:
+    """GVFS names a mount after its full connection URI, e.g.
+    'smb-share:server=192.168.1.10,share=Media' -- turn that into something
+    a human would recognize, falling back to the raw name if it's a shape
+    we don't specifically parse (sftp, ftp, google-drive, ...).
+    """
+    _scheme, _, rest = name.partition(":")
+    params = dict(pair.split("=", 1) for pair in rest.split(",") if "=" in pair)
+    share = params.get("share")
+    server = params.get("server") or params.get("host")
+    if share and server:
+        return f"{share} @ {server}"
+    return server or name
+
+
+def detect_network_mounts() -> list[Place]:
+    if not os.path.isdir(GVFS_ROOT):
+        return []
+    try:
+        return [
+            Place(label=_label_for_gvfs_entry(entry.name), path=entry.path, kind="network")
+            for entry in os.scandir(GVFS_ROOT)
+            if entry.is_dir()
+        ]
+    except PermissionError:
+        return []
+
+
+PROC_MOUNTS = "/proc/mounts"
+
+
+def _unescape_mount_path(path: str) -> str:
+    # /proc/mounts octal-escapes whitespace and backslashes in paths.
+    return path.replace("\\040", " ").replace("\\011", "\t").replace("\\012", "\n").replace("\\134", "\\")
+
+
+def detect_home_mounts() -> list[Place]:
+    """FUSE mounts inside $HOME, e.g. rclone's ~/365 and ~/GoogleDrive.
+    Read from /proc/mounts so only what is live right now shows up."""
+    home = os.path.expanduser("~")
+    try:
+        with open(PROC_MOUNTS) as f:
+            lines = f.readlines()
+    except OSError:
+        return []
+    places: list[Place] = []
+    for line in lines:
+        parts = line.split()
+        if len(parts) < 3 or not parts[2].startswith("fuse."):
+            continue
+        path = _unescape_mount_path(parts[1])
+        if path.startswith(home + os.sep):
+            places.append(Place(label=os.path.basename(path), path=path, kind=parts[2][5:]))
+    return places
+
+
+def load_saved() -> list[Place]:
+    if not os.path.isfile(BOOKMARKS_FILE):
+        return []
+    try:
+        with open(BOOKMARKS_FILE) as f:
+            data = json.load(f)
+        return [Place(label=b["label"], path=b["path"], kind="saved") for b in data]
+    except Exception:
+        return []
+
+
+def save_bookmark(label: str, path: str) -> None:
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    saved = load_saved()
+    saved = [b for b in saved if b.path != path]
+    saved.append(Place(label=label, path=path, kind="saved"))
+    with open(BOOKMARKS_FILE, "w") as f:
+        json.dump([{"label": b.label, "path": b.path} for b in saved], f, indent=2)
+
+
+def remove_bookmark(path: str) -> None:
+    saved = [b for b in load_saved() if b.path != path]
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    with open(BOOKMARKS_FILE, "w") as f:
+        json.dump([{"label": b.label, "path": b.path} for b in saved], f, indent=2)
+
+
+def all_places() -> list[Place]:
+    home = Place(label="Home", path=os.path.expanduser("~"), kind="home")
+    return [home] + detect_mounted() + detect_network_mounts() + detect_home_mounts() + load_saved()

commandertui/boot.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.screen import Screen
+from textual.widgets import Static
+
+from .ascii_font import banner
+
+CURSOR = "█"  # solid block, like a CRT text cursor
+
+
+def _build_art() -> str:
+    title_lines = banner("COMMANDER").split("\n")
+    body_lines = [
+        "",
+        "T U I  --  dual-pane file manager",
+        "",
+        "CONNECT 2400 ...................... OK",
+        "LOADING PANELS ..................... OK",
+        "READY.",
+    ]
+    content = title_lines + body_lines
+    width = max(len(line) for line in content) + 2  # 1 space padding each side
+
+    def pad(line: str) -> str:
+        return f"|{line.center(width)}|"
+
+    border = "+" + "-" * width + "+"
+    boxed = [border] + [pad(line) for line in content] + [border]
+    return "\n".join(boxed)
+
+
+ART = _build_art()
+
+
+class BootScreen(Screen):
+    """A brief modem-style 'printing' reveal shown once at startup.
+
+    Purely cosmetic: it reveals ART character by character with a visible
+    cursor, like text arriving over a slow serial line. Once fully drawn it
+    waits on screen for an explicit [Enter] rather than auto-dismissing --
+    the point is to actually see the drawing happen, not blink and miss it.
+    """
+
+    DEFAULT_CSS = """
+    BootScreen {
+        align: center middle;
+    }
+    #boot-text {
+        width: auto;
+        height: auto;
+    }
+    #boot-hint {
+        width: auto;
+        height: auto;
+        text-align: center;
+        margin-top: 1;
+    }
+    """
+
+    BINDINGS = [Binding("enter", "continue_", "Continue", priority=True)]
+
+    def __init__(
+        self,
+        art: str = ART,
+        chars_per_tick: int = 3,
+        tick_seconds: float = 0.035,
+        bell: bool = True,
+    ) -> None:
+        super().__init__()
+        self.art = art
+        self.chars_per_tick = chars_per_tick
+        self.tick_seconds = tick_seconds
+        self.bell = bell
+        self._pos = 0
+        self._timer = None
+        self._done = False
+
+    def compose(self) -> ComposeResult:
+        # No Center/Middle wrapper containers: those default to width 100%,
+        # which meant "align: center" had nothing to actually center -- the
+        # boxed art rendered flush against the left edge instead. `width:
+        # auto` on the Static itself (set in DEFAULT_CSS) is what lets the
+        # screen's own `align: center middle` actually center it as a block.
+        yield Static("", id="boot-text")
+        yield Static("", id="boot-hint")
+
+    def on_mount(self) -> None:
+        self._timer = self.set_interval(self.tick_seconds, self._tick)
+
+    def _tick(self) -> None:
+        self._pos = min(len(self.art), self._pos + self.chars_per_tick)
+        widget = self.query_one("#boot-text", Static)
+        visible = self.art[: self._pos]
+        cursor = CURSOR if self._pos < len(self.art) else ""
+        widget.update(visible + cursor)
+
+        if self._pos >= len(self.art):
+            self._done = True
+            if self._timer is not None:
+                self._timer.stop()
+            if self.bell:
+                self.app.bell()
+            self.query_one("#boot-hint", Static).update("[ENTER] to continue")
+
+    def action_continue_(self) -> None:
+        if not self._done:
+            # Not drawn yet: Enter fast-forwards straight to the final frame
+            # instead of doing nothing, in case someone doesn't want to wait.
+            self._pos = len(self.art)
+            self._tick()
+            return
+        self.dismiss()

commandertui/cli.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import argparse
+import os
+
+from . import __version__
+from .app import CommanderApp
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="commandertui", description="Dual-pane TUI file manager")
+    parser.add_argument("left", nargs="?", default=os.path.expanduser("~"))
+    parser.add_argument("right", nargs="?", default=os.path.expanduser("~"))
+    parser.add_argument("--version", action="version", version=f"commandertui {__version__}")
+    args = parser.parse_args()
+
+    app = CommanderApp(left_path=args.left, right_path=args.right)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

commandertui/compare_screen.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import DataTable, Footer, Static
+
+from .diff import compare
+from .modals import MessageScreen
+from .models import DiffStatus, OpKind, OpSide, OperationQueue, QueuedOp
+from .plan import plan_mirror, plan_two_way, plan_update
+from .run_queue import run_queue_with_progress
+
+STATUS_LABEL = {
+    DiffStatus.LEFT_ONLY: "< only left",
+    DiffStatus.RIGHT_ONLY: "> only right",
+    DiffStatus.MODIFIED: "! modified",
+    DiffStatus.IDENTICAL: "= identical",
+}
+
+
+class CompareScreen(Screen):
+    """Full recursive diff between the two panes' current directories, with
+    bulk actions (mirror/update/two-way) or per-item manual handling.
+    """
+
+    # priority=True: same reason as CommanderApp -- the focused DataTable
+    # would otherwise intercept space/enter-like keys before we see them.
+    BINDINGS = [
+        Binding("escape", "back", "Back", priority=True),
+        Binding("m", "mirror", "Mirror ->", priority=True),
+        Binding("u", "update", "Update ->", priority=True),
+        Binding("b", "two_way", "Two-way", priority=True),
+        Binding("space", "toggle_manual", "Mark", priority=True),
+        Binding("c", "copy_manual", "Copy marked ->", priority=True),
+    ]
+
+    def __init__(self, left_root: str, right_root: str) -> None:
+        super().__init__()
+        self.left_root = left_root
+        self.right_root = right_root
+        self.manual_marks: set[str] = set()
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="compare-summary")
+        yield DataTable(id="compare-table", cursor_type="row")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.reload()
+
+    def reload(self) -> None:
+        self.diffs = compare(self.left_root, self.right_root)
+        table = self.query_one("#compare-table", DataTable)
+        table.clear(columns=True)
+        table.add_columns(" ", "Path", "Status")
+        for d in self.diffs:
+            if d.status == DiffStatus.IDENTICAL:
+                continue
+            mark = "*" if d.rel_path in self.manual_marks else ""
+            table.add_row(mark, d.rel_path, STATUS_LABEL[d.status], key=d.rel_path)
+
+        non_identical = sum(1 for d in self.diffs if d.status != DiffStatus.IDENTICAL)
+        summary = self.query_one("#compare-summary", Static)
+        summary.update(
+            f"{self.left_root}  <->  {self.right_root}\n"
+            f"{non_identical} differences   "
+            "[m]irror  [u]pdate  [b]idirectional  [space] mark  [c]opy marked  [esc] back"
+        )
+
+    def action_back(self) -> None:
+        self.dismiss()
+
+    def _run_queue(self, title: str, queue: OperationQueue) -> None:
+        run_queue_with_progress(
+            self, title, queue, self.left_root, self.right_root, after=lambda report: self.reload()
+        )
+
+    def action_mirror(self) -> None:
+        active = [d for d in self.diffs if d.status != DiffStatus.IDENTICAL]
+        self._run_queue("Mirror: make RIGHT identical to LEFT", plan_mirror(active))
+
+    def action_update(self) -> None:
+        active = [d for d in self.diffs if d.status != DiffStatus.IDENTICAL]
+        self._run_queue("Update: copy new/changed LEFT -> RIGHT (no deletes)", plan_update(active))
+
+    def action_two_way(self) -> None:
+        active = [d for d in self.diffs if d.status != DiffStatus.IDENTICAL]
+        queue, conflicts = plan_two_way(active)
+        if conflicts:
+            names = "\n".join(f"  {c.rel_path}" for c in conflicts[:10])
+            self.app.push_screen(
+                MessageScreen(
+                    f"{len(conflicts)} conflict(s) changed on both sides -- "
+                    f"resolve manually with [space]+[c]:\n{names}"
+                )
+            )
+        self._run_queue("Two-way: propagate each side's exclusive changes", queue)
+
+    def action_toggle_manual(self) -> None:
+        table = self.query_one("#compare-table", DataTable)
+        if table.row_count == 0:
+            return
+        row_key = table.coordinate_to_cell_key(table.cursor_coordinate).row_key
+        if row_key is None or row_key.value is None:
+            return
+        rel_path = str(row_key.value)
+        if rel_path in self.manual_marks:
+            self.manual_marks.discard(rel_path)
+        else:
+            self.manual_marks.add(rel_path)
+        self.reload()
+
+    def action_copy_manual(self) -> None:
+        if not self.manual_marks:
+            self.app.push_screen(MessageScreen("No items marked. Use [space] first."))
+            return
+        by_path = {d.rel_path: d for d in self.diffs}
+        queue = OperationQueue()
+        for rel_path in self.manual_marks:
+            d = by_path.get(rel_path)
+            if d is None:
+                continue
+            if d.status == DiffStatus.LEFT_ONLY or (d.status == DiffStatus.MODIFIED and d.left):
+                queue.add(
+                    QueuedOp(
+                        OpKind.COPY,
+                        OpSide.LEFT_TO_RIGHT,
+                        rel_path,
+                        bool(d.left and d.left.kind.value == "dir"),
+                        size=d.left.size if d.left else 0,
+                    )
+                )
+            elif d.status == DiffStatus.RIGHT_ONLY:
+                queue.add(
+                    QueuedOp(
+                        OpKind.COPY,
+                        OpSide.RIGHT_TO_LEFT,
+                        rel_path,
+                        bool(d.right and d.right.kind.value == "dir"),
+                        size=d.right.size if d.right else 0,
+                    )
+                )
+        self.manual_marks.clear()
+        self._run_queue("Copy marked items", queue)

commandertui/diff.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import os
+
+from .models import DiffEntry, DiffStatus, EntryKind
+from .scanner import DEFAULT_EXCLUSIONS, scan_directory
+
+# Files that differ by mtime alone (common after a plain copy that touched
+# metadata) but are otherwise identical should not be flagged as modified.
+MTIME_TOLERANCE_SECONDS = 2.0
+
+
+def compare(
+    left_root: str,
+    right_root: str,
+    exclusions: set[str] = frozenset(DEFAULT_EXCLUSIONS),
+    cancel_check=None,
+) -> list[DiffEntry]:
+    if not os.path.isdir(left_root) or not os.path.isdir(right_root):
+        raise FileNotFoundError("One or both paths do not exist")
+
+    left = scan_directory(left_root, exclusions, cancel_check)
+    if cancel_check and cancel_check():
+        return []
+    right = scan_directory(right_root, exclusions, cancel_check)
+    if cancel_check and cancel_check():
+        return []
+
+    all_paths = sorted(set(left) | set(right))
+    diffs: list[DiffEntry] = []
+
+    for rel_path in all_paths:
+        l = left.get(rel_path)
+        r = right.get(rel_path)
+        name = (l or r).name
+
+        if l and not r:
+            status = DiffStatus.LEFT_ONLY
+        elif r and not l:
+            status = DiffStatus.RIGHT_ONLY
+        elif l.kind == EntryKind.DIR and r.kind == EntryKind.DIR:
+            status = DiffStatus.IDENTICAL
+        elif l.kind != r.kind:
+            status = DiffStatus.MODIFIED
+        elif l.size != r.size:
+            status = DiffStatus.MODIFIED
+        elif abs(l.mtime - r.mtime) > MTIME_TOLERANCE_SECONDS:
+            status = DiffStatus.MODIFIED
+        else:
+            status = DiffStatus.IDENTICAL
+
+        diffs.append(DiffEntry(rel_path=rel_path, name=name, status=status, left=l, right=r))
+
+    return diffs
+
+
+def summarize(diffs: list[DiffEntry]) -> dict:
+    counts = {status: 0 for status in DiffStatus}
+    for d in diffs:
+        counts[d.status] += 1
+    return {status.value: n for status, n in counts.items()}

commandertui/executor.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Callable
+
+from .models import OpKind, OpSide, OperationQueue
+from .scanner import tree_stats
+from .sync import copy_item, delete_item, move_item
+
+OpProgressCallback = Callable[[int, int, str], None]  # (op_index, op_total, description)
+
+
+@dataclass
+class TransferStatus:
+    file_name: str = ""
+    file_done: int = 0
+    file_total: int = 0
+    files_done: int = 0
+    files_total: int = 0
+    bytes_done: int = 0
+    bytes_total: int = 0
+    ops_done: int = 0
+    ops_total: int = 0
+
+
+TransferCallback = Callable[[TransferStatus], None]
+
+
+@dataclass
+class ExecutionReport:
+    succeeded: int = 0
+    failed: list[tuple[str, str]] = field(default_factory=list)  # (rel_path, error)
+    cancelled: bool = False
+
+
+def execute(
+    queue: OperationQueue,
+    left_root: str,
+    right_root: str,
+    on_progress: OpProgressCallback | None = None,
+    cancel_check: Callable[[], bool] | None = None,
+    on_transfer: TransferCallback | None = None,
+) -> ExecutionReport:
+    report = ExecutionReport()
+    total = len(queue)
+    status = TransferStatus(ops_total=total)
+
+    # Per-op (files, bytes), so the overall bar can snap to the exact
+    # position after each op -- renames and deletes move no bytes but
+    # still have to advance it.
+    op_stats: list[tuple[int, int]] = []
+    if on_transfer:
+        for op in queue.ops:
+            if op.kind == OpKind.DELETE:
+                op_stats.append((0, 0))
+                continue
+            src_root, _ = _roots_for(op.side, left_root, right_root)
+            files, _dirs, size = tree_stats([os.path.join(src_root, op.rel_path)], cancel_check)
+            op_stats.append((files, size))
+        status.files_total = sum(f for f, _ in op_stats)
+        status.bytes_total = sum(b for _, b in op_stats)
+        on_transfer(status)
+
+    base_files = base_bytes = 0
+    current = {"done": 0}
+
+    def file_progress(done: int, file_total: int, name: str) -> None:
+        if done == 0:  # a new file starts
+            status.files_done += 1
+            current["done"] = 0
+        status.bytes_done += done - current["done"]
+        current["done"] = done
+        status.file_name, status.file_done, status.file_total = name, done, file_total
+        on_transfer(status)
+
+    byte_progress = file_progress if on_transfer else None
+
+    for i, op in enumerate(queue.ops):
+        if cancel_check and cancel_check():
+            report.cancelled = True
+            break
+        if on_progress:
+            on_progress(i, total, op.rel_path)
+
+        try:
+            if op.kind == OpKind.COPY:
+                src_root, dst_root = _roots_for(op.side, left_root, right_root)
+                result = copy_item(
+                    os.path.join(src_root, op.rel_path),
+                    os.path.join(dst_root, op.rel_path),
+                    byte_progress,
+                    cancel_check,
+                )
+            elif op.kind == OpKind.MOVE:
+                src_root, dst_root = _roots_for(op.side, left_root, right_root)
+                result = move_item(
+                    os.path.join(src_root, op.rel_path),
+                    os.path.join(dst_root, op.rel_path),
+                    byte_progress,
+                    cancel_check,
+                )
+            else:  # DELETE
+                root = left_root if op.side == OpSide.LEFT else right_root
+                result = delete_item(os.path.join(root, op.rel_path))
+
+            if result.cancelled:
+                report.cancelled = True
+                break
+            if result.ok:
+                report.succeeded += 1
+            else:
+                report.failed.append((op.rel_path, result.error or "unknown error"))
+        except Exception as e:
+            report.failed.append((op.rel_path, str(e)))
+
+        if on_transfer:
+            base_files += op_stats[i][0]
+            base_bytes += op_stats[i][1]
+            status.files_done, status.bytes_done = base_files, base_bytes
+            status.ops_done = i + 1
+            on_transfer(status)
+
+    if on_progress:
+        on_progress(total, total, "done")
+    return report
+
+
+def _roots_for(side: OpSide, left_root: str, right_root: str) -> tuple[str, str]:
+    if side == OpSide.LEFT_TO_RIGHT:
+        return left_root, right_root
+    if side == OpSide.RIGHT_TO_LEFT:
+        return right_root, left_root
+    raise ValueError(f"_roots_for is only valid for cross-pane ops, got {side}")