gsd-pi 2.23.0 → 2.24.0

package/src/resources/extensions/gsd/parallel-eligibility.ts

@@ -0,0 +1,233 @@
+/**
+ * GSD Parallel Eligibility — Milestone parallelism analysis.
+ *
+ * Analyzes which milestones can safely run in parallel by checking
+ * dependency satisfaction and file overlap across slice plans.
+ */
+
+import { deriveState } from "./state.js";
+import { parseRoadmap, parsePlan, loadFile } from "./files.js";
+import { resolveMilestoneFile, resolveSliceFile } from "./paths.js";
+import { findMilestoneIds } from "./guided-flow.js";
+import type { MilestoneRegistryEntry } from "./types.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface EligibilityResult {
+  milestoneId: string;
+  title: string;
+  eligible: boolean;
+  reason: string;
+}
+
+export interface ParallelCandidates {
+  eligible: EligibilityResult[];
+  ineligible: EligibilityResult[];
+  fileOverlaps: Array<{ mid1: string; mid2: string; files: string[] }>;
+}
+
+// ─── File Collection ─────────────────────────────────────────────────────────
+
+/**
+ * Collect all `filesLikelyTouched` across every slice plan in a milestone.
+ * Returns a deduplicated list of file paths.
+ */
+async function collectTouchedFiles(
+  basePath: string,
+  milestoneId: string,
+): Promise<string[]> {
+  const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+  if (!roadmapPath) return [];
+
+  const roadmapContent = await loadFile(roadmapPath);
+  if (!roadmapContent) return [];
+
+  const roadmap = parseRoadmap(roadmapContent);
+  const files = new Set<string>();
+
+  for (const slice of roadmap.slices) {
+    const planPath = resolveSliceFile(basePath, milestoneId, slice.id, "PLAN");
+    if (!planPath) continue;
+
+    const planContent = await loadFile(planPath);
+    if (!planContent) continue;
+
+    const plan = parsePlan(planContent);
+    for (const f of plan.filesLikelyTouched) {
+      files.add(f);
+    }
+  }
+
+  return [...files];
+}
+
+// ─── Overlap Detection ──────────────────────────────────────────────────────
+
+/**
+ * Compare file sets across milestones and return pairs with overlapping files.
+ */
+function detectFileOverlaps(
+  fileSets: Map<string, string[]>,
+): Array<{ mid1: string; mid2: string; files: string[] }> {
+  const overlaps: Array<{ mid1: string; mid2: string; files: string[] }> = [];
+  const ids = [...fileSets.keys()];
+
+  for (let i = 0; i < ids.length; i++) {
+    const files1 = new Set(fileSets.get(ids[i])!);
+    for (let j = i + 1; j < ids.length; j++) {
+      const files2 = fileSets.get(ids[j])!;
+      const shared = files2.filter(f => files1.has(f));
+      if (shared.length > 0) {
+        overlaps.push({ mid1: ids[i], mid2: ids[j], files: shared.sort() });
+      }
+    }
+  }
+
+  return overlaps;
+}
+
+// ─── Analysis ────────────────────────────────────────────────────────────────
+
+/**
+ * Analyze milestones for parallel execution eligibility.
+ *
+ * A milestone is eligible if:
+ * 1. It is not complete
+ * 2. Its dependencies (`dependsOn`) are all complete
+ * 3. It does not have file overlap with other eligible milestones
+ *    (overlaps are flagged as warnings but do not disqualify)
+ */
+export async function analyzeParallelEligibility(
+  basePath: string,
+): Promise<ParallelCandidates> {
+  const milestoneIds = findMilestoneIds(basePath);
+  const state = await deriveState(basePath);
+  const registry = state.registry;
+
+  // Build a lookup for quick status checks
+  const registryMap = new Map<string, MilestoneRegistryEntry>();
+  for (const entry of registry) {
+    registryMap.set(entry.id, entry);
+  }
+
+  const eligible: EligibilityResult[] = [];
+  const ineligible: EligibilityResult[] = [];
+
+  for (const mid of milestoneIds) {
+    const entry = registryMap.get(mid);
+    const title = entry?.title ?? mid;
+    const status = entry?.status ?? "pending";
+
+    // Rule 1: skip complete milestones
+    if (status === "complete") {
+      ineligible.push({
+        milestoneId: mid,
+        title,
+        eligible: false,
+        reason: "Already complete.",
+      });
+      continue;
+    }
+
+    // Rule 2: check dependency satisfaction
+    const deps = entry?.dependsOn ?? [];
+    const unsatisfied = deps.filter(dep => {
+      const depEntry = registryMap.get(dep);
+      return !depEntry || depEntry.status !== "complete";
+    });
+
+    if (unsatisfied.length > 0) {
+      ineligible.push({
+        milestoneId: mid,
+        title,
+        eligible: false,
+        reason: `Blocked by incomplete dependencies: ${unsatisfied.join(", ")}.`,
+      });
+      continue;
+    }
+
+    eligible.push({
+      milestoneId: mid,
+      title,
+      eligible: true,
+      reason: "All dependencies satisfied.",
+    });
+  }
+
+  // Rule 3: check file overlap among eligible milestones
+  const fileSets = new Map<string, string[]>();
+  for (const result of eligible) {
+    const files = await collectTouchedFiles(basePath, result.milestoneId);
+    fileSets.set(result.milestoneId, files);
+  }
+
+  const fileOverlaps = detectFileOverlaps(fileSets);
+
+  // Annotate eligible milestones that have file overlaps
+  const overlappingIds = new Set<string>();
+  for (const overlap of fileOverlaps) {
+    overlappingIds.add(overlap.mid1);
+    overlappingIds.add(overlap.mid2);
+  }
+
+  for (const result of eligible) {
+    if (overlappingIds.has(result.milestoneId)) {
+      result.reason = "All dependencies satisfied. WARNING: has file overlap with another eligible milestone.";
+    }
+  }
+
+  return { eligible, ineligible, fileOverlaps };
+}
+
+// ─── Formatting ──────────────────────────────────────────────────────────────
+
+/**
+ * Produce a human-readable report of parallel eligibility analysis.
+ */
+export function formatEligibilityReport(candidates: ParallelCandidates): string {
+  const lines: string[] = [];
+
+  lines.push("# Parallel Eligibility Report");
+  lines.push("");
+
+  // Eligible milestones
+  lines.push(`## Eligible for Parallel Execution (${candidates.eligible.length})`);
+  lines.push("");
+  if (candidates.eligible.length === 0) {
+    lines.push("No milestones are currently eligible for parallel execution.");
+  } else {
+    for (const e of candidates.eligible) {
+      lines.push(`- **${e.milestoneId}** — ${e.title}`);
+      lines.push(`  ${e.reason}`);
+    }
+  }
+  lines.push("");
+
+  // Ineligible milestones
+  lines.push(`## Ineligible (${candidates.ineligible.length})`);
+  lines.push("");
+  if (candidates.ineligible.length === 0) {
+    lines.push("All milestones are eligible.");
+  } else {
+    for (const e of candidates.ineligible) {
+      lines.push(`- **${e.milestoneId}** — ${e.title}`);
+      lines.push(`  ${e.reason}`);
+    }
+  }
+  lines.push("");
+
+  // File overlap warnings
+  if (candidates.fileOverlaps.length > 0) {
+    lines.push(`## File Overlap Warnings (${candidates.fileOverlaps.length})`);
+    lines.push("");
+    for (const overlap of candidates.fileOverlaps) {
+      lines.push(`- **${overlap.mid1}** <-> **${overlap.mid2}** — ${overlap.files.length} shared file(s):`);
+      for (const f of overlap.files) {
+        lines.push(`  - \`${f}\``);
+      }
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}

package/src/resources/extensions/gsd/parallel-merge.ts

@@ -0,0 +1,156 @@
+/**
+ * GSD Parallel Merge — Worktree reconciliation for parallel milestones.
+ *
+ * Handles merging completed milestone worktrees back to main branch
+ * with safety checks for parallel execution context.
+ */
+
+import { loadFile } from "./files.js";
+import { resolveMilestoneFile } from "./paths.js";
+import { mergeMilestoneToMain } from "./auto-worktree.js";
+import { MergeConflictError } from "./git-service.js";
+import { removeSessionStatus } from "./session-status-io.js";
+import type { WorkerInfo } from "./parallel-orchestrator.js";
+
+// ─── Types ─────────────────────────────────────────────────────────────────
+
+export interface MergeResult {
+  milestoneId: string;
+  success: boolean;
+  commitMessage?: string;
+  pushed?: boolean;
+  error?: string;
+  conflictFiles?: string[];
+}
+
+export type MergeOrder = "sequential" | "by-completion";
+
+// ─── Merge Queue ───────────────────────────────────────────────────────────
+
+/**
+ * Determine safe merge order for completed milestones.
+ * Sequential: merge in milestone ID order (M001 before M002).
+ * By-completion: merge in the order milestones finished.
+ */
+export function determineMergeOrder(
+  workers: WorkerInfo[],
+  order: MergeOrder = "sequential",
+): string[] {
+  const completed = workers.filter(w => w.state === "stopped" && w.completedUnits > 0);
+  if (order === "by-completion") {
+    return completed
+      .sort((a, b) => a.startedAt - b.startedAt) // earliest first
+      .map(w => w.milestoneId);
+  }
+  return completed
+    .sort((a, b) => a.milestoneId.localeCompare(b.milestoneId))
+    .map(w => w.milestoneId);
+}
+
+/**
+ * Attempt to merge a single milestone's worktree back to main.
+ * Wraps mergeMilestoneToMain with error handling for parallel context.
+ */
+export async function mergeCompletedMilestone(
+  basePath: string,
+  milestoneId: string,
+): Promise<MergeResult> {
+  try {
+    // Load the roadmap content (needed by mergeMilestoneToMain)
+    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    if (!roadmapPath) {
+      return {
+        milestoneId,
+        success: false,
+        error: `No roadmap found for ${milestoneId}`,
+      };
+    }
+
+    const roadmapContent = await loadFile(roadmapPath);
+    if (!roadmapContent) {
+      return {
+        milestoneId,
+        success: false,
+        error: `Could not read roadmap for ${milestoneId}`,
+      };
+    }
+
+    // Attempt the merge
+    const result = mergeMilestoneToMain(basePath, milestoneId, roadmapContent);
+
+    // Clean up parallel session status
+    removeSessionStatus(basePath, milestoneId);
+
+    return {
+      milestoneId,
+      success: true,
+      commitMessage: result.commitMessage,
+      pushed: result.pushed,
+    };
+  } catch (err) {
+    if (err instanceof MergeConflictError) {
+      return {
+        milestoneId,
+        success: false,
+        error: `Merge conflict: ${err.conflictedFiles.length} conflicting file(s)`,
+        conflictFiles: err.conflictedFiles,
+      };
+    }
+    return {
+      milestoneId,
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/**
+ * Merge all completed milestones in sequence.
+ * Stops on first conflict and returns results so far.
+ */
+export async function mergeAllCompleted(
+  basePath: string,
+  workers: WorkerInfo[],
+  order: MergeOrder = "sequential",
+): Promise<MergeResult[]> {
+  const mergeOrder = determineMergeOrder(workers, order);
+  const results: MergeResult[] = [];
+
+  for (const mid of mergeOrder) {
+    const result = await mergeCompletedMilestone(basePath, mid);
+    results.push(result);
+
+    // Stop on first conflict — later merges may depend on this one
+    if (!result.success && result.conflictFiles) {
+      break;
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Format merge results for display.
+ */
+export function formatMergeResults(results: MergeResult[]): string {
+  if (results.length === 0) return "No completed milestones to merge.";
+
+  const lines: string[] = ["# Merge Results\n"];
+
+  for (const r of results) {
+    if (r.success) {
+      const pushStatus = r.pushed ? " (pushed)" : "";
+      lines.push(`- **${r.milestoneId}** — merged successfully${pushStatus}`);
+    } else if (r.conflictFiles) {
+      lines.push(`- **${r.milestoneId}** — CONFLICT (${r.conflictFiles.length} file(s)):`);
+      for (const f of r.conflictFiles) {
+        lines.push(`  - \`${f}\``);
+      }
+      lines.push(`  Resolve conflicts manually and run \`/gsd parallel merge ${r.milestoneId}\` to retry.`);
+    } else {
+      lines.push(`- **${r.milestoneId}** — failed: ${r.error}`);
+    }
+  }
+
+  return lines.join("\n");
+}