wave-code 1.3.0 → 1.5.0

package/src/utils/worktree.ts

@@ -407,6 +407,103 @@ export interface WorktreeChanges {
   commits: number;
 }
 
+/**
+ * The linked worktree a directory sits in, derived from the filesystem only.
+ * Same field semantics as `createWorktree`'s result, so a caller can hand it
+ * straight to `removeWorktree`.
+ */
+export interface DerivedWorktree {
+  path: string;
+  branch: string;
+  repoRoot: string;
+  hookBased: boolean;
+}
+
+/**
+ * Work out whether `sessionDir` **is** a linked git worktree — and which one —
+ * without running git.
+ *
+ * Two callers need this and both need it cheap: `listDaemonSessions` embeds the
+ * answer in every session row (the remote page decides from it whether deleting
+ * a session also deletes a worktree), and `destroy --removeWorktree` needs the
+ * path/branch/repoRoot that `removeWorktree` takes. Shelling out per row is not
+ * an option — `listDaemonSessions` runs on every reconnect, snapshot and page
+ * open, and a synchronous git call in this process freezes every session it
+ * serves (see the note at the top of this file). So the whole derivation is
+ * plain fs reads:
+ *
+ * - `.git` a **directory** in `sessionDir` ⇒ it is the main working tree, not a
+ *   worktree ⇒ `undefined` (removing it would be removing the repository).
+ * - `.git` a **file** ⇒ a linked worktree; the file holds `gitdir: <path>`,
+ *   which is where that worktree's own HEAD lives.
+ * - branch = `<gitdir>/HEAD` (`ref: refs/heads/<name>`); a detached HEAD has no
+ *   branch, which returns `""` — the same thing `git branch --show-current`
+ *   says, and `removeWorktree` skips a branch it cannot name.
+ * - repoRoot = the main repository root, i.e. the directory *above* the common
+ *   git dir that `<gitdir>/commondir` points at (`<repoRoot>/.git`).
+ *
+ * `sessionDir` must be the worktree root itself (the directory a session was
+ * created in) — a subdirectory of a worktree has no `.git` of its own, and this
+ * returns `undefined` for it rather than guessing. Every failure path returns
+ * `undefined`: "not a worktree / cannot tell" is a legitimate answer and must
+ * never throw into a caller that is only decorating a list.
+ */
+export function deriveWorktreeInfo(
+  sessionDir: string,
+): DerivedWorktree | undefined {
+  try {
+    if (!sessionDir) return undefined;
+    const dir = path.resolve(sessionDir);
+    const gitEntry = path.join(dir, ".git");
+    if (!fs.statSync(gitEntry).isFile()) return undefined;
+
+    const prefix = "gitdir: ";
+    const content = fs.readFileSync(gitEntry, "utf8").trim();
+    if (!content.startsWith(prefix)) return undefined;
+    const gitDir = path.resolve(dir, content.substring(prefix.length).trim());
+
+    let branch = "";
+    try {
+      const head = fs.readFileSync(path.join(gitDir, "HEAD"), "utf8").trim();
+      const refPrefix = "ref: refs/heads/";
+      if (head.startsWith(refPrefix)) {
+        branch = head.substring(refPrefix.length);
+      }
+    } catch {
+      // Detached/unreadable HEAD: no branch to delete, the worktree is still
+      // identifiable.
+    }
+
+    let repoRoot = "";
+    try {
+      const common = fs
+        .readFileSync(path.join(gitDir, "commondir"), "utf8")
+        .trim();
+      const commonDir = path.resolve(gitDir, common);
+      repoRoot =
+        path.basename(commonDir) === ".git"
+          ? path.dirname(commonDir)
+          : commonDir;
+    } catch {
+      return undefined;
+    }
+    if (!repoRoot) return undefined;
+
+    // Hook-based worktrees are removed by the WorktreeRemove hook, never by
+    // `git worktree remove` — mirror createWorktree's own hookBased decision
+    // (same test `wave daemon destroy --remove-worktree` uses).
+    const config = loadMergedWaveConfig(repoRoot);
+    return {
+      path: dir,
+      branch,
+      repoRoot,
+      hookBased: hasWorktreeCreateHook(config?.hooks),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Count what deleting a worktree would throw away, so the caller can warn
  * before it happens. Both counts are best-effort: an unknown base branch (never

package/src/utils/bracketedPaste.ts

@@ -1,170 +0,0 @@
-/**
- * Bracketed paste (DECSET 2004) detector.
- *
- * When bracketed paste is enabled, terminals wrap pasted text in
- * `\x1b[200~` (start) and `\x1b[201~` (end) markers, which lets the input
- * pipeline distinguish "text was pasted" from "user typed keys" — most
- * importantly, a pasted trailing `\r` must NOT be treated as an Enter key.
- *
- * ink delivers each stdin chunk through useInput after stripping ONE leading
- * ESC from the parsed sequence (see use-input.js), so markers may arrive in
- * either the raw form (`\x1b[200~`) or the stripped form (`[200~`), and may
- * be split across chunks. The detector normalizes both forms and buffers
- * partial markers until they complete (deferral is safe: a deferred partial
- * is flushed unchanged if the next chunk does not complete a marker).
- */
-export type PasteProcessResult =
-  | { kind: "input"; input: string }
-  | { kind: "paste"; text: string; leadingInput?: string }
-  | { kind: "consume" };
-
-export interface BracketedPasteDetector {
-  /**
-   * Feed one input chunk (as delivered by ink's useInput callback).
-   * - `input`: regular keystrokes, pass through to normal handling.
-   * - `paste`: completed bracketed paste; insert `text` without submitting.
-   *   `leadingInput` (rare) is content that preceded the start marker in the
-   *   same chunk and should be handled as regular input first.
-   * - `consume`: content of an in-flight paste (or an empty paste); do
-   *   nothing with this chunk.
-   */
-  process(chunk: string): PasteProcessResult;
-  reset(): void;
-}
-
-const ESC = "\u001b";
-const START_STRIPPED = "[200~";
-const START_RAW = `${ESC}[200~`;
-const END_STRIPPED = "[201~";
-const END_RAW = `${ESC}[201~`;
-
-const START_FORMS = [START_RAW, START_STRIPPED];
-const END_FORMS = [END_RAW, END_STRIPPED];
-
-/**
- * Suffixes that may be the beginning of a marker split across chunks.
- * Longest-first so the longest matching suffix is deferred (e.g. `[200`
- * rather than `[20` for `...x[200`). Deferral is flush-equivalent: if the
- * next chunk does not complete a marker, the deferred suffix is delivered
- * as regular input unchanged.
- */
-const PARTIAL_SUFFIXES = [
-  `${ESC}[201`,
-  `${ESC}[200`,
-  `${ESC}[20`,
-  `${ESC}[2`,
-  "[201",
-  "[200",
-  "[20",
-  "[2",
-].sort((a, b) => b.length - a.length);
-
-export function createBracketedPasteDetector(): BracketedPasteDetector {
-  let inPaste = false;
-  let buffer = ""; // paste content collected since the start marker
-  let pending = ""; // deferred partial marker suffix from a previous chunk
-
-  const findFirst = (
-    text: string,
-    forms: string[],
-  ): { index: number; length: number } | null => {
-    let best: { index: number; length: number } | null = null;
-    for (const form of forms) {
-      const index = text.indexOf(form);
-      if (index !== -1 && (best === null || index < best.index)) {
-        best = { index, length: form.length };
-      }
-    }
-    return best;
-  };
-
-  const endsWithPartial = (text: string): string | null => {
-    for (const prefix of PARTIAL_SUFFIXES) {
-      if (text.endsWith(prefix)) {
-        return prefix;
-      }
-    }
-    return null;
-  };
-
-  const process = (chunk: string): PasteProcessResult => {
-    let remaining = pending + chunk;
-    pending = "";
-    let leadingInput = "";
-    let pasteText: string | null = null;
-
-    while (remaining.length > 0) {
-      if (!inPaste) {
-        const start = findFirst(remaining, START_FORMS);
-        if (start) {
-          leadingInput += remaining.slice(0, start.index);
-          remaining = remaining.slice(start.index + start.length);
-          inPaste = true;
-          continue;
-        }
-        // Orphan end marker (start was missed, e.g. consumed by another
-        // input handler): treat the preceding text as paste so a trailing
-        // `\r` cannot trigger the coalesced-Enter submit heuristic.
-        const end = findFirst(remaining, END_FORMS);
-        if (end) {
-          pasteText =
-            (pasteText ?? "") + leadingInput + remaining.slice(0, end.index);
-          leadingInput = "";
-          remaining = remaining.slice(end.index + end.length);
-          continue;
-        }
-        const partial = endsWithPartial(remaining);
-        if (partial) {
-          pending = remaining.slice(remaining.length - partial.length);
-          remaining = remaining.slice(0, remaining.length - partial.length);
-        }
-        if (remaining.length > 0) {
-          leadingInput += remaining;
-          remaining = "";
-        }
-        break;
-      }
-
-      const end = findFirst(remaining, END_FORMS);
-      if (end) {
-        pasteText = (pasteText ?? "") + buffer + remaining.slice(0, end.index);
-        buffer = "";
-        inPaste = false;
-        remaining = remaining.slice(end.index + end.length);
-        continue;
-      }
-      const partial = endsWithPartial(remaining);
-      if (partial) {
-        pending = remaining.slice(remaining.length - partial.length);
-        remaining = remaining.slice(0, remaining.length - partial.length);
-      }
-      buffer += remaining;
-      remaining = "";
-      break;
-    }
-
-    if (inPaste) {
-      // Paste still in flight: hold the content, deliver nothing yet.
-      return { kind: "consume" };
-    }
-    if (pasteText !== null) {
-      const result: { kind: "paste"; text: string; leadingInput?: string } = {
-        kind: "paste",
-        text: pasteText,
-      };
-      if (leadingInput !== "") {
-        result.leadingInput = leadingInput;
-      }
-      return result;
-    }
-    return { kind: "input", input: leadingInput };
-  };
-
-  const reset = (): void => {
-    inPaste = false;
-    buffer = "";
-    pending = "";
-  };
-
-  return { process, reset };
-}