gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/dist/resources/extensions/gsd/parallel-eligibility.js

@@ -0,0 +1,182 @@
+/**
+ * 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";
+// ─── File Collection ─────────────────────────────────────────────────────────
+/**
+ * Collect all `filesLikelyTouched` across every slice plan in a milestone.
+ * Returns a deduplicated list of file paths.
+ */
+async function collectTouchedFiles(basePath, milestoneId) {
+    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();
+    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) {
+    const overlaps = [];
+    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) {
+    const milestoneIds = findMilestoneIds(basePath);
+    const state = await deriveState(basePath);
+    const registry = state.registry;
+    // Build a lookup for quick status checks
+    const registryMap = new Map();
+    for (const entry of registry) {
+        registryMap.set(entry.id, entry);
+    }
+    const eligible = [];
+    const ineligible = [];
+    for (const mid of milestoneIds) {
+        const entry = registryMap.get(mid);
+        const title = entry?.title ?? mid;
+        const status = entry?.status ?? "pending";
+        // Rule 1: skip complete and parked milestones
+        if (status === "complete" || status === "parked") {
+            ineligible.push({
+                milestoneId: mid,
+                title,
+                eligible: false,
+                reason: status === "parked" ? "Milestone is parked." : "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();
+    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();
+    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) {
+    const lines = [];
+    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/dist/resources/extensions/gsd/parallel-merge.js

@@ -0,0 +1,121 @@
+/**
+ * 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 { getErrorMessage } from "./error-utils.js";
+// ─── 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, order = "sequential") {
+    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, milestoneId) {
+    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: getErrorMessage(err),
+        };
+    }
+}
+/**
+ * Merge all completed milestones in sequence.
+ * Stops on first conflict and returns results so far.
+ */
+export async function mergeAllCompleted(basePath, workers, order = "sequential") {
+    const mergeOrder = determineMergeOrder(workers, order);
+    const results = [];
+    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) {
+    if (results.length === 0)
+        return "No completed milestones to merge.";
+    const lines = ["# 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");
+}