gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/queue-reorder-ui.ts

@@ -1,276 +0,0 @@
-/**
- * GSD Queue Reorder UI
- *
- * Interactive TUI overlay for reordering pending milestones.
- * ↑/↓ navigates cursor. Space grabs/releases item for moving.
- * While grabbed, ↑/↓ swaps the item with its neighbor.
- * Enter confirms all changes. Esc cancels.
- * Conflicting depends_on entries are auto-removed on confirm.
- */
-
-import type { ExtensionContext } from "@gsd/pi-coding-agent";
-import { type Theme } from "@gsd/pi-coding-agent";
-import { Key, matchesKey, truncateToWidth, type TUI } from "@gsd/pi-tui";
-import { makeUI, GLYPH } from "../shared/mod.js";
-import { validateQueueOrder, type DependencyValidation } from "./queue-order.js";
-
-export interface ReorderItem {
-  id: string;
-  title: string;
-  dependsOn?: string[];
-}
-
-export interface ReorderResult {
-  order: string[];
-  /** depends_on entries to remove from CONTEXT.md files */
-  depsToRemove: Array<{ milestone: string; dep: string }>;
-}
-
-/**
- * Show the queue reorder overlay.
- * Returns the new order + deps to remove, or null if cancelled.
- */
-export async function showQueueReorder(
-  ctx: ExtensionContext,
-  completed: ReorderItem[],
-  pending: ReorderItem[],
-): Promise<ReorderResult | null> {
-  if (!ctx.hasUI) return null;
-  if (pending.length < 2) return null;
-
-  const result = await ctx.ui.custom<ReorderResult | null>((tui: TUI, theme: Theme, _kb, done) => {
-    const items = [...pending];
-    let cursor = 0;
-    let grabbed = false;
-    let cachedLines: string[] | undefined;
-    let validation: DependencyValidation;
-
-    // Mutable deps map — tracks removals during this session
-    const liveDeps = new Map<string, string[]>();
-    for (const item of [...completed, ...pending]) {
-      if (item.dependsOn && item.dependsOn.length > 0) {
-        liveDeps.set(item.id, [...item.dependsOn]);
-      }
-    }
-
-    const removedDeps: Array<{ milestone: string; dep: string }> = [];
-    const completedIds = new Set(completed.map(c => c.id));
-
-    function revalidate() {
-      validation = validateQueueOrder(items.map(i => i.id), liveDeps, completedIds);
-    }
-
-    revalidate();
-
-    function refresh() {
-      cachedLines = undefined;
-      tui.requestRender();
-    }
-
-    function swapItems(fromIdx: number, toIdx: number) {
-      if (toIdx < 0 || toIdx >= items.length) return;
-      const [item] = items.splice(fromIdx, 1);
-      items.splice(toIdx, 0, item);
-      cursor = toIdx;
-      revalidate();
-      refresh();
-    }
-
-    function removeDep(milestone: string, dep: string) {
-      const deps = liveDeps.get(milestone);
-      if (!deps) return;
-      const idx = deps.indexOf(dep);
-      if (idx >= 0) {
-        deps.splice(idx, 1);
-        if (deps.length === 0) liveDeps.delete(milestone);
-        removedDeps.push({ milestone, dep });
-        const item = items.find(i => i.id === milestone);
-        if (item?.dependsOn) {
-          item.dependsOn = item.dependsOn.filter(d => d !== dep);
-        }
-        revalidate();
-        refresh();
-      }
-    }
-
-    function handleInput(data: string) {
-      if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
-        done(null);
-        return;
-      }
-
-      // Confirm — auto-resolve would_block violations
-      if (matchesKey(data, Key.enter)) {
-        const wouldBlock = validation.violations.filter(v => v.type === 'would_block');
-        for (const v of wouldBlock) {
-          removeDep(v.milestone, v.dependsOn);
-        }
-        done({ order: items.map(i => i.id), depsToRemove: removedDeps });
-        return;
-      }
-
-      // Space — toggle grab mode
-      if (data === " ") {
-        grabbed = !grabbed;
-        refresh();
-        return;
-      }
-
-      // ↑/↓ — move grabbed item OR navigate cursor
-      if (matchesKey(data, Key.up)) {
-        if (grabbed) {
-          swapItems(cursor, cursor - 1);
-        } else {
-          cursor = Math.max(0, cursor - 1);
-          refresh();
-        }
-        return;
-      }
-      if (matchesKey(data, Key.down)) {
-        if (grabbed) {
-          swapItems(cursor, cursor + 1);
-        } else {
-          cursor = Math.min(items.length - 1, cursor + 1);
-          refresh();
-        }
-        return;
-      }
-
-      // 'd' — manually remove a dep on the cursor item
-      if (data === "d" || data === "D") {
-        const item = items[cursor];
-        const deps = liveDeps.get(item.id);
-        if (deps) {
-          const activeDep = deps.find(d => !completedIds.has(d));
-          if (activeDep) removeDep(item.id, activeDep);
-        }
-        return;
-      }
-    }
-
-    function render(width: number): string[] {
-      if (cachedLines) return cachedLines;
-
-      const ui = makeUI(theme, width);
-      const lines: string[] = [];
-      const push = (...rows: string[][]) => { for (const r of rows) lines.push(...r); };
-      const add = (s: string) => truncateToWidth(s, width);
-
-      const headerText = grabbed ? "  Queue Reorder — Moving Item" : "  Queue Reorder";
-      push(ui.bar(), ui.blank(), ui.header(headerText), ui.blank());
-
-      // Completed milestones (dimmed)
-      if (completed.length > 0) {
-        lines.push(add(theme.fg("dim", "  Completed:")));
-        for (const m of completed) {
-          const label = m.title && m.title !== m.id ? `${m.id}  ${m.title}` : m.id;
-          lines.push(add(`    ${theme.fg("dim", `${GLYPH.statusDone} ${label}`)}`));
-        }
-        push(ui.blank());
-      }
-
-      // Pending milestones
-      const queueLabel = grabbed ? "  Queue (space to release, ↑/↓ to move):" : "  Queue (space to grab, ↑/↓ to navigate):";
-      lines.push(add(theme.fg("text", queueLabel)));
-
-      const violatedPairs = new Set(
-        validation.violations.filter(v => v.type === 'would_block').map(v => `${v.milestone}:${v.dependsOn}`),
-      );
-      const redundantPairs = new Set(
-        validation.redundant.map(r => `${r.milestone}:${r.dependsOn}`),
-      );
-
-      for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        const isCursor = i === cursor;
-        const num = i + 1;
-        const label = item.title && item.title !== item.id ? `${item.id}  ${item.title}` : item.id;
-
-        if (isCursor && grabbed) {
-          lines.push(add(`  ${theme.fg("warning", `▸▸ ${num}. ${label}`)}`));
-        } else if (isCursor) {
-          lines.push(add(`  ${theme.fg("accent", `${GLYPH.cursor} ${num}. ${label}`)}`));
-        } else {
-          lines.push(add(`    ${theme.fg("text", `${num}. ${label}`)}`));
-        }
-
-        // depends_on annotations
-        const deps = liveDeps.get(item.id) ?? [];
-        for (const dep of deps) {
-          if (completedIds.has(dep)) continue;
-          const pairKey = `${item.id}:${dep}`;
-          if (violatedPairs.has(pairKey)) {
-            lines.push(add(`       ${theme.fg("warning", `${GLYPH.statusWarning} depends_on: ${dep} — auto-removed on confirm`)}`));
-          } else if (redundantPairs.has(pairKey)) {
-            lines.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep} (redundant)`)}`));
-          } else {
-            lines.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep}`)}`));
-          }
-        }
-
-        // Missing deps
-        for (const v of validation.violations.filter(v => v.milestone === item.id && v.type === 'missing_dep')) {
-          lines.push(add(`       ${theme.fg("error", `${GLYPH.statusWarning} depends_on: ${v.dependsOn} (does not exist)`)}`));
-        }
-      }
-
-      // Removed deps feedback
-      if (removedDeps.length > 0) {
-        push(ui.blank());
-        for (const r of removedDeps) {
-          lines.push(add(`  ${theme.fg("success", `${GLYPH.statusDone} Removed: ${r.milestone} depends_on ${r.dep}`)}`));
-        }
-      }
-
-      // Circular warning
-      const circ = validation.violations.find(v => v.type === 'circular');
-      if (circ) {
-        push(ui.blank());
-        lines.push(add(`  ${theme.fg("error", `${GLYPH.statusWarning} ${circ.message}`)}`));
-      }
-
-      push(ui.blank());
-
-      // Hints — context-sensitive based on grab state
-      const hints: string[] = [];
-      if (grabbed) {
-        hints.push("↑/↓ move item", "space release");
-      } else {
-        hints.push("↑/↓ navigate", "space grab");
-      }
-      const hasDeps = liveDeps.get(items[cursor]?.id)?.some(d => !completedIds.has(d));
-      if (hasDeps) hints.push("d del dep");
-
-      const wouldBlockCount = validation.violations.filter(v => v.type === 'would_block').length;
-      if (wouldBlockCount > 0) {
-        hints.push(`enter (fixes ${wouldBlockCount} dep)`);
-      } else {
-        hints.push("enter ok");
-      }
-      hints.push("esc");
-
-      push(ui.hints(hints), ui.bar());
-
-      cachedLines = lines;
-      return lines;
-    }
-
-    return { render, invalidate: () => { cachedLines = undefined; }, handleInput };
-  }, {
-    overlay: true,
-    overlayOptions: { width: "70%", minWidth: 50, maxHeight: "80%", anchor: "center" },
-  });
-
-  // Fallback for RPC mode where ctx.ui.custom() returns undefined.
-  // Reorder requires interactive input — notify and return null.
-  if (result === undefined) {
-    ctx.ui.notify(
-      "Queue reorder requires an interactive terminal. Current order: " +
-        pending.map(p => p.id).join(" → "),
-      "warning",
-    );
-    return null;
-  }
-
-  return result;
-}

package/dist/resources/extensions/gsd/quick.ts

@@ -1,212 +0,0 @@
-/**
- * GSD Quick Mode — /gsd quick <task>
- * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
- *
- * Lightweight task execution with GSD guarantees (atomic commits, state
- * tracking) but without the full milestone/slice ceremony.
- *
- * Quick tasks live in `.gsd/quick/` and are tracked in STATE.md's
- * "Quick Tasks Completed" table.
- */
-
-import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
-import { existsSync, mkdirSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { loadPrompt } from "./prompt-loader.js";
-import { gsdRoot } from "./paths.js";
-import { createGitService, runGit } from "./git-service.js";
-import { getErrorMessage } from "./error-utils.js";
-
-// ─── Quick Task Helpers ───────────────────────────────────────────────────────
-
-/**
- * Generate a URL-friendly slug from a description.
- * Lowercase, hyphens, max 40 chars.
- */
-function slugify(text: string): string {
-  return text
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-|-$/g, "")
-    .slice(0, 40)
-    .replace(/-$/, "");
-}
-
-/**
- * Determine the next quick task number by scanning existing directories.
- */
-function getNextTaskNum(quickDir: string): number {
-  if (!existsSync(quickDir)) return 1;
-  try {
-    const entries = readdirSync(quickDir, { withFileTypes: true });
-    let max = 0;
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const match = entry.name.match(/^(\d+)-/);
-      if (match) {
-        const num = parseInt(match[1], 10);
-        if (num > max) max = num;
-      }
-    }
-    return max + 1;
-  } catch {
-    return 1;
-  }
-}
-
-/**
- * Ensure the quick task directory structure exists.
- * Returns the task directory path.
- */
-function ensureQuickDir(basePath: string, taskNum: number, slug: string): string {
-  const quickDir = join(gsdRoot(basePath), "quick");
-  const taskDir = join(quickDir, `${taskNum}-${slug}`);
-  mkdirSync(taskDir, { recursive: true });
-  return taskDir;
-}
-
-// ─── Main Handler ─────────────────────────────────────────────────────────────
-
-export async function handleQuick(
-  args: string,
-  ctx: ExtensionCommandContext,
-  pi: ExtensionAPI,
-): Promise<void> {
-  const basePath = process.cwd();
-  const root = gsdRoot(basePath);
-
-  // Validate: .gsd/ must exist
-  if (!existsSync(root)) {
-    ctx.ui.notify(
-      "No .gsd/ directory found. Run /gsd to initialize a project first.",
-      "error",
-    );
-    return;
-  }
-
-  // Parse description from args
-  let description = args.trim();
-  if (!description) {
-    ctx.ui.notify(
-      "Usage: /gsd quick <task description>\n\nExample: /gsd quick fix login button not responding on mobile",
-      "info",
-    );
-    return;
-  }
-
-  // Setup
-  const quickDir = join(root, "quick");
-  const taskNum = getNextTaskNum(quickDir);
-  const slug = slugify(description);
-  const taskDir = ensureQuickDir(basePath, taskNum, slug);
-  const taskDirRel = `.gsd/quick/${taskNum}-${slug}`;
-  const date = new Date().toISOString().split("T")[0];
-
-  // Create git branch for the quick task (unless isolation: none)
-  const git = createGitService(basePath);
-  const branchName = `gsd/quick/${taskNum}-${slug}`;
-  const skipBranch = git.prefs.isolation === "none";
-
-  let branchCreated = false;
-  let originalBranch: string | undefined;
-  if (!skipBranch) {
-    try {
-      originalBranch = git.getCurrentBranch();
-      if (originalBranch !== branchName) {
-        // Auto-commit any dirty state before switching
-        try {
-          git.autoCommit("quick-task", `Q${taskNum}`, []);
-        } catch { /* nothing to commit — fine */ }
-
-        runGit(basePath, ["checkout", "-b", branchName]);
-        branchCreated = true;
-      }
-    } catch (err) {
-      // Branch creation failed — continue on current branch
-      const message = getErrorMessage(err);
-      ctx.ui.notify(`Could not create branch ${branchName}: ${message}. Working on current branch.`, "warning");
-    }
-  }
-
-  const actualBranch = branchCreated ? branchName : git.getCurrentBranch();
-
-  // Notify user
-  ctx.ui.notify(
-    `Quick task ${taskNum}: ${description}\nDirectory: ${taskDirRel}\nBranch: ${actualBranch}`,
-    "info",
-  );
-
-  // Build and dispatch the quick task prompt
-  const summaryPath = `${taskDirRel}/${taskNum}-SUMMARY.md`;
-  const prompt = loadPrompt("quick-task", {
-    description,
-    taskDir: taskDirRel,
-    branch: actualBranch,
-    summaryPath,
-    date,
-    taskNum: String(taskNum),
-    slug,
-  });
-
-  pi.sendMessage(
-    {
-      customType: "gsd-quick-task",
-      content: prompt,
-      display: false,
-    },
-    { triggerTurn: true },
-  );
-
-  // Schedule branch merge-back after the quick task agent session ends.
-  // Without this, auto-mode resumes on the quick-task branch (#1269).
-  if (branchCreated && originalBranch) {
-    _pendingQuickBranchReturn = {
-      basePath,
-      originalBranch,
-      quickBranch: branchName,
-      taskNum,
-      slug,
-      description,
-    };
-  }
-}
-
-/** Pending quick-task branch return — consumed by cleanupQuickBranch(). */
-let _pendingQuickBranchReturn: {
-  basePath: string;
-  originalBranch: string;
-  quickBranch: string;
-  taskNum: number;
-  slug: string;
-  description: string;
-} | null = null;
-
-/**
- * Merge the quick-task branch back to the original branch and switch.
- * Called from the agent_end handler after a quick task completes.
- * Returns true if a branch return was performed.
- */
-export function cleanupQuickBranch(): boolean {
-  if (!_pendingQuickBranchReturn) return false;
-  const { basePath, originalBranch, quickBranch, taskNum, slug, description } = _pendingQuickBranchReturn;
-  _pendingQuickBranchReturn = null;
-
-  try {
-    // Auto-commit any remaining work
-    try { runGit(basePath, ["add", "-A"]); } catch {}
-    try { runGit(basePath, ["commit", "-m", `quick(Q${taskNum}): ${slug}`]); } catch {}
-
-    // Switch back and merge
-    runGit(basePath, ["checkout", originalBranch]);
-    try {
-      runGit(basePath, ["merge", "--squash", quickBranch]);
-      runGit(basePath, ["commit", "-m", `quick(Q${taskNum}): ${description.slice(0, 72)}`]);
-    } catch { /* merge conflict or nothing — non-fatal */ }
-
-    // Clean up quick branch
-    try { runGit(basePath, ["branch", "-D", quickBranch]); } catch {}
-    return true;
-  } catch {
-    return false;
-  }
-}

package/dist/resources/extensions/gsd/repo-identity.ts

@@ -1,169 +0,0 @@
-/**
- * GSD Repo Identity — external state directory primitives.
- *
- * Computes a stable per-repo identity hash, resolves the external
- * `~/.gsd/projects/<hash>/` state directory, and manages the
- * `<project>/.gsd → external` symlink.
- */
-
-import { createHash } from "node:crypto";
-import { execFileSync } from "node:child_process";
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, symlinkSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve, sep } from "node:path";
-
-// ─── Repo Identity ──────────────────────────────────────────────────────────
-
-/**
- * Get the git remote URL for "origin", or "" if no remote is configured.
- * Uses `git config` rather than `git remote get-url` for broader compat.
- */
-function getRemoteUrl(basePath: string): string {
-  try {
-    return execFileSync("git", ["config", "--get", "remote.origin.url"], {
-      cwd: basePath,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-      timeout: 5_000,
-    }).trim();
-  } catch {
-    return "";
-  }
-}
-
-/**
- * Resolve the git toplevel (real root) for the given path.
- * For worktrees this returns the main repo root, not the worktree path.
- */
-function resolveGitRoot(basePath: string): string {
-  try {
-    // In a worktree, --show-toplevel returns the worktree path, not the main
-    // repo root. Use --git-common-dir to find the shared .git directory,
-    // then derive the main repo root from it (#1288).
-    const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
-      cwd: basePath,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-      timeout: 5_000,
-    }).trim();
-
-    // If commonDir ends with .git/worktrees/<name>, the main repo is two
-    // levels up from the worktrees dir. If it's just .git, resolve normally.
-    if (commonDir.includes(`${sep}worktrees${sep}`) || commonDir.includes("/worktrees/")) {
-      // e.g., /path/to/project/.gsd/worktrees/M001/.git → /path/to/project
-      // or /path/to/project/.git/worktrees/M001 → /path/to/project
-      const gitDir = commonDir.replace(/[/\\]worktrees[/\\][^/\\]+$/, "");
-      const mainRoot = resolve(gitDir, "..");
-      return mainRoot;
-    }
-
-    // Not in a worktree — use --show-toplevel as usual
-    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd: basePath,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-      timeout: 5_000,
-    }).trim();
-  } catch {
-    return resolve(basePath);
-  }
-}
-
-/**
- * Compute a stable identity for a repository.
- *
- * SHA-256 of `${remoteUrl}\n${resolvedRoot}`, truncated to 12 hex chars.
- * Deterministic: same repo always produces the same hash regardless of
- * which worktree the caller is inside.
- */
-export function repoIdentity(basePath: string): string {
-  const remoteUrl = getRemoteUrl(basePath);
-  const root = resolveGitRoot(basePath);
-  const input = `${remoteUrl}\n${root}`;
-  return createHash("sha256").update(input).digest("hex").slice(0, 12);
-}
-
-// ─── External State Directory ───────────────────────────────────────────────
-
-/**
- * Compute the external GSD state directory for a repository.
- *
- * Returns `$GSD_STATE_DIR/projects/<hash>` if `GSD_STATE_DIR` is set,
- * otherwise `~/.gsd/projects/<hash>`.
- */
-export function externalGsdRoot(basePath: string): string {
-  const base = process.env.GSD_STATE_DIR || join(homedir(), ".gsd");
-  return join(base, "projects", repoIdentity(basePath));
-}
-
-// ─── Symlink Management ─────────────────────────────────────────────────────
-
-/**
- * Ensure the `<project>/.gsd` symlink points to the external state directory.
- *
- * 1. mkdir -p the external dir
- * 2. If `<project>/.gsd` doesn't exist → create symlink
- * 3. If `<project>/.gsd` is already the correct symlink → no-op
- * 4. If `<project>/.gsd` is a real directory → return as-is (migration handles later)
- *
- * Returns the resolved external path.
- */
-export function ensureGsdSymlink(projectPath: string): string {
-  const externalPath = externalGsdRoot(projectPath);
-  const localGsd = join(projectPath, ".gsd");
-
-  // Ensure external directory exists
-  mkdirSync(externalPath, { recursive: true });
-
-  if (!existsSync(localGsd)) {
-    // Nothing exists yet — create symlink
-    symlinkSync(externalPath, localGsd, "junction");
-    return externalPath;
-  }
-
-  try {
-    const stat = lstatSync(localGsd);
-
-    if (stat.isSymbolicLink()) {
-      // Already a symlink — verify it points to the right place
-      const target = realpathSync(localGsd);
-      if (target === externalPath) {
-        return externalPath; // correct symlink, no-op
-      }
-      // Symlink exists but points elsewhere — leave it for now
-      // (could be a custom override or stale symlink)
-      return target;
-    }
-
-    if (stat.isDirectory()) {
-      // Real directory — migration will handle this later.
-      // Return the local path so existing code still works.
-      return localGsd;
-    }
-  } catch {
-    // lstat failed — path exists but we can't stat it
-  }
-
-  return localGsd;
-}
-
-// ─── Worktree Detection ─────────────────────────────────────────────────────
-
-/**
- * Check if the given directory is a git worktree (not the main repo).
- *
- * Git worktrees have a `.git` *file* (not directory) containing a
- * `gitdir:` pointer. This is git's native worktree indicator — no
- * string marker parsing needed.
- */
-export function isInsideWorktree(cwd: string): boolean {
-  const gitPath = join(cwd, ".git");
-  try {
-    const stat = lstatSync(gitPath);
-    if (!stat.isFile()) return false;
-    const content = readFileSync(gitPath, "utf-8").trim();
-    return content.startsWith("gitdir:");
-  } catch {
-    return false;
-  }
-}