commandertui 1.4.3__tar.gz → 1.5.1__tar.gz

{commandertui-1.4.3 → commandertui-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commandertui
-Version: 1.4.3
+Version: 1.5.1
 Summary: Dual-pane retro terminal file manager: compare, sync, copy and move folders
 Author: Humberto Barchini
 License-Expression: MIT
@@ -183,7 +183,7 @@ the command that matches how it was installed:
 
 | Installed as | Update runs |
 |---|---|
-| Arch package (`makepkg`) | rebuilds from the release's PKGBUILD with `makepkg -si` (your sudo password is typed in the terminal, never read by the app) |
+| Arch package (`makepkg`) | rebuilds from the release's PKGBUILD with `makepkg -si --nocheck` (tests already ran in the release workflow) (your sudo password is typed in the terminal, never read by the app) |
 | pipx | `pipx upgrade commandertui` |
 | pip | `pip install --upgrade commandertui` |
 | git checkout | no button: the dialog tells you to `git pull` |
@@ -260,3 +260,20 @@ first version, **Claude Opus 5.5** did most of v0.2 and the v1.0 packaging.
 ## License
 
 MIT — see [LICENSE](LICENSE).
+
+
+## Copy/move conflicts
+
+F5 (Copy) and F6 (Move) check the destination before transferring. Existing
+items open a dialog focused on **Skip**: overwrite, skip, rename, or ask for
+each conflict (with **Apply to all remaining**). Copy also offers **Only newer**
+and **Merge** for existing folders; Merge asks how to handle conflicting files.
+Overwrite on folders keeps destination-only files. Repeated source names use
+the same policy; rename selects free `_1`, `_2`, … names.
+
+Transfers run with cancellable progress. Skipped and unfinished sources stay
+marked. Moves verify each copied file before trashing its source; skipped
+and failed files stay in the source. Existing files always require a decision,
+even when size and date match: Overwrite copies/moves them, while Skip (or
+Only newer for identical files) retains them. The completion message reports
+copied, skipped, failed, and identical files retained by a move.

{commandertui-1.4.3 → commandertui-1.5.1}/README.md

@@ -164,7 +164,7 @@ the command that matches how it was installed:
 
 | Installed as | Update runs |
 |---|---|
-| Arch package (`makepkg`) | rebuilds from the release's PKGBUILD with `makepkg -si` (your sudo password is typed in the terminal, never read by the app) |
+| Arch package (`makepkg`) | rebuilds from the release's PKGBUILD with `makepkg -si --nocheck` (tests already ran in the release workflow) (your sudo password is typed in the terminal, never read by the app) |
 | pipx | `pipx upgrade commandertui` |
 | pip | `pip install --upgrade commandertui` |
 | git checkout | no button: the dialog tells you to `git pull` |
@@ -241,3 +241,20 @@ first version, **Claude Opus 5.5** did most of v0.2 and the v1.0 packaging.
 ## License
 
 MIT — see [LICENSE](LICENSE).
+
+
+## Copy/move conflicts
+
+F5 (Copy) and F6 (Move) check the destination before transferring. Existing
+items open a dialog focused on **Skip**: overwrite, skip, rename, or ask for
+each conflict (with **Apply to all remaining**). Copy also offers **Only newer**
+and **Merge** for existing folders; Merge asks how to handle conflicting files.
+Overwrite on folders keeps destination-only files. Repeated source names use
+the same policy; rename selects free `_1`, `_2`, … names.
+
+Transfers run with cancellable progress. Skipped and unfinished sources stay
+marked. Moves verify each copied file before trashing its source; skipped
+and failed files stay in the source. Existing files always require a decision,
+even when size and date match: Overwrite copies/moves them, while Skip (or
+Only newer for identical files) retains them. The completion message reports
+copied, skipped, failed, and identical files retained by a move.

commandertui-1.5.1/commandertui/__init__.py

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

{commandertui-1.4.3 → commandertui-1.5.1}/commandertui/boot.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from textual.app import ComposeResult
 from textual.binding import Binding
 from textual.screen import Screen
+from textual.containers import Vertical
 from textual.widgets import Static
 
 from .ascii_font import banner
@@ -65,9 +66,16 @@ class BootScreen(Screen):
         width: auto;
         height: auto;
     }
-    #boot-hint {
+    #boot-box {
         width: auto;
         height: auto;
+    }
+    #boot-hint {
+        /* 100% of the box, which is as wide as the art: text-align can then
+           really center the hint under it (width:auto hugged the text and
+           left it at the art's left edge). */
+        width: 100%;
+        height: auto;
         text-align: center;
         margin-top: 1;
     }
@@ -100,8 +108,9 @@ class BootScreen(Screen):
         # 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")
+        with Vertical(id="boot-box"):
+            yield Static("", id="boot-text")
+            yield Static("", id="boot-hint")
 
     def on_mount(self) -> None:
         # Double-size title when the window is wide enough for it.

commandertui-1.5.1/commandertui/conflicts.py

@@ -0,0 +1,183 @@
+"""Read-only copy/move collision detection and pure per-entry decisions.
+
+Identity is metadata-based, not a content comparison: SMB/GVFS can report
+misleading sizes/mtimes. As in diff.py, equal sizes and mtimes within two
+seconds count as identical. Every existing file is still a conflict requiring
+an explicit resolution, including metadata-identical files.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+from collections import Counter
+from dataclasses import dataclass, field, replace
+from enum import Enum
+from typing import Literal
+
+from .diff import MTIME_TOLERANCE_SECONDS
+from .models import EntryKind, FileEntry, OpKind
+from .scanner import scan_directory
+
+
+@dataclass(frozen=True)
+class Conflict:
+    rel_path: str
+    name: str
+    src: FileEntry
+    dst: FileEntry
+    kind_mismatch: bool
+    newer: Literal["src", "dst", "same"]
+    identical: bool = False
+
+
+@dataclass
+class ConflictReport:
+    conflicts: list[Conflict] = field(default_factory=list)
+    identical: int = 0
+    dir_collisions: list[str] = field(default_factory=list)
+    total_src_files_new: int = 0
+    duplicate_sources: list[str] = field(default_factory=list)
+    identical_paths: list[str] = field(default_factory=list)
+    conflicts_by_source: dict[str, Conflict] = field(default_factory=dict)
+
+    @property
+    def has_conflicts(self) -> bool:
+        return bool(self.conflicts or self.duplicate_sources)
+
+
+class Resolution(str, Enum):
+    OVERWRITE = "overwrite"
+    SKIP = "skip"
+    ONLY_NEWER = "only_newer"
+    RENAME = "rename"
+    MERGE = "merge"
+    CANCEL = "cancel"
+
+
+def allowed_resolutions(kind: OpKind) -> list[Resolution]:
+    if kind == OpKind.COPY:
+        return list(Resolution)
+    if kind == OpKind.MOVE:
+        return [Resolution.OVERWRITE, Resolution.SKIP, Resolution.RENAME, Resolution.CANCEL]
+    raise ValueError(f"Unsupported operation: {kind}")
+
+
+def rename_target(path: str) -> str:
+    """Suggest a free sibling (not reserved); even dangling symlinks occupy names."""
+    stem, extension = os.path.splitext(path)
+    index = 1
+    while True:
+        candidate = f"{stem}_{index}{extension}"
+        if not os.path.lexists(candidate):
+            return candidate
+        index += 1
+
+
+def resolve(conflict: Conflict, resolution: Resolution) -> Literal["copy", "skip", "rename"]:
+    """Choose an action without touching either side, including for MOVE skips.
+
+    MERGE is a tree-level policy: missing files copy directly, while collisions
+    need another per-file resolution. CANCEL must be handled by the caller.
+    Neither is a valid per-conflict decision here.
+    """
+    if resolution == Resolution.OVERWRITE:
+        return "copy"
+    if resolution == Resolution.SKIP:
+        return "skip"
+    if resolution == Resolution.RENAME:
+        return "rename"
+    if resolution == Resolution.ONLY_NEWER:
+        return "copy" if conflict.newer == "src" else "skip"
+    raise ValueError(f"{resolution} requires caller-level handling")
+
+
+def _entry(path: str, rel_path: str) -> FileEntry:
+    metadata = os.lstat(path)
+    kind = (
+        EntryKind.SYMLINK
+        if stat.S_ISLNK(metadata.st_mode)
+        else EntryKind.DIR if stat.S_ISDIR(metadata.st_mode) else EntryKind.FILE
+    )
+    return FileEntry(
+        rel_path,
+        os.path.basename(rel_path),
+        kind,
+        0 if kind == EntryKind.DIR else metadata.st_size,
+        metadata.st_mtime,
+    )
+
+
+def detect_conflicts(sources: list[str], dst_dir: str, cancel_check=None) -> ConflictReport:
+    """Return collisions with paths relative to dst_dir, including source basename.
+
+    Uses scanner exclusions and never follows symlinks. Directory/type collisions
+    block their subtree, so descendants are not reported as independently new.
+    Cancellation returns an empty report rather than a misleading partial result.
+    """
+    names = Counter(os.path.basename(os.path.normpath(source)) for source in sources)
+    report = ConflictReport(duplicate_sources=[name for name, count in names.items() if count > 1])
+
+    def cancelled() -> bool:
+        return bool(cancel_check and cancel_check())
+
+    def compare(src: FileEntry, dst: FileEntry) -> None:
+        src_abs = os.path.join(os.path.dirname(os.path.abspath(source)), src.rel_path)
+        mismatch = src.kind != dst.kind
+        delta = src.mtime - dst.mtime
+        newer = "same" if abs(delta) <= MTIME_TOLERANCE_SECONDS else "src" if delta > 0 else "dst"
+        identical = not mismatch and src.size == dst.size and newer == "same"
+        if identical:
+            report.identical += 1
+            report.identical_paths.append(src_abs)
+        conflict = Conflict(src.rel_path, src.name, src, dst, mismatch, newer, identical)
+        report.conflicts.append(conflict)
+        report.conflicts_by_source[src_abs] = conflict
+
+    for source in sources:
+        if cancelled():
+            return ConflictReport()
+        name = os.path.basename(os.path.normpath(source))
+        src = _entry(source, name)
+        target = os.path.join(dst_dir, name)
+        dst = _entry(target, name) if os.path.lexists(target) else None
+        if src.kind != EntryKind.DIR:
+            if dst is None:
+                report.total_src_files_new += 1
+            else:
+                compare(src, dst)
+            continue
+        if dst is not None and dst.kind != EntryKind.DIR:
+            compare(src, dst)
+            continue
+        left = scan_directory(source, cancel_check=cancel_check)
+        if cancelled():
+            return ConflictReport()
+        if dst is None:
+            report.total_src_files_new += sum(e.kind != EntryKind.DIR for e in left.values())
+            continue
+        report.dir_collisions.append(name)
+        right = scan_directory(target, cancel_check=cancel_check)
+        if cancelled():
+            return ConflictReport()
+        blocked: set[str] = set()
+        for path, entry in left.items():
+            if cancelled():
+                return ConflictReport()
+            if any(parent in blocked for parent in _parents(path)):
+                continue
+            other = right.get(path)
+            if other is None:
+                report.total_src_files_new += entry.kind != EntryKind.DIR
+            elif entry.kind != EntryKind.DIR or other.kind != EntryKind.DIR:
+                compare(replace(entry, rel_path=f"{name}/{path}"), replace(other, rel_path=f"{name}/{path}"))
+                if entry.kind == EntryKind.DIR:
+                    blocked.add(path)
+    return report
+
+
+def _parents(path: str):
+    parent = os.path.dirname(path)
+    while parent:
+        yield parent
+        parent = os.path.dirname(parent)

{commandertui-1.4.3 → commandertui-1.5.1}/commandertui/main_screen.py

@@ -24,6 +24,7 @@ from .modals import (
 )
 from .models import OpKind, OpSide, OperationQueue, QueuedOp
 from .run_queue import run_queue_with_progress
+from .run_transfer import run_transfer
 from .scanner import path_size
 from .widgets import PARENT_MARK, FilePanel, FunctionBar, MainTopBar
 
@@ -493,25 +494,7 @@ class MainScreen(Screen):
             self._nothing_selected()
             return
 
-        side = OpSide.LEFT_TO_RIGHT if src_panel.side == "left" else OpSide.RIGHT_TO_LEFT
-        queue = OperationQueue()
-        for item in items:
-            rel_path = os.path.relpath(item, src_panel.path)
-            queue.add(QueuedOp(kind, side, rel_path, os.path.isdir(item), size=path_size(item)))
-
-        def after(report) -> None:
-            src_panel.marked.clear()
-            src_panel.refresh_listing()
-            dst_panel.refresh_listing()
-
-        run_queue_with_progress(
-            self,
-            f"{label} to {dst_panel.path}",
-            queue,
-            self._panel("left").path,
-            self._panel("right").path,
-            after,
-        )
+        run_transfer(self, kind, label, src_panel, dst_panel, items)
 
     # ------------------------------------------------------------- misc
     def action_show_compare(self) -> None:

{commandertui-1.4.3 → commandertui-1.5.1}/commandertui/modals.py

@@ -7,7 +7,7 @@ import time
 
 from textual.app import ComposeResult
 from textual.binding import Binding
-from textual.containers import Horizontal, Vertical
+from textual.containers import Horizontal, Vertical, VerticalScroll
 from textual.screen import ModalScreen
 from textual.widgets import Button, DataTable, Input, OptionList, Static
 
@@ -698,3 +698,204 @@ class UpdateScreen(ModalScreen[str]):
 
     def action_skip(self) -> None:
         self.dismiss("skip")
+
+
+class ConflictScreen(ModalScreen):
+    """One safe decision for a batch or one collision; no filesystem changes."""
+
+    DEFAULT_CSS = """
+    ConflictScreen { align: center middle; }
+    #conflict-box { width: 80%; min-width: 60; max-width: 100; height: auto; max-height: 95%;
+        border: heavy $foreground; padding: 1 3; overflow: hidden hidden; }
+    ConflictScreen.compact #conflict-box { padding: 0 2; }
+    #conflict-title { text-style: bold; margin-bottom: 1; max-height: 2; }
+    #conflict-summary { height: auto; margin-bottom: 1; overflow: hidden auto; }
+    #conflict-buttons { height: auto; overflow: hidden hidden; }
+    #conflict-buttons Button { position: absolute; min-width: 0; height: 3; margin: 0; }
+    #apply-remaining { margin-top: 1; }
+    ConflictScreen.compact #apply-remaining { margin-top: 0; }
+    """
+
+    BINDINGS = [
+        Binding(key, f"choose('{value}')", label, priority=True)
+        for key, value, label in [
+            ("o", "overwrite", "Overwrite"),
+            ("s", "skip", "Skip"),
+            ("n", "only_newer", "Only newer"),
+            ("r", "rename", "Rename"),
+            ("m", "merge", "Merge"),
+            ("a", "ask", "Ask each"),
+            ("c", "cancel", "Cancel"),
+            ("escape", "cancel", "Cancel"),
+        ]
+    ]
+
+    def __init__(self, report, dst_dir, kind, *, rel_path=None, file_policy=False, summary=None):
+        super().__init__()
+        from .conflicts import Resolution, allowed_resolutions
+
+        self.report_data = report
+        self.dst_dir = dst_dir
+        self.kind = kind
+        self.rel_path = rel_path
+        self.file_policy = file_policy
+        self.summary_text = summary
+        self.options = [
+            r.value
+            for r in allowed_resolutions(kind)
+            if r != Resolution.MERGE or (report.dir_collisions and not file_policy and rel_path is None)
+        ]
+        if not file_policy and rel_path is None:
+            self.options.insert(-1, "ask")
+
+    def compose(self):
+        from textual.widgets import Checkbox
+
+        report = self.report_data
+        count = len(
+            {c.rel_path for c in report.conflicts}
+            | set(report.dir_collisions)
+            | set(report.duplicate_sources)
+        )
+        title = (
+            f"Resolve {self.rel_path}"
+            if self.rel_path
+            else (
+                "Choose a policy for conflicting files"
+                if self.file_policy
+                else f"{count} items already exist"
+            )
+        )
+        entries = report.conflicts
+        if self.rel_path:
+            entries = [c for c in entries if c.rel_path == self.rel_path]
+        lines = [f"in {self.dst_dir}"]
+        if report.identical:
+            lines.append(f"({report.identical} identical: same size and date)")
+        for conflict in entries[:6]:
+
+            def side(entry, label):
+                date = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(entry.mtime))
+                return f"{label}: {_human_bytes(entry.size)}, {date}"
+
+            label = "identical" if conflict.identical else f"newer: {conflict.newer}"
+            lines.append(
+                f"{conflict.rel_path}: {side(conflict.src, 'Source')} | "
+                f"{side(conflict.dst, 'Destination')} — {label}"
+            )
+        if len(entries) > 6:
+            lines.append(f"... and {len(entries) - 6} more")
+        if report.dir_collisions:
+            lines.append("Existing folders: " + ", ".join(report.dir_collisions[:6]))
+        if report.duplicate_sources:
+            lines.append("Repeated source names: " + ", ".join(report.duplicate_sources))
+        labels = {
+            "overwrite": "Overwrite (o)",
+            "skip": "Skip (s)",
+            "only_newer": "Only newer (n)",
+            "rename": "Rename (r)",
+            "merge": "Merge (m)",
+            "ask": "Ask each (a)",
+            "cancel": "Cancel (Esc)",
+        }
+        if report.dir_collisions and not self.file_policy:
+            labels["overwrite"] = "Overwrite (keeps extra files) (o)"
+        with Vertical(id="conflict-box"):
+            yield Static(title, id="conflict-title", markup=False)
+            with VerticalScroll(id="conflict-summary"):
+                yield Static(self.summary_text or "\n".join(lines), id="conflict-list", markup=False)
+            with Vertical(id="conflict-buttons"):
+                for option in self.options:
+                    yield Button(labels[option], id=f"conflict-{option}")
+            if self.rel_path:
+                yield Checkbox("Apply to all remaining (l)", id="apply-remaining")
+
+    def on_mount(self):
+        self._resize_layout()
+        self.query_one("#conflict-skip", Button).focus()
+
+    def on_resize(self):
+        self._resize_layout()
+
+    def _resize_layout(self):
+        self.set_class(self.size.width < 125 or self.size.height < 30, "compact")
+        self.call_after_refresh(self._layout_controls)
+
+    def _layout_controls(self):
+        """Wrap measured button widths; reserve fixed space outside the list.
+
+        Reposition existing buttons instead of remounting them, preserving
+        focus and the Ask each checkbox when the terminal is resized.
+        """
+        from rich.cells import cell_len
+
+        box = self.query_one("#conflict-box")
+        controls = self.query_one("#conflict-buttons")
+        buttons = list(controls.query(Button))
+        available = controls.content_size.width
+        if not available:
+            return
+        compact = self.has_class("compact")
+        margin = 1 if compact else 2
+        widths = [
+            max(14 if compact else 18, cell_len(str(button.label)) + max(4, button.gutter.width))
+            for button in buttons
+        ]
+        rows = [list(range(min(3, len(buttons)))), list(range(3, len(buttons)))]
+        if compact or any(sum(widths[i] + 2 * margin for i in row) > available for row in rows):
+            rows = []
+            row = []
+            used = 0
+            for index, width in enumerate(widths):
+                if row and used + width + 2 * margin > available:
+                    rows.append(row)
+                    row, used = [], 0
+                row.append(index)
+                used += width + 2 * margin
+            if row:
+                rows.append(row)
+        y = 1
+        for row in filter(None, rows):
+            used = sum(widths[i] + 2 * margin for i in row)
+            x = max(0, (available - used) // 2)
+            for index in row:
+                button = buttons[index]
+                button.styles.width = min(widths[index], available - 2 * margin)
+                button.styles.offset = (x + margin, y)
+                x += widths[index] + 2 * margin
+            y += 3 if compact else 4
+        controls.styles.height = y if compact else y - 1
+        title = self.query_one("#conflict-title")
+        summary = self.query_one("#conflict-summary")
+        checkbox = self.query("#apply-remaining")
+        checkbox_height = (3 + (0 if compact else 1)) if checkbox else 0
+        # Auto height keeps the established large-dialog proportions. Only the
+        # summary is capped and scrollable; focus can never scroll the box.
+        reserved = (
+            box.gutter.height
+            + min(2, title.get_content_height(box.content_size, self.size, available))
+            + title.styles.margin.height
+            + int(controls.styles.height.value)
+        )
+        reserved += checkbox_height + summary.styles.margin.height
+        summary.styles.max_height = max(1, int(self.size.height * 0.95) - reserved)
+
+    def action_choose(self, value):
+        from textual.widgets import Checkbox
+
+        if value not in self.options:
+            return
+        apply = self.query_one("#apply-remaining", Checkbox).value if self.rel_path else False
+        self.dismiss((value, apply))
+
+    def action_cancel(self):
+        self.dismiss(("cancel", False))
+
+    def key_l(self):
+        if self.rel_path:
+            checkbox = self.query_one("#apply-remaining")
+            checkbox.value = not checkbox.value
+
+    def on_button_pressed(self, event: Button.Pressed):
+        event.stop()
+        self.action_choose(event.button.id.removeprefix("conflict-"))