@visual-z/xeno 0.8.1 → 0.8.2

package/src/store/worktree.ts

@@ -20,8 +20,10 @@
  *   is for cooperative branches, not adversarial ones.
  */
 
-import { mkdtemp, rm, realpath } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir, mkdtemp, rm, realpath } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { basename, join } from "node:path";
 import { tmpdir } from "node:os";
 
 /** Branch prefix, so a stale worktree is identifiable months later. */
@@ -37,6 +39,37 @@ export type CreateResult =
   | { ok: true; path: string; branch: string; snapshot: { head: string; tree: string } }
   | { ok: false; error: string };
 
+export interface CreateOptions {
+  /**
+   * Where the checkout goes. Default: a fresh temp directory, which suits a
+   * writing branch that lives for one subtask. A model-entered worktree is
+   * kept across sessions, so it names a stable parent and its own leaf.
+   */
+  location?: { parent: string; leaf: string };
+  /** Carry the parent's uncommitted files (default, as a branch needs). */
+  includeChanges?: boolean;
+}
+
+/**
+ * The stable home of model-entered worktrees for one repository.
+ *
+ * Under xeno's config directory rather than the project: inside `.xeno` it
+ * would collide with the rule that session state is never edited, and a
+ * sibling directory leaves xeno's checkouts in the user's project tree (Codex
+ * keeps its worktrees under its own home for the same reason). The digest of
+ * the repository path keeps two clones with the same name apart.
+ */
+export function persistentWorktreeParent(configDir: string, repo: string): string {
+  const digest = createHash("sha256").update(repo).digest("hex").slice(0, 8);
+  return join(configDir, "worktrees", `${basename(repo)}-${digest}`);
+}
+
+/** The repository's main checkout: `git worktree list` always lists it first. */
+export async function mainWorktree(dir: string): Promise<string | null> {
+  const listed = await listWorktrees(dir).catch(() => []);
+  return listed[0]?.path ?? null;
+}
+
 export type RemoveResult =
   | { ok: true }
   | { ok: false; error: string; dirty: boolean };
@@ -61,7 +94,7 @@ export async function isGitRepo(dir: string): Promise<boolean> {
   return git(dir, ["rev-parse", "--git-dir"]).code === 0;
 }
 
-export async function createWorktree(repo: string, name: string): Promise<CreateResult> {
+export async function createWorktree(repo: string, name: string, options: CreateOptions = {}): Promise<CreateResult> {
   // Refused rather than degraded. Falling back to the shared directory is the
   // exact failure isolation exists to prevent: parallel writing branches
   // would overwrite each other with nothing to indicate isolation was never
@@ -107,13 +140,24 @@ export async function createWorktree(repo: string, name: string): Promise<Create
   } finally { await rm(scratch, { recursive: true, force: true }); }
 
   const branch = `${WORKTREE_BRANCH_PREFIX}${name}`;
-  const created = await mkdtemp(join(tmpdir(), `xeno-wt-${name}-`));
-  // Resolved through symlinks, because git reports the real path and a
-  // caller comparing the two would never match. On macOS /var is a symlink
-  // to /private/var, so every temp path differs by default.
-  const path = await realpath(created);
-  // mkdtemp created it; git worktree add needs the path not to exist.
-  await rm(path, { recursive: true, force: true });
+  if (git(repo, ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]).code === 0) {
+    return { ok: false, error: `branch ${branch} already exists; choose another name or work in its existing checkout` };
+  }
+  let path: string;
+  if (options.location) {
+    await mkdir(options.location.parent, { recursive: true });
+    // Resolved for the same reason as the temp path below.
+    path = join(await realpath(options.location.parent), options.location.leaf);
+    if (existsSync(path)) return { ok: false, error: `${path} already exists; choose another name` };
+  } else {
+    const created = await mkdtemp(join(tmpdir(), `xeno-wt-${name}-`));
+    // Resolved through symlinks, because git reports the real path and a
+    // caller comparing the two would never match. On macOS /var is a symlink
+    // to /private/var, so every temp path differs by default.
+    path = await realpath(created);
+    // mkdtemp created it; git worktree add needs the path not to exist.
+    await rm(path, { recursive: true, force: true });
+  }
 
   // --lock in the same call: locking afterwards leaves a window in which a
   // concurrent prune can remove the worktree that was just created.
@@ -121,6 +165,7 @@ export async function createWorktree(repo: string, name: string): Promise<Create
   if (add.code !== 0) {
     return { ok: false, error: `git worktree add failed: ${add.stderr.trim()}` };
   }
+  if (options.includeChanges === false) return { ok: true, path, branch, snapshot: { head: head.stdout.trim(), tree: git(path, ["rev-parse", "HEAD^{tree}"]).stdout.trim() } };
   // Only this freshly created disposable checkout is reset. The child index
   // carries the parent's uncommitted input, so normal diff/inspection still sees it.
   const hydrate = git(path, ["read-tree", "--reset", "-u", tree]);

package/src/tui/ui/screen.ts

@@ -31,7 +31,7 @@ import { screenLayout, sidebarContentWidth, type ScreenLayout } from "./layout.t
 import { greetingLines, mascotFrame, MASCOT_FRAME_MS, MASCOT_FRAMES, type Greeting } from "./mascot.ts";
 import { MessageList, type MessageFeatures } from "./messages.ts";
 import { Motion } from "./motion.ts";
-import { contextLabel, goalLabel, modeLabels, sidebarLines, speedText, topbarRow, type Line, type StatusModel } from "./status.ts";
+import { contextLabel, goalLabel, idleActivityLabel, modeLabels, sidebarLines, speedText, topbarRow, type Line, type StatusModel } from "./status.ts";
 import { DEFAULT_CELL, stripImageRows } from "./image-size.ts";
 import { formatElapsed } from "./duration.ts";
 import { Pictures, type PictureSource } from "./pictures.ts";
@@ -105,6 +105,8 @@ export class Screen {
   private readonly activity = new Motion();
   private spin = 0;
   private busySince = 0;
+  /** The last turn's wall time, shown beside its outcome until the next turn starts. */
+  private lastTurnMs: number | undefined;
   private lastEvent = 0;
   private activityMs = ACTIVITY_MS;
   private animations = true;
@@ -337,7 +339,8 @@ export class Screen {
   setDock(state: DockState): void {
     const wasBusy = this.dockState.busy;
     this.dockState = state;
-    if (state.busy && !wasBusy) this.busySince = Date.now();
+    if (state.busy && !wasBusy) { this.busySince = Date.now(); this.lastTurnMs = undefined; }
+    if (!state.busy && wasBusy) this.lastTurnMs = Date.now() - this.busySince;
     this.syncActivity();
     this.paintEdges();
   }
@@ -393,7 +396,7 @@ export class Screen {
       const { above, below } = this.composer.overflow;
       if (above) left = [{ segs: [{ text: `↑ ${above} more`, role: "muted" }], priority: 1 }];
       if (below && !this.toastText) right.push({ segs: [{ text: `↓ ${below} more`, role: "muted" }], priority: 2 });
-      if (!above && this.status?.activity) left = [{ segs: [{ text: this.status.activity.label, role: this.status.activity.state === "error" ? "error" : this.status.activity.state === "blocked" ? "warning" : "muted" }], priority: 1, min: 4 }];
+      if (!above && this.status?.activity) left = [idleActivityLabel(this.status.activity, this.lastTurnMs)];
     }
     this.topEdge.setRows([edgeLine({ width, corners: ["╭", "╮"], role, left, right })]);
     const bottomLeft: Label[] = [...(this.status ? modeLabels(this.status) : []), ...(d.model ? [

package/src/tui/ui/status.ts

@@ -385,3 +385,19 @@ export function wrap(text: string, width: number, lines: number): string[] {
   kept[lines - 1] = `${displayWidth(last) + 1 <= w ? last : cells(last, w - 1).trimEnd()}…`;
   return kept;
 }
+
+/**
+ * The input box's top-edge label while no turn runs: the outcome in its own
+ * colour, then how long the last turn took (Codex "Worked for 2m 5s", Claude
+ * Code "Cooked for 1m 6s"). A plain grey "Turn finished" read the same as
+ * "nothing happened" (fix-finished-turn-status).
+ */
+export function idleActivityLabel(activity: NonNullable<StatusModel["activity"]>, turnMs?: number): Label {
+  const tone = activity.state === "done" ? { glyph: "✓", role: "success" as const }
+    : activity.state === "error" ? { glyph: "✗", role: "error" as const }
+    : activity.state === "blocked" ? { glyph: activity.label === "Stopped" ? "■" : "", role: "warning" as const }
+    : { glyph: "", role: "muted" as const };
+  const text = activity.label === "Stopped" && activity.detail ? `Stopped · ${activity.detail}` : activity.label;
+  return { segs: [...(tone.glyph ? [{ text: tone.glyph, role: tone.role }, { text: " ", role: "muted" as const }] : []), { text, role: tone.role },
+    ...(turnMs !== undefined ? [{ text: ` · ${formatElapsed(turnMs)}`, role: "muted" as const }] : [])], priority: 1, min: 4, shrink: tone.glyph ? 2 : 0 };
+}