gh-stack 0.7.1 → 0.10.0

package/src/lib/snapshot.ts

@@ -1,7 +1,17 @@
-// Snapshot system for undo support and pre-rewrite base recovery
+// Snapshot system for undo support and pre-rewrite base recovery.
+//
+// v3 stores each snapshot as its own append-only file under
+// `.git/.gh-stack/snapshots/`, retained per-stack. This replaces the single
+// growing `snapshots[]` array of v2 — the array was rewritten on every command
+// (churn + a conflict magnet) and global trimming could evict a dependent
+// stack's only record while a busy sibling stack churned (see issue #13).
 import type { StackMetadata, Snapshot } from "../types.ts";
 import * as git from "./git.ts";
-import { writeMetadata, getOrderedBranches } from "./metadata.ts";
+import { getOrderedBranches } from "./metadata.ts";
+import { snapshotsDir } from "./paths.ts";
+import { mkdir, readdir, unlink } from "node:fs/promises";
+
+const MAX_SNAPSHOTS_PER_STACK = 10;
 
 /**
  * Find the pre-rewrite SHA for a parent branch by walking snapshots newest-first.
@@ -76,10 +86,54 @@ export async function findPreRewriteSha(
   return null;
 }
 
-const MAX_SNAPSHOTS = 10;
+// Snapshot files are named `<sortable-timestamp>__<encoded-stack>.json`. The
+// timestamp keeps colons/dots out of the filename (Windows-safe) while sorting
+// chronologically as a plain string; the stack name is URL-encoded so `/` in a
+// branch-derived name doesn't create subdirectories.
+function snapshotFileName(snapshot: Snapshot): string {
+  const ts = snapshot.timestamp.replace(/[:.]/g, "-");
+  return `${ts}__${encodeURIComponent(snapshot.stack ?? "")}.json`;
+}
+
+/** Write a fully-formed snapshot to its file. Used by takeSnapshot and the
+ * v2→v3 migration (which replays historical snapshots without touching git). */
+export async function writeSnapshotFile(snapshot: Snapshot): Promise<void> {
+  const dir = await snapshotsDir();
+  await mkdir(dir, { recursive: true });
+  await Bun.write(`${dir}/${snapshotFileName(snapshot)}`, JSON.stringify(snapshot, null, 2) + "\n");
+}
 
 /**
- * Take a snapshot of all branch HEADs in the current stack before a destructive operation.
+ * Load all snapshots from disk, oldest → newest. This populates
+ * `meta.snapshots` on read so the in-memory shape matches v2.
+ */
+export async function loadSnapshots(): Promise<Snapshot[]> {
+  const dir = await snapshotsDir();
+  let entries: string[];
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return [];
+  }
+
+  const snapshots: Snapshot[] = [];
+  for (const file of entries) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      snapshots.push((await Bun.file(`${dir}/${file}`).json()) as Snapshot);
+    } catch {
+      // Skip malformed snapshot files.
+    }
+  }
+
+  // ISO 8601 timestamps sort chronologically as strings.
+  return snapshots.toSorted((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+
+/**
+ * Take a snapshot of all branch HEADs in the current stack before a destructive
+ * operation. Writes one append-only file and trims that stack's history to the
+ * most recent N — sibling stacks are never touched.
  */
 export async function takeSnapshot(
   meta: StackMetadata,
@@ -104,23 +158,37 @@ export async function takeSnapshot(
     timestamp: new Date().toISOString(),
     operation,
     branches,
+    stack: stackName,
   };
 
-  if (!meta.snapshots) {
-    meta.snapshots = [];
-  }
+  await writeSnapshotFile(snapshot);
 
+  // Keep in-memory array consistent for callers that read it afterward.
+  if (!meta.snapshots) meta.snapshots = [];
   meta.snapshots.push(snapshot);
 
-  // Keep only the last N snapshots
-  if (meta.snapshots.length > MAX_SNAPSHOTS) {
-    meta.snapshots = meta.snapshots.slice(-MAX_SNAPSHOTS);
-  }
+  await gcStackSnapshots(stackName);
 
-  await writeMetadata(meta);
   return meta;
 }
 
+/** Trim a single stack's snapshot files to the most recent N. */
+async function gcStackSnapshots(stackName: string): Promise<void> {
+  const dir = await snapshotsDir();
+  const suffix = `__${encodeURIComponent(stackName)}.json`;
+  let entries: string[];
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return;
+  }
+  const mine = entries.filter((f) => f.endsWith(suffix)).toSorted(); // sortable ts prefix
+  const excess = mine.length - MAX_SNAPSHOTS_PER_STACK;
+  for (let i = 0; i < excess; i++) {
+    await unlink(`${dir}/${mine[i]!}`).catch(() => {});
+  }
+}
+
 /**
  * Get the last snapshot (for undo).
  */
@@ -132,7 +200,7 @@ export function getLastSnapshot(meta: StackMetadata): Snapshot | null {
 }
 
 /**
- * Pop the last snapshot (remove it after restoring).
+ * Pop the last snapshot (remove it after restoring) — deletes its file too.
  */
 export async function popSnapshot(
   meta: StackMetadata,
@@ -142,6 +210,7 @@ export async function popSnapshot(
   }
 
   const snapshot = meta.snapshots.pop()!;
-  await writeMetadata(meta);
+  const dir = await snapshotsDir();
+  await unlink(`${dir}/${snapshotFileName(snapshot)}`).catch(() => {});
   return { meta, snapshot };
 }

package/src/lib/ui.ts

@@ -2,7 +2,7 @@
 import * as p from "./output.ts";
 import pc from "picocolors";
 import type { Stack, StackMetadata } from "../types.ts";
-import { getOrderedBranches } from "./metadata.ts";
+import { getOrderedBranches, stackBase } from "./metadata.ts";
 
 // ── Auto-yes mode (for agents/CI) ──
 
@@ -32,7 +32,10 @@ export function renderStackTree(
   const showNumbers = options?.showNumbers ?? true;
   const lines: string[] = [];
 
-  lines.push(`${pc.green("◯")} main`);
+  const base = stackBase(stack);
+  const baseIsTrunk = base === "main" || base === "master";
+  const baseHint = baseIsTrunk ? "" : pc.dim(" (base — in parent stack)");
+  lines.push(`${pc.green("◯")} ${base}${baseHint}`);
 
   for (let i = 0; i < ordered.length; i++) {
     const branchName = ordered[i]!;

package/src/types.ts

@@ -1,7 +1,13 @@
-// gh-stack metadata schema (v2)
+// gh-stack metadata schema.
+//
+// `StackMetadata` is the in-memory shape shared by every command. Its on-disk
+// representation has evolved (v1 monolith → v2 monolith → v3 per-stack files +
+// git branch config), but the in-memory object stays stable so commands never
+// need to know which storage version produced it. `version` reflects the
+// store the object was assembled from.
 
 export interface StackMetadata {
-  version: 2;
+  version: 2 | 3;
   current_stack: string | null;
   stacks: Record<string, Stack>;
   archive?: Record<string, Stack>;
@@ -12,18 +18,38 @@ export interface Stack {
   description: string;
   last_branch: string | null;
   branches: Record<string, Branch>;
+  // The ref this stack is rooted on. Usually the trunk ("main"), but for a
+  // stack that was split off another (see `gh-stack split`), this is a branch
+  // belonging to the parent stack. The stack's root branch is the one whose
+  // `parent` equals this value. Optional on disk for back-compat; treat a
+  // missing value as "main" via `stackBase()`.
+  base?: string;
 }
 
 export interface Branch {
   parent: string; // "main" or another branch name
   pr?: number; // GitHub PR number
   description?: string; // Human-readable label
+
+  // Stable per-branch identity (UUID), stamped on first write and mirrored into
+  // git config as `branch.<name>.ghstack-id`. Because `git branch -m` moves the
+  // whole config section but the JSON is keyed by name, this id is what lets us
+  // recognize a renamed branch and re-key its (now-stale) JSON entry — even
+  // before it has a PR number to match on. See metadata.ts `reconcileRenames`.
+  id?: string;
+
+  // ── submit caches (v0.9.0, issue #16) ──
+  // Let `submit` skip redundant network calls when nothing relevant changed.
+  prTitle?: string; // last-known GitHub PR title, for rendering the stack viz without a fetch
+  prBase?: string; // last base we set on the PR via `gh pr edit --base`; skip the edit when parent is unchanged
+  vizHash?: string; // hash of the stack-viz block we last wrote to this PR; skip the PATCH when it would be identical
 }
 
 export interface Snapshot {
   timestamp: string; // ISO 8601
   operation: string; // "restack" | "merge" | "sync" | "remove"
   branches: Record<string, string>; // branch name -> commit SHA
+  stack?: string; // owning stack (v3: drives per-stack retention + file naming)
 }
 
 // Resume state for restack --resume