@hwip/cli 0.0.1 → 0.1.1

package/dist/listener-worktree-cleanup.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The listener's side of `--wt`: when a session has ended, take back the
+ * worktree it ran in if nothing in it would be lost, and say so when something
+ * would (`worktree.ts` holds the judgement; this holds the timing).
+ *
+ * A pass runs when the set of session names changed since the last one — a
+ * session ending is a name leaving — and once at startup, for sessions that
+ * ended while no listener ran. An unchanged inventory costs nothing: no tmux,
+ * no git, and with no worktree on record not even a call for the panes.
+ */
+import type { DesktopNotification } from './desktop-notify.js';
+import { readPaneCwds, reconcileWorktrees, type GitRun } from './worktree.js';
+export interface WorktreeCleanupDeps {
+    log: (message: string) => void;
+    /** The desktop banner. A rejection is logged, never thrown. */
+    notify: (note: DesktopNotification) => Promise<unknown>;
+    /** tmux as the listener talks to it (its socket, async, with a timeout). */
+    tmux: GitRun;
+    /** Swappable in tests. */
+    hasRows?: () => boolean;
+    readPanes?: typeof readPaneCwds;
+    reconcile?: typeof reconcileWorktrees;
+}
+export declare const createWorktreeCleanup: (deps: WorktreeCleanupDeps) => {
+    observe: (sessionNames: readonly string[]) => void;
+};
+//# sourceMappingURL=listener-worktree-cleanup.d.ts.map

package/dist/listener-worktree-cleanup.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * The listener's side of `--wt`: when a session has ended, take back the
+ * worktree it ran in if nothing in it would be lost, and say so when something
+ * would (`worktree.ts` holds the judgement; this holds the timing).
+ *
+ * A pass runs when the set of session names changed since the last one — a
+ * session ending is a name leaving — and once at startup, for sessions that
+ * ended while no listener ran. An unchanged inventory costs nothing: no tmux,
+ * no git, and with no worktree on record not even a call for the panes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorktreeCleanup = void 0;
+const path_1 = require("path");
+const worktree_js_1 = require("./worktree.js");
+const createWorktreeCleanup = (deps) => {
+    const { log, notify, tmux } = deps;
+    const hasRows = deps.hasRows ?? (() => (0, worktree_js_1.readWorktreeRows)().length > 0);
+    const readPanes = deps.readPanes ?? worktree_js_1.readPaneCwds;
+    const reconcile = deps.reconcile ?? worktree_js_1.reconcileWorktrees;
+    let lastNames = null;
+    let inFlight = false;
+    const pass = async () => {
+        if (!hasRows())
+            return;
+        const panes = await readPanes(tmux);
+        // An unreadable list read as an empty one would make every live session's worktree look abandoned.
+        // Not retried until the names change again: retrying each 5 s sweep would log the same failure all day.
+        // The worktree stays, and `hwip worktree clean` takes it later.
+        if (!panes) {
+            log('! worktree cleanup skipped: could not read the tmux panes');
+            return;
+        }
+        const report = await reconcile({ paneCwds: panes });
+        for (const r of report.removed)
+            log(`worktree removed: ${r.path}${r.branchDeleted ? ` (branch ${r.branch} deleted)` : ''}`);
+        for (const path of report.gone)
+            log(`worktree forgotten, its directory is gone: ${path}`);
+        for (const k of report.kept) {
+            const why = k.reasons.join(', ');
+            log(`worktree kept: ${k.path} — ${why}`);
+            void notify({ title: 'Hwip · worktree kept', body: `${(0, path_1.basename)(k.path)} — ${why}`, reveal: k.path })
+                .catch((err) => log(`! banner failed — ${err instanceof Error ? err.message : String(err)}`));
+        }
+    };
+    return {
+        observe: (sessionNames) => {
+            const names = [...sessionNames].sort().join('\n');
+            if (names === lastNames)
+                return;
+            // One pass at a time. The names are not recorded for a pass that did not start, so the next publish asks again.
+            if (inFlight)
+                return;
+            lastNames = names;
+            inFlight = true;
+            void pass()
+                .catch((err) => log(`! worktree cleanup failed: ${err instanceof Error ? err.message : String(err)}`))
+                .finally(() => { inFlight = false; });
+        },
+    };
+};
+exports.createWorktreeCleanup = createWorktreeCleanup;