gsd-pi 2.33.1 → 2.34.0-dev.6769913

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

@@ -1,223 +0,0 @@
-// GSD Extension — Undo Last Unit
-// Rollback the most recent completed unit: revert git, remove state, uncheck plans.
-
-import type { ExtensionCommandContext, ExtensionAPI } from "@gsd/pi-coding-agent";
-import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { nativeRevertCommit, nativeRevertAbort } from "./native-git-bridge.js";
-import { deriveState } from "./state.js";
-import { invalidateAllCaches } from "./cache.js";
-import { gsdRoot, resolveTasksDir, resolveSlicePath, buildTaskFileName } from "./paths.js";
-import { sendDesktopNotification } from "./notifications.js";
-import { parseUnitId } from "./unit-id.js";
-
-/**
- * Undo the last completed unit: revert git commits, remove from completed-units,
- * delete summary artifacts, and uncheck the task in PLAN.
- */
-export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi: ExtensionAPI, basePath: string): Promise<void> {
-  const force = args.includes("--force");
-
-  // 1. Load completed-units.json
-  const completedKeysFile = join(gsdRoot(basePath), "completed-units.json");
-  if (!existsSync(completedKeysFile)) {
-    ctx.ui.notify("Nothing to undo — no completed units found.", "info");
-    return;
-  }
-
-  let keys: string[];
-  try {
-    keys = JSON.parse(readFileSync(completedKeysFile, "utf-8"));
-  } catch {
-    ctx.ui.notify("Nothing to undo — completed-units.json is corrupt.", "warning");
-    return;
-  }
-
-  if (keys.length === 0) {
-    ctx.ui.notify("Nothing to undo — no completed units.", "info");
-    return;
-  }
-
-  // Get the last completed unit
-  const lastKey = keys[keys.length - 1];
-  const sepIdx = lastKey.indexOf("/");
-  const unitType = sepIdx >= 0 ? lastKey.slice(0, sepIdx) : lastKey;
-  const unitId = sepIdx >= 0 ? lastKey.slice(sepIdx + 1) : lastKey;
-
-  if (!force) {
-    ctx.ui.notify(
-      `Will undo: ${unitType} (${unitId})\n` +
-      `This will:\n` +
-      `  - Remove from completed-units.json\n` +
-      `  - Delete summary artifacts\n` +
-      `  - Uncheck task in PLAN (if execute-task)\n` +
-      `  - Attempt to revert associated git commits\n\n` +
-      `Run /gsd undo --force to confirm.`,
-      "warning",
-    );
-    return;
-  }
-
-  // 2. Remove from completed-units.json
-  keys = keys.filter(k => k !== lastKey);
-  writeFileSync(completedKeysFile, JSON.stringify(keys), "utf-8");
-
-  // 3. Delete summary artifact
-  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-  let summaryRemoved = false;
-  if (mid && sid && tid) {
-    // Task-level: M001/S01/T01
-    const tasksDir = resolveTasksDir(basePath, mid, sid);
-    if (tasksDir) {
-      const summaryFile = join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
-      if (existsSync(summaryFile)) {
-        unlinkSync(summaryFile);
-        summaryRemoved = true;
-      }
-    }
-  } else if (mid && sid) {
-    // Slice-level: M001/S01
-    const slicePath = resolveSlicePath(basePath, mid, sid);
-    if (slicePath) {
-      // Try common summary filenames
-      for (const suffix of ["SUMMARY", "COMPLETE"]) {
-        const candidates = findFileWithPrefix(slicePath, sid, suffix);
-        for (const f of candidates) {
-          unlinkSync(f);
-          summaryRemoved = true;
-        }
-      }
-    }
-  }
-
-  // 4. Uncheck task in PLAN if execute-task
-  let planUpdated = false;
-  if (unitType === "execute-task" && mid && sid && tid) {
-    planUpdated = uncheckTaskInPlan(basePath, mid, sid, tid);
-  }
-
-  // 5. Try to revert git commits from activity log
-  let commitsReverted = 0;
-  const activityDir = join(gsdRoot(basePath), "activity");
-  try {
-    if (existsSync(activityDir)) {
-      const commits = findCommitsForUnit(activityDir, unitType, unitId);
-      if (commits.length > 0) {
-        for (const sha of commits.reverse()) {
-          try {
-            nativeRevertCommit(basePath, sha);
-            commitsReverted++;
-          } catch {
-            // Revert conflict or already reverted — skip
-            try { nativeRevertAbort(basePath); } catch { /* no-op */ }
-            break;
-          }
-        }
-      }
-    }
-  } finally {
-    // 6. Re-derive state — always invalidate caches even if git operations fail
-    invalidateAllCaches();
-    await deriveState(basePath);
-  }
-
-  // Build result message
-  const results: string[] = [`Undone: ${unitType} (${unitId})`];
-  results.push(`  - Removed from completed-units.json`);
-  if (summaryRemoved) results.push(`  - Deleted summary artifact`);
-  if (planUpdated) results.push(`  - Unchecked task in PLAN`);
-  if (commitsReverted > 0) {
-    results.push(`  - Reverted ${commitsReverted} commit(s) (staged, not committed)`);
-    results.push(`  Review with 'git diff --cached' then 'git commit' or 'git reset HEAD'`);
-  }
-
-  ctx.ui.notify(results.join("\n"), "success");
-  sendDesktopNotification("GSD", `Undone: ${unitType} (${unitId})`, "info", "complete");
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-export function uncheckTaskInPlan(basePath: string, mid: string, sid: string, tid: string): boolean {
-  const slicePath = resolveSlicePath(basePath, mid, sid);
-  if (!slicePath) return false;
-
-  // Find the PLAN file
-  const planCandidates = findFileWithPrefix(slicePath, sid, "PLAN");
-  if (planCandidates.length === 0) return false;
-
-  const planFile = planCandidates[0];
-  let content = readFileSync(planFile, "utf-8");
-
-  // Match checked task line: - [x] **T01** or - [x] T01:
-  const regex = new RegExp(`^(\\s*-\\s*)\\[x\\](\\s*\\**${tid}\\**[:\\s])`, "mi");
-  if (regex.test(content)) {
-    content = content.replace(regex, "$1[ ]$2");
-    writeFileSync(planFile, content, "utf-8");
-    return true;
-  }
-  return false;
-}
-
-function findFileWithPrefix(dir: string, prefix: string, suffix: string): string[] {
-  try {
-    const files = readdirSync(dir);
-    return files
-      .filter(f => f.includes(suffix) && (f.startsWith(prefix) || f.startsWith(`${prefix}-`)))
-      .map(f => join(dir, f));
-  } catch {
-    return [];
-  }
-}
-
-export function findCommitsForUnit(activityDir: string, unitType: string, unitId: string): string[] {
-  const safeUnitId = unitId.replace(/\//g, "-");
-  const commitSet = new Set<string>();
-  const commits: string[] = [];
-
-  try {
-    const files = readdirSync(activityDir)
-      .filter(f => f.includes(unitType) && f.includes(safeUnitId) && f.endsWith(".jsonl"))
-      .sort()
-      .reverse();
-
-    if (files.length === 0) return [];
-
-    // Parse the most recent activity log for this unit
-    const content = readFileSync(join(activityDir, files[0]), "utf-8");
-    for (const line of content.split("\n")) {
-      if (!line.trim()) continue;
-      try {
-        const entry = JSON.parse(line);
-        // Look for tool results containing git commit output
-        if (entry?.message?.content) {
-          const blocks = Array.isArray(entry.message.content) ? entry.message.content : [];
-          for (const block of blocks) {
-            if (block.type === "tool_result" && typeof block.content === "string") {
-              for (const sha of extractCommitShas(block.content)) {
-                if (!commitSet.has(sha)) {
-                  commitSet.add(sha);
-                  commits.push(sha);
-                }
-              }
-            }
-          }
-        }
-      } catch { /* malformed JSON line — skip */ }
-    }
-  } catch { /* activity dir issues — skip */ }
-
-  return commits;
-}
-
-export function extractCommitShas(content: string): string[] {
-  const seen = new Set<string>();
-  const commits: string[] = [];
-  for (const match of content.matchAll(/\[[\w/.-]+\s+([a-f0-9]{7,40})\]/g)) {
-    const sha = match[1];
-    if (sha && !seen.has(sha)) {
-      seen.add(sha);
-      commits.push(sha);
-    }
-  }
-  return commits;
-}

package/dist/resources/extensions/gsd/unit-id.ts

@@ -1,14 +0,0 @@
-// GSD Extension — Unit ID Parsing
-// Centralizes the milestone/slice/task decomposition of unit ID strings.
-
-export interface ParsedUnitId {
-  milestone: string;
-  slice?: string;
-  task?: string;
-}
-
-/** Parse a unit ID string (e.g. "M1/S1/T1") into its milestone, slice, and task components. */
-export function parseUnitId(unitId: string): ParsedUnitId {
-  const [milestone, slice, task] = unitId.split("/");
-  return { milestone: milestone!, slice, task };
-}

package/dist/resources/extensions/gsd/unit-runtime.ts

@@ -1,192 +0,0 @@
-import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import {
-  gsdRoot,
-  relSliceFile,
-  relTaskFile,
-  resolveSliceFile,
-  resolveTaskFile,
-} from "./paths.js";
-import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
-import { loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
-import { parseUnitId } from "./unit-id.js";
-
-export type UnitRuntimePhase =
-  | "dispatched"
-  | "wrapup-warning-sent"
-  | "timeout"
-  | "recovered"
-  | "finalized"
-  | "paused"
-  | "skipped";
-
-export interface ExecuteTaskRecoveryStatus {
-  planPath: string;
-  summaryPath: string;
-  summaryExists: boolean;
-  taskChecked: boolean;
-  nextActionAdvanced: boolean;
-  mustHaveCount: number;
-  mustHavesMentionedInSummary: number;
-}
-
-export interface AutoUnitRuntimeRecord {
-  version: 1;
-  unitType: string;
-  unitId: string;
-  startedAt: number;
-  updatedAt: number;
-  phase: UnitRuntimePhase;
-  wrapupWarningSent: boolean;
-  continueHereFired: boolean;
-  timeoutAt: number | null;
-  lastProgressAt: number;
-  progressCount: number;
-  lastProgressKind: string;
-  recovery?: ExecuteTaskRecoveryStatus;
-  recoveryAttempts?: number;
-  lastRecoveryReason?: "idle" | "hard";
-}
-
-function isAutoUnitRuntimeRecord(data: unknown): data is AutoUnitRuntimeRecord {
-  return (
-    typeof data === "object" &&
-    data !== null &&
-    (data as AutoUnitRuntimeRecord).version === 1 &&
-    typeof (data as AutoUnitRuntimeRecord).unitType === "string" &&
-    typeof (data as AutoUnitRuntimeRecord).unitId === "string"
-  );
-}
-
-function runtimeDir(basePath: string): string {
-  return join(gsdRoot(basePath), "runtime", "units");
-}
-
-function runtimePath(basePath: string, unitType: string, unitId: string): string {
-  const sanitizedUnitType = unitType.replace(/[^a-zA-Z0-9._-]+/g, "-");
-  const sanitizedUnitId = unitId.replace(/[^a-zA-Z0-9._-]+/g, "-");
-  return join(runtimeDir(basePath), `${sanitizedUnitType}-${sanitizedUnitId}.json`);
-}
-
-export function writeUnitRuntimeRecord(
-  basePath: string,
-  unitType: string,
-  unitId: string,
-  startedAt: number,
-  updates: Partial<AutoUnitRuntimeRecord> = {},
-): AutoUnitRuntimeRecord {
-  const path = runtimePath(basePath, unitType, unitId);
-  const prev = readUnitRuntimeRecord(basePath, unitType, unitId);
-  const next: AutoUnitRuntimeRecord = {
-    version: 1,
-    unitType,
-    unitId,
-    startedAt,
-    updatedAt: Date.now(),
-    phase: updates.phase ?? prev?.phase ?? "dispatched",
-    wrapupWarningSent: updates.wrapupWarningSent ?? prev?.wrapupWarningSent ?? false,
-    continueHereFired: updates.continueHereFired ?? prev?.continueHereFired ?? false,
-    timeoutAt: updates.timeoutAt ?? prev?.timeoutAt ?? null,
-    lastProgressAt: updates.lastProgressAt ?? prev?.lastProgressAt ?? Date.now(),
-    progressCount: updates.progressCount ?? prev?.progressCount ?? 0,
-    lastProgressKind: updates.lastProgressKind ?? prev?.lastProgressKind ?? "dispatch",
-    recovery: updates.recovery ?? prev?.recovery,
-    recoveryAttempts: updates.recoveryAttempts ?? prev?.recoveryAttempts ?? 0,
-    lastRecoveryReason: updates.lastRecoveryReason ?? prev?.lastRecoveryReason,
-  };
-  saveJsonFile(path, next);
-  return next;
-}
-
-export function readUnitRuntimeRecord(basePath: string, unitType: string, unitId: string): AutoUnitRuntimeRecord | null {
-  return loadJsonFileOrNull(runtimePath(basePath, unitType, unitId), isAutoUnitRuntimeRecord);
-}
-
-export function clearUnitRuntimeRecord(basePath: string, unitType: string, unitId: string): void {
-  const path = runtimePath(basePath, unitType, unitId);
-  if (existsSync(path)) unlinkSync(path);
-}
-
-/**
- * Return all runtime records currently on disk for `basePath`.
- * Returns an empty array if the runtime directory does not exist.
- */
-export function listUnitRuntimeRecords(basePath: string): AutoUnitRuntimeRecord[] {
-  const dir = runtimeDir(basePath);
-  if (!existsSync(dir)) return [];
-  const results: AutoUnitRuntimeRecord[] = [];
-  for (const file of readdirSync(dir)) {
-    if (!file.endsWith(".json")) continue;
-    try {
-      const raw = readFileSync(join(dir, file), "utf-8");
-      const record = JSON.parse(raw) as AutoUnitRuntimeRecord;
-      results.push(record);
-    } catch {
-      // Skip malformed files
-    }
-  }
-  return results;
-}
-
-export async function inspectExecuteTaskDurability(
-  basePath: string,
-  unitId: string,
-): Promise<ExecuteTaskRecoveryStatus | null> {
-  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-  if (!mid || !sid || !tid) return null;
-
-  const planAbs = resolveSliceFile(basePath, mid, sid, "PLAN");
-  const summaryAbs = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
-  const stateAbs = join(gsdRoot(basePath), "STATE.md");
-
-  const planPath = relSliceFile(basePath, mid, sid, "PLAN");
-  const summaryPath = relTaskFile(basePath, mid, sid, tid, "SUMMARY");
-
-  const planContent = planAbs ? await loadFile(planAbs) : null;
-  const stateContent = existsSync(stateAbs) ? readFileSync(stateAbs, "utf-8") : "";
-  const summaryExists = !!(summaryAbs && existsSync(summaryAbs));
-
-  const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const taskChecked = !!planContent && new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m").test(planContent);
-  const nextActionAdvanced = !new RegExp(`Execute ${tid}\\b`).test(stateContent);
-
-  // Must-have coverage: load task plan and count mentions in summary
-  let mustHaveCount = 0;
-  let mustHavesMentionedInSummary = 0;
-
-  const taskPlanAbs = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
-  if (taskPlanAbs) {
-    const taskPlanContent = await loadFile(taskPlanAbs);
-    if (taskPlanContent) {
-      const mustHaves = parseTaskPlanMustHaves(taskPlanContent);
-      mustHaveCount = mustHaves.length;
-      if (mustHaveCount > 0 && summaryExists && summaryAbs) {
-        const summaryContent = await loadFile(summaryAbs);
-        if (summaryContent) {
-          mustHavesMentionedInSummary = countMustHavesMentionedInSummary(mustHaves, summaryContent);
-        }
-      }
-    }
-  }
-
-  return {
-    planPath,
-    summaryPath,
-    summaryExists,
-    taskChecked,
-    nextActionAdvanced,
-    mustHaveCount,
-    mustHavesMentionedInSummary,
-  };
-}
-
-export function formatExecuteTaskRecoveryStatus(status: ExecuteTaskRecoveryStatus): string {
-  const missing = [] as string[];
-  if (!status.summaryExists) missing.push(`summary missing (${status.summaryPath})`);
-  if (!status.taskChecked) missing.push(`task checkbox unchecked in ${status.planPath}`);
-  if (!status.nextActionAdvanced) missing.push("state next action still points at the timed-out task");
-  if (status.mustHaveCount > 0 && status.mustHavesMentionedInSummary < status.mustHaveCount) {
-    missing.push(`must-have gap: ${status.mustHavesMentionedInSummary} of ${status.mustHaveCount} must-haves addressed in summary`);
-  }
-  return missing.length > 0 ? missing.join("; ") : "all durable task artifacts present";
-}

package/dist/resources/extensions/gsd/validate-directory.ts

@@ -1,164 +0,0 @@
-/**
- * GSD Directory Validation — Safeguards against running in dangerous directories.
- *
- * Prevents GSD from creating .gsd/ structures in system paths, home directories,
- * or other locations where writing project scaffolding would be harmful.
- */
-
-import { realpathSync, readdirSync } from "node:fs";
-import { homedir, platform, tmpdir } from "node:os";
-import { resolve } from "node:path";
-
-// ─── Types ──────────────────────────────────────────────────────────────────────
-
-export interface DirectoryValidationResult {
-  /** Whether the directory is safe for GSD operations */
-  safe: boolean;
-  /** Severity: "blocked" = hard stop, "warning" = user can override */
-  severity: "ok" | "blocked" | "warning";
-  /** Human-readable reason if not safe */
-  reason?: string;
-}
-
-// ─── Blocked Paths ──────────────────────────────────────────────────────────────
-
-/** Paths where GSD must never create .gsd/ — no override possible. */
-const UNIX_BLOCKED_PATHS = new Set([
-  "/",
-  "/bin",
-  "/sbin",
-  "/usr",
-  "/usr/bin",
-  "/usr/sbin",
-  "/usr/lib",
-  "/usr/local",
-  "/usr/local/bin",
-  "/etc",
-  "/var",
-  "/var/tmp",
-  "/dev",
-  "/proc",
-  "/sys",
-  "/boot",
-  "/lib",
-  "/lib64",
-  // macOS-specific
-  "/System",
-  "/Library",
-  "/Applications",
-  "/Volumes",
-  "/private",
-  "/private/var",
-  "/private/etc",
-  "/private/tmp",
-]);
-
-const WINDOWS_BLOCKED_PATHS = new Set([
-  "C:\\",
-  "C:\\Windows",
-  "C:\\Windows\\System32",
-  "C:\\Program Files",
-  "C:\\Program Files (x86)",
-]);
-
-// ─── Core Validation ────────────────────────────────────────────────────────────
-
-/**
- * Validate whether a directory is safe for GSD to operate in.
- *
- * Checks in order:
- * 1. Blocked system paths (hard stop)
- * 2. Home directory itself (hard stop)
- * 3. Temp directory root (hard stop)
- * 4. High entry count heuristic (warning)
- */
-export function validateDirectory(dirPath: string): DirectoryValidationResult {
-  // Resolve to absolute + follow symlinks so aliases can't bypass checks
-  let resolved: string;
-  try {
-    resolved = realpathSync(resolve(dirPath));
-  } catch {
-    // If we can't resolve, use the raw resolved path
-    resolved = resolve(dirPath);
-  }
-
-  // Normalize trailing slashes for consistent comparison.
-  // Special cases: "/" → "/" (not ""), "C:\" → "C:\" (not "C:")
-  let normalized = resolved.replace(/[/\\]+$/, "");
-  if (normalized === "") {
-    normalized = "/";
-  } else if (/^[A-Za-z]:$/.test(normalized)) {
-    normalized = normalized + "\\";
-  }
-
-  // ── Check 1: Blocked system paths ──────────────────────────────────────
-  const blockedPaths = platform() === "win32" ? WINDOWS_BLOCKED_PATHS : UNIX_BLOCKED_PATHS;
-  if (blockedPaths.has(normalized)) {
-    return {
-      safe: false,
-      severity: "blocked",
-      reason: `Refusing to run in system directory: ${normalized}. GSD must be run inside a project directory.`,
-    };
-  }
-
-  // ── Check 2: Home directory itself (not subdirs) ───────────────────────
-  let resolvedHome: string;
-  try {
-    resolvedHome = realpathSync(resolve(homedir())).replace(/[/\\]+$/, "");
-  } catch {
-    resolvedHome = resolve(homedir()).replace(/[/\\]+$/, "");
-  }
-
-  if (normalized === resolvedHome) {
-    return {
-      safe: false,
-      severity: "blocked",
-      reason: `Refusing to run in your home directory (${normalized}). GSD must be run inside a project directory, not $HOME.`,
-    };
-  }
-
-  // ── Check 3: Temp directory root ───────────────────────────────────────
-  let resolvedTmp: string;
-  try {
-    resolvedTmp = realpathSync(resolve(tmpdir())).replace(/[/\\]+$/, "");
-  } catch {
-    resolvedTmp = resolve(tmpdir()).replace(/[/\\]+$/, "");
-  }
-
-  if (normalized === resolvedTmp) {
-    return {
-      safe: false,
-      severity: "blocked",
-      reason: `Refusing to run in the system temp directory (${normalized}). Use a project subdirectory instead.`,
-    };
-  }
-
-  // ── Check 4: Suspiciously large directory (heuristic warning) ──────────
-  try {
-    const entries = readdirSync(normalized);
-    if (entries.length > 200) {
-      return {
-        safe: false,
-        severity: "warning",
-        reason: `This directory has ${entries.length} entries, which suggests it may not be a project directory. Are you sure you want to initialize GSD here?`,
-      };
-    }
-  } catch {
-    // Can't read directory — let downstream handle the error
-  }
-
-  return { safe: true, severity: "ok" };
-}
-
-/**
- * Assert that a directory is safe for GSD operations.
- * Throws with a descriptive message if the directory is blocked.
- * Returns the validation result for warnings (caller decides how to handle).
- */
-export function assertSafeDirectory(dirPath: string): DirectoryValidationResult {
-  const result = validateDirectory(dirPath);
-  if (result.severity === "blocked") {
-    throw new Error(result.reason);
-  }
-  return result;
-}