pipane 0.1.6 → 0.1.8

package/dist/server/server/worktree-name.js

@@ -1,39 +1,124 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
 /**
- * Return a short label for the Git checkout containing cwd.
- *
- * A linked worktree has a .git file whose target contains a `commondir`
- * pointer. Regular checkouts (and non-Git directories) are labelled `root`.
+ * Filesystem-only Git checkout lookup. One instance is shared across all
+ * sessions in a single listing, then discarded so worktree changes are visible
+ * on the next request.
  */
-export function resolveWorktreeName(cwd) {
-    if (!cwd)
-        return "root";
-    let dir = path.resolve(cwd);
-    while (true) {
-        const gitPath = path.join(dir, ".git");
-        if (existsSync(gitPath)) {
-            try {
-                const stat = statSync(gitPath);
-                if (stat.isDirectory())
-                    return "root";
-                if (!stat.isFile())
-                    return "root";
-                const marker = readFileSync(gitPath, "utf8").trim();
-                if (!marker.startsWith("gitdir: "))
-                    return "root";
-                const gitDir = path.resolve(dir, marker.slice("gitdir: ".length).trim());
-                if (!existsSync(path.join(gitDir, "commondir")))
-                    return "root";
-                return path.basename(dir) || "root";
+class GitCheckoutLookup {
+    cache = new Map();
+    resolve(location) {
+        if (!location)
+            return null;
+        let dir = path.resolve(location);
+        const visited = [];
+        while (true) {
+            if (this.cache.has(dir)) {
+                return this.remember(visited, this.cache.get(dir) ?? null);
+            }
+            visited.push(dir);
+            const gitPath = path.join(dir, ".git");
+            if (existsSync(gitPath)) {
+                return this.remember(visited, this.readCheckout(dir, gitPath));
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return this.remember(visited, null);
+            dir = parent;
+        }
+    }
+    readCheckout(root, gitPath) {
+        try {
+            const stat = statSync(gitPath);
+            if (stat.isDirectory()) {
+                return {
+                    root,
+                    commonGitDir: canonicalPath(gitPath),
+                    linked: false,
+                };
             }
-            catch {
-                return "root";
+            if (!stat.isFile())
+                return null;
+            const marker = readFileSync(gitPath, "utf8").trim();
+            if (!marker.startsWith("gitdir: "))
+                return null;
+            const gitDir = path.resolve(root, marker.slice("gitdir: ".length).trim());
+            if (!existsSync(gitDir))
+                return null;
+            const commonDirMarker = path.join(gitDir, "commondir");
+            if (!existsSync(commonDirMarker)) {
+                // A separate Git directory or submodule checkout uses a .git file too,
+                // but unlike a linked worktree it has no commondir pointer.
+                return {
+                    root,
+                    commonGitDir: canonicalPath(gitDir),
+                    linked: false,
+                };
             }
+            const commonDir = path.resolve(gitDir, readFileSync(commonDirMarker, "utf8").trim());
+            if (!existsSync(commonDir))
+                return null;
+            return {
+                root,
+                commonGitDir: canonicalPath(commonDir),
+                linked: true,
+            };
         }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return "root";
-        dir = parent;
+        catch {
+            return null;
+        }
+    }
+    remember(visited, checkout) {
+        for (const location of visited)
+            this.cache.set(location, checkout);
+        return checkout;
+    }
+}
+function canonicalPath(value) {
+    try {
+        return realpathSync(value);
+    }
+    catch {
+        return path.resolve(value);
     }
 }
+function checkoutName(checkout) {
+    return checkout?.linked ? path.basename(checkout.root) || "root" : "root";
+}
+/**
+ * Create a resolver with a request-scoped filesystem cache. This avoids Git
+ * subprocesses and ensures shared cwd/path ancestors are only inspected once
+ * while listing many sessions.
+ */
+export function createWorktreeNameResolver() {
+    const lookup = new GitCheckoutLookup();
+    return (cwd, recentToolPaths = []) => {
+        const cwdCheckout = lookup.resolve(cwd);
+        // Tool paths are stored oldest-to-newest. The newest successful project
+        // file operation is stronger evidence than Pi's immutable session cwd.
+        for (let i = recentToolPaths.length - 1; i >= 0; i--) {
+            const activityCheckout = lookup.resolve(recentToolPaths[i]);
+            if (!activityCheckout)
+                continue;
+            if (!cwdCheckout || activityCheckout.commonGitDir === cwdCheckout.commonGitDir) {
+                return checkoutName(activityCheckout);
+            }
+        }
+        // The session cwd says where Pi was launched, not which checkout the
+        // conversation is actively using. Until successful same-repository file
+        // activity provides evidence, treat the session as root.
+        return "root";
+    };
+}
+/**
+ * Return a short label for the Git checkout a session is actively using.
+ *
+ * Pi cannot change its process cwd persistently, so the recorded cwd only
+ * identifies the repository. Recent successful read/write/edit paths identify
+ * its active checkout; without one, the label defaults to root. Linked
+ * worktrees are recognized by their commondir pointer. Removed worktrees
+ * naturally stop matching because their .git metadata is no longer present.
+ */
+export function resolveWorktreeName(cwd, recentToolPaths = []) {
+    return createWorktreeNameResolver()(cwd, recentToolPaths);
+}