collab-runtime 0.8.0__tar.gz → 0.9.0__tar.gz

{collab_runtime-0.8.0/collab_runtime.egg-info → collab_runtime-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: collab-runtime
-Version: 0.8.0
+Version: 0.9.0
 Summary: Collaborative file locking runtime
 Author-email: KirilMT <kiril.mt95@gmail.com>
 License-Expression: MIT

{collab_runtime-0.8.0 → collab_runtime-0.9.0}/README.md

@@ -237,6 +237,9 @@ collab daemon-status
 # Stop the daemon
 collab daemon-stop
 
+# Restart the daemon
+collab daemon-restart
+
 # Foreground watcher (internal/diagnostics)
 collab watch --interval 5 --timeout 0
 

{collab_runtime-0.8.0 → collab_runtime-0.9.0}/collab/live_locks_watcher.py

@@ -261,6 +261,10 @@ _local_owned_locks: set[str] = set()
 # Guard to prevent _graceful_shutdown from running more than once
 _shutdown_done: bool = False
 
+# Track when each lock was acquired so we can enforce a minimum hold time
+# and avoid rapid acquire/release cycles when git status is transient.
+_lock_acquired_at: dict[str, datetime] = {}
+
 # URL of the running dashboard server (set in main after _start_dashboard_server).
 # Used by interactive conflict menus so users can review all active locks.
 _dashboard_url: str | None = None
@@ -473,6 +477,15 @@ def _normalize_path(path: str, project_root: str) -> str:
         return path.replace("\\", "/")
 
 
+def _min_auto_lock_hold_seconds() -> int:
+    """Minimum seconds an auto-watch lock must be held before auto-release.
+
+    Configurable via ``COLLAB_MIN_AUTO_LOCK_HOLD_SECONDS`` (default 300 = 5 min).
+    Wrapped in a callable so tests can monkeypatch without import-time coupling.
+    """
+    return int(os.getenv("COLLAB_MIN_AUTO_LOCK_HOLD_SECONDS", "300"))
+
+
 def _should_ignore_path(path: str) -> bool:
     """Return True for paths the watcher should skip."""
     norm = path.replace("\\", "/")
@@ -741,9 +754,23 @@ def _process_new_files(client, branch: str, new_files: set[str]) -> None:
                 )
                 log_msg = _color(msg, Fore.GREEN) if _HAS_COLORAMA else msg
                 logger.info(log_msg)
+                # Cross-branch advisory (#150): warn when renewing a lock
+                # held by the same developer on a different branch.
+                existing_branch = data[0].get("existing_branch") if data else None
+                if existing_branch and existing_branch != br_local:
+                    warn_msg = (
+                        f"CROSS-BRANCH: {fp} is also locked by you on "
+                        f"branch '{existing_branch}' (current: '{br_local}'). "
+                        "Concurrent edits may cause merge conflicts."
+                    )
+                    logger.warning(
+                        _color(warn_msg, Fore.YELLOW) if _HAS_COLORAMA else warn_msg
+                    )
                 # Track locks this watcher created so remote scans do not
                 # report them as 'remote added' later.
                 _local_owned_locks.add(fp)
+                # Record acquisition time for minimum-hold enforcement.
+                _lock_acquired_at[fp] = datetime.now()
         except Exception:
             # Log full traceback so errors during acquire are visible in errors.log
             logger.exception("Failed to acquire lock for %s", fp)
@@ -754,8 +781,26 @@ def _process_releases(client, released: set[str]) -> None:
 
     Extracted so tests can simulate exceptions when removing locks from the local-owned
     set without running the entire main loop.
+
+    Enforces a minimum hold time to avoid rapid acquire/release cycles when git status
+    is transient.
     """
     for fp in released:
+        # Enforce minimum lock hold time: skip files whose lock was acquired
+        # too recently to avoid thrashing when git status fluctuates.
+        acquired = _lock_acquired_at.get(fp)
+        if acquired is not None:
+            age = (datetime.now() - acquired).total_seconds()
+            if age < _min_auto_lock_hold_seconds():
+                logger.debug(
+                    "⏳ [KEPT] %s — lock is only %ds old "
+                    "(< %ds minimum); deferring auto-release",
+                    fp,
+                    int(age),
+                    _min_auto_lock_hold_seconds(),
+                )
+                continue
+
         # Was this file in conflict?
         if fp in _active_conflicts:
             _active_conflicts.discard(fp)
@@ -916,6 +961,74 @@ def _resolve_lock_diff_base_ref() -> str | None:
     return None
 
 
+def _get_sibling_worktree_dirty_files() -> set[str]:
+    """Return dirty files from sibling git worktrees.
+
+    Uses ``git worktree list --porcelain`` to discover sibling worktrees, then runs
+    ``git status --porcelain`` in each.  Paths are normalised to project- relative form.
+    Used by :func:`_get_modified_and_unpushed_files` so that concurrent edits across
+    worktrees are not released as stale (#150).
+    """
+    sibling_files: set[str] = set()
+
+    captured = safe_subprocess.capture(
+        ["git", "worktree", "list", "--porcelain"],
+        policy="git",
+        cwd=_PROJECT_ROOT,
+        timeout=10.0,
+    )
+    if not captured.ok or captured.timed_out:
+        return sibling_files
+
+    out = safe_subprocess.decode_output(captured.stdout)
+    worktrees: list[tuple[str, str]] = []  # (path, branch)
+    current_path = ""
+    for line in out.splitlines():
+        line = line.strip()
+        if line.startswith("worktree "):
+            current_path = line[len("worktree ") :]
+        elif line.startswith("branch ") and current_path:
+            branch_ref = line[len("branch ") :]
+            branch = branch_ref.replace("refs/heads/", "", 1)
+            worktrees.append((current_path, branch))
+            current_path = ""
+
+    our_root = os.path.abspath(_PROJECT_ROOT).rstrip("\\/").lower()
+
+    for wt_path, wt_branch in worktrees:
+        wt_abs = os.path.abspath(wt_path).rstrip("\\/").lower()
+        if wt_abs == our_root:
+            continue
+        if not os.path.isdir(wt_path):
+            continue
+
+        try:
+            wt_captured = safe_subprocess.capture(
+                ["git", "status", "--porcelain"],
+                policy="git",
+                cwd=wt_path,
+                timeout=10.0,
+            )
+            if not wt_captured.ok or wt_captured.timed_out:
+                continue
+            wt_out = safe_subprocess.decode_output(wt_captured.stdout).strip("\r\n")
+            for line in wt_out.splitlines():
+                if len(line) > 3:
+                    p = _normalize_path(_parse_git_status_path(line), _PROJECT_ROOT)
+                    if p and not _should_ignore_path(p):
+                        sibling_files.add(p)
+                        logger.debug(
+                            "👥 [WORKTREE] %s — dirty in sibling '%s' (%s)",
+                            p,
+                            wt_branch,
+                            wt_path,
+                        )
+        except Exception as exc:
+            logger.debug("Failed to scan sibling worktree %s: %s", wt_path, exc)
+
+    return sibling_files
+
+
 def _get_modified_and_unpushed_files() -> set[str]:
     """Return the set of files that are 'in progress' for this developer.
 
@@ -957,6 +1070,15 @@ def _get_modified_and_unpushed_files() -> set[str]:
         # just won't lock committed-but-unpushed files, which beats crashing.
         pass
 
+    # Part 3: sibling worktree dirty files (#150) — prevent stale-lock release
+    # when another worktree is actively editing the same files.
+    try:
+        sibling_dirty = _get_sibling_worktree_dirty_files()
+        if sibling_dirty:
+            result.update(sibling_dirty)
+    except Exception as exc:
+        logger.debug("Sibling worktree scan failed: %s", exc)
+
     return result
 
 
@@ -1003,6 +1125,18 @@ def _reconcile_on_startup(client) -> None:
         fp = lock.get("file_path", "")
         if fp:
             lock_map[fp] = lock
+            # Populate _lock_acquired_at from existing locks so the minimum-hold
+            # check works correctly across watcher restarts.
+            acquired_str = lock.get("acquired_at")
+            if acquired_str and fp not in _lock_acquired_at:
+                try:
+                    _lock_acquired_at[fp] = (
+                        datetime.fromisoformat(acquired_str)
+                        .astimezone()
+                        .replace(tzinfo=None)
+                    )
+                except (ValueError, TypeError):
+                    pass
 
     locked_paths = set(lock_map.keys())
     branch = _get_current_branch()
@@ -1071,6 +1205,26 @@ def _reconcile_on_startup(client) -> None:
                 msg = f"[RESUMED] {fp} - lock re-adopted from this machine"
                 logger.info(_color(msg, Fore.GREEN) if _HAS_COLORAMA else msg)
         else:
+            # File is clean — but skip if the lock was acquired too recently.
+            # This prevents the watcher from releasing locks it just acquired
+            # during the same reconciliation pass (e.g. when git status is
+            # transient).
+            acquired = _lock_acquired_at.get(fp)
+            if acquired is not None:
+                age = (datetime.now() - acquired).total_seconds()
+                if age < _min_auto_lock_hold_seconds():
+                    logger.debug(
+                        "⏳ [KEPT] %s — lock is only %ds old "
+                        "(< %ds minimum); skipping auto-release",
+                        fp,
+                        int(age),
+                        _min_auto_lock_hold_seconds(),
+                    )
+                    # Keep the lock in _local_owned_locks so the main loop
+                    # continues to track it for eventual release.
+                    _local_owned_locks.add(fp)
+                    continue
+
             # File is clean - stale lock, release it
             try:
                 _scoped_owned_query(
@@ -1114,6 +1268,7 @@ def _reconcile_on_startup(client) -> None:
                 _handle_post_restart_conflict(client, fp, data[0])
             else:
                 _local_owned_locks.add(fp)
+                _lock_acquired_at[fp] = datetime.now()
                 n_newly_locked += 1
                 msg = f"[LOCKED] {fp} - acquired lock for dirty file at startup"
                 logger.debug(_color(msg, Fore.GREEN) if _HAS_COLORAMA else msg)
@@ -1367,6 +1522,22 @@ def _graceful_shutdown() -> None:
                         msg = f"[KEPT] {fp} - still has local edits, lock preserved"
                         logger.debug(_color(msg, Fore.GREEN) if _HAS_COLORAMA else msg)
                     else:
+                        # Enforce minimum hold time even during shutdown:
+                        # keep locks that were acquired too recently.
+                        acquired = _lock_acquired_at.get(fp)
+                        if acquired is not None:
+                            age = (datetime.now() - acquired).total_seconds()
+                            if age < _min_auto_lock_hold_seconds():
+                                n_kept += 1
+                                logger.debug(
+                                    "⏳ [KEPT] %s — lock is only %ds old "
+                                    "(< %ds minimum); preserving",
+                                    fp,
+                                    int(age),
+                                    _min_auto_lock_hold_seconds(),
+                                )
+                                continue
+
                         try:
                             _scope_agent(
                                 client.table("file_locks")
@@ -1400,6 +1571,21 @@ def _graceful_shutdown() -> None:
                         ]
                         for fp in db_locks:
                             if fp and fp not in still_dirty:
+                                # Enforce minimum hold time
+                                acquired = _lock_acquired_at.get(fp)
+                                if acquired is not None:
+                                    age = (datetime.now() - acquired).total_seconds()
+                                    if age < _min_auto_lock_hold_seconds():
+                                        n_kept += 1
+                                        logger.debug(
+                                            "⏳ [KEPT] %s — lock is only %ds old "
+                                            "(< %ds minimum); preserving",
+                                            fp,
+                                            int(age),
+                                            _min_auto_lock_hold_seconds(),
+                                        )
+                                        continue
+
                                 _scope_agent(
                                     client.table("file_locks")
                                     .delete()