gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -5,10 +5,11 @@
  * state, no globals — every dependency is passed as a parameter or imported as a
  * utility.
  */
-import { loadFile, parseContinue, parsePlan, parseRoadmap, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
+import { loadFile, parseContinue, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
+import { parseRoadmap } from "./parsers-legacy.js";
 import { getLoadedSkills } from "@gsd/pi-coding-agent";
 import { join, basename } from "node:path";
 import { existsSync } from "node:fs";
@@ -139,17 +140,41 @@ export async function inlineFileSmart(absPath, relPath, label, query, threshold
  * Load and inline dependency slice summaries (full content, not just paths).
  */
 export async function inlineDependencySummaries(mid, sid, base, budgetChars) {
-    const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-    const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-    if (!roadmapContent)
-        return "- (no dependencies)";
-    const roadmap = parseRoadmap(roadmapContent);
-    const sliceEntry = roadmap.slices.find(s => s.id === sid);
-    if (!sliceEntry || sliceEntry.depends.length === 0)
-        return "- (no dependencies)";
+    // DB primary path — get slice depends directly
+    let depends = null;
+    try {
+        const { isDbAvailable, getSlice } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            const slice = getSlice(mid, sid);
+            if (slice) {
+                if (slice.depends.length === 0)
+                    return "- (no dependencies)";
+                depends = slice.depends;
+            }
+            // If slice not found in DB, fall through to file-based parsing
+        }
+    }
+    catch { /* fall through */ }
+    // If DB didn't provide depends, fall back to roadmap parsing
+    if (!depends) {
+        const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+        if (roadmapPath) {
+            const roadmapContent = await loadFile(roadmapPath);
+            if (roadmapContent) {
+                const parsed = parseRoadmap(roadmapContent);
+                const slice = parsed.slices.find(s => s.id === sid);
+                if (slice && slice.depends.length > 0) {
+                    depends = slice.depends;
+                }
+            }
+        }
+        if (!depends) {
+            return "- (no dependencies)";
+        }
+    }
     const sections = [];
     const seen = new Set();
-    for (const dep of sliceEntry.depends) {
+    for (const dep of depends) {
         if (seen.has(dep))
             continue;
         seen.add(dep);
@@ -557,28 +582,52 @@ export async function getDependencyTaskSummaryPaths(mid, sid, currentTid, depend
  * - All slices are complete (milestone done — no point reassessing)
  */
 export async function checkNeedsReassessment(base, mid, state) {
-    const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-    const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
+    // DB primary path — fall through to file-based when DB has no data for this milestone
+    try {
+        const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            const slices = getMilestoneSlices(mid);
+            if (slices.length > 0) {
+                const completedSliceIds = slices.filter(s => s.status === "complete").map(s => s.id);
+                const hasIncomplete = slices.some(s => s.status !== "complete");
+                if (completedSliceIds.length === 0 || !hasIncomplete)
+                    return null;
+                const lastCompleted = completedSliceIds[completedSliceIds.length - 1];
+                const assessmentFile = resolveSliceFile(base, mid, lastCompleted, "ASSESSMENT");
+                const hasAssessment = !!(assessmentFile && await loadFile(assessmentFile));
+                if (hasAssessment)
+                    return null;
+                const summaryFile = resolveSliceFile(base, mid, lastCompleted, "SUMMARY");
+                const hasSummary = !!(summaryFile && await loadFile(summaryFile));
+                if (!hasSummary)
+                    return null;
+                return { sliceId: lastCompleted };
+            }
+        }
+    }
+    catch { /* fall through */ }
+    // File-based fallback using roadmap checkboxes
+    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+    if (!roadmapPath)
+        return null;
+    const roadmapContent = await loadFile(roadmapPath);
     if (!roadmapContent)
         return null;
-    const roadmap = parseRoadmap(roadmapContent);
-    const completedSlices = roadmap.slices.filter(s => s.done);
-    const incompleteSlices = roadmap.slices.filter(s => !s.done);
-    // No completed slices or all slices done — skip
-    if (completedSlices.length === 0 || incompleteSlices.length === 0)
+    const parsed = parseRoadmap(roadmapContent);
+    const fileCompletedIds = parsed.slices.filter(s => s.done).map(s => s.id);
+    const fileHasIncomplete = parsed.slices.some(s => !s.done);
+    if (fileCompletedIds.length === 0 || !fileHasIncomplete)
         return null;
-    // Check the last completed slice
-    const lastCompleted = completedSlices[completedSlices.length - 1];
-    const assessmentFile = resolveSliceFile(base, mid, lastCompleted.id, "ASSESSMENT");
-    const hasAssessment = !!(assessmentFile && await loadFile(assessmentFile));
-    if (hasAssessment)
+    const lastDone = fileCompletedIds[fileCompletedIds.length - 1];
+    const assessFile = resolveSliceFile(base, mid, lastDone, "ASSESSMENT");
+    const hasAssess = !!(assessFile && await loadFile(assessFile));
+    if (hasAssess)
         return null;
-    // Also need a summary to reassess against
-    const summaryFile = resolveSliceFile(base, mid, lastCompleted.id, "SUMMARY");
-    const hasSummary = !!(summaryFile && await loadFile(summaryFile));
-    if (!hasSummary)
+    const summFile = resolveSliceFile(base, mid, lastDone, "SUMMARY");
+    const hasSumm = !!(summFile && await loadFile(summFile));
+    if (!hasSumm)
         return null;
-    return { sliceId: lastCompleted.id };
+    return { sliceId: lastDone };
 }
 /**
  * Check if the most recently completed slice needs a UAT run.
@@ -592,42 +641,70 @@ export async function checkNeedsReassessment(base, mid, state) {
  * - UAT result file already exists (idempotent — already ran)
  */
 export async function checkNeedsRunUat(base, mid, state, prefs) {
-    const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-    const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-    if (!roadmapContent)
+    // DB primary path — fall through to file-based when DB has no data for this milestone
+    try {
+        const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            const slices = getMilestoneSlices(mid);
+            if (slices.length > 0) {
+                const completedSlices = slices.filter(s => s.status === "complete");
+                const incompleteSlices = slices.filter(s => s.status !== "complete");
+                if (completedSlices.length === 0)
+                    return null;
+                if (incompleteSlices.length === 0)
+                    return null;
+                if (!prefs?.uat_dispatch)
+                    return null;
+                const lastCompleted = completedSlices[completedSlices.length - 1];
+                const sid = lastCompleted.id;
+                const uatFile = resolveSliceFile(base, mid, sid, "UAT");
+                if (!uatFile)
+                    return null;
+                const uatContent = await loadFile(uatFile);
+                if (!uatContent)
+                    return null;
+                const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
+                if (uatResultFile) {
+                    const hasResult = !!(await loadFile(uatResultFile));
+                    if (hasResult)
+                        return null;
+                }
+                const uatType = extractUatType(uatContent) ?? "artifact-driven";
+                return { sliceId: sid, uatType };
+            }
+        }
+    }
+    catch { /* fall through */ }
+    // File-based fallback using roadmap checkboxes
+    if (!prefs?.uat_dispatch)
         return null;
-    const roadmap = parseRoadmap(roadmapContent);
-    const completedSlices = roadmap.slices.filter(s => s.done);
-    const incompleteSlices = roadmap.slices.filter(s => !s.done);
-    // No completed slices — nothing to UAT yet
-    if (completedSlices.length === 0)
+    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+    if (!roadmapPath)
         return null;
-    // All slices done — milestone complete path, skip (reassessment handles)
-    if (incompleteSlices.length === 0)
+    const roadmapContent = await loadFile(roadmapPath);
+    if (!roadmapContent)
         return null;
-    // uat_dispatch must be opted in
-    if (!prefs?.uat_dispatch)
+    const parsed = parseRoadmap(roadmapContent);
+    const completedFileSlices = parsed.slices.filter(s => s.done);
+    const incompleteFileSlices = parsed.slices.filter(s => !s.done);
+    if (completedFileSlices.length === 0 || incompleteFileSlices.length === 0)
         return null;
-    // Take the last completed slice
-    const lastCompleted = completedSlices[completedSlices.length - 1];
-    const sid = lastCompleted.id;
-    // UAT file must exist
-    const uatFile = resolveSliceFile(base, mid, sid, "UAT");
-    if (!uatFile)
+    const lastCompletedFile = completedFileSlices[completedFileSlices.length - 1];
+    const uatSid = lastCompletedFile.id;
+    const uatFileFb = resolveSliceFile(base, mid, uatSid, "UAT");
+    if (!uatFileFb)
         return null;
-    const uatContent = await loadFile(uatFile);
-    if (!uatContent)
+    const uatContentFb = await loadFile(uatFileFb);
+    if (!uatContentFb)
         return null;
-    // If UAT result already exists, skip (idempotent)
-    const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
-    if (uatResultFile) {
-        const hasResult = !!(await loadFile(uatResultFile));
-        if (hasResult)
+    const uatResultFb = resolveSliceFile(base, mid, uatSid, "UAT-RESULT");
+    if (uatResultFb) {
+        const hasResultFb = !!(await loadFile(uatResultFb));
+        if (hasResultFb)
             return null;
     }
-    // Classify UAT type; default to artifact-driven (LLM-executed UATs are always artifact-driven)
-    const uatType = extractUatType(uatContent) ?? "artifact-driven";
-    return { sliceId: sid, uatType };
+    const uatTypeFb = extractUatType(uatContentFb) ?? "artifact-driven";
+    return { sliceId: uatSid, uatType: uatTypeFb };
 }
 // ─── Prompt Builders ──────────────────────────────────────────────────────
 /**
@@ -1024,19 +1101,30 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
     // Inline all slice summaries (deduplicated by slice ID)
-    const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-    if (roadmapContent) {
-        const roadmap = parseRoadmap(roadmapContent);
-        const seenSlices = new Set();
-        for (const slice of roadmap.slices) {
-            if (seenSlices.has(slice.id))
-                continue;
-            seenSlices.add(slice.id);
-            const summaryPath = resolveSliceFile(base, mid, slice.id, "SUMMARY");
-            const summaryRel = relSliceFile(base, mid, slice.id, "SUMMARY");
-            inlined.push(await inlineFile(summaryPath, summaryRel, `${slice.id} Summary`));
+    let sliceIds = [];
+    try {
+        const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            sliceIds = getMilestoneSlices(mid).map(s => s.id);
         }
     }
+    catch { /* fall through */ }
+    // File-based fallback: parse roadmap for slice IDs when DB has no data
+    if (sliceIds.length === 0 && roadmapPath) {
+        const roadmapContent = await loadFile(roadmapPath);
+        if (roadmapContent) {
+            sliceIds = parseRoadmap(roadmapContent).slices.map(s => s.id);
+        }
+    }
+    const seenSlices = new Set();
+    for (const sid of sliceIds) {
+        if (seenSlices.has(sid))
+            continue;
+        seenSlices.add(sid);
+        const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
+        const summaryRel = relSliceFile(base, mid, sid, "SUMMARY");
+        inlined.push(await inlineFile(summaryPath, summaryRel, `${sid} Summary`));
+    }
     // Inline root GSD files (skip for minimal — completion can read these if needed)
     if (inlineLevel !== "minimal") {
         const requirementsInline = await inlineRequirementsFromDb(base, undefined, inlineLevel);
@@ -1077,24 +1165,35 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
     // Inline all slice summaries and UAT results
-    const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-    if (roadmapContent) {
-        const roadmap = parseRoadmap(roadmapContent);
-        const seenSlices = new Set();
-        for (const slice of roadmap.slices) {
-            if (seenSlices.has(slice.id))
-                continue;
-            seenSlices.add(slice.id);
-            const summaryPath = resolveSliceFile(base, mid, slice.id, "SUMMARY");
-            const summaryRel = relSliceFile(base, mid, slice.id, "SUMMARY");
-            inlined.push(await inlineFile(summaryPath, summaryRel, `${slice.id} Summary`));
-            const uatPath = resolveSliceFile(base, mid, slice.id, "UAT-RESULT");
-            const uatRel = relSliceFile(base, mid, slice.id, "UAT-RESULT");
-            const uatInline = await inlineFileOptional(uatPath, uatRel, `${slice.id} UAT Result`);
-            if (uatInline)
-                inlined.push(uatInline);
+    let valSliceIds = [];
+    try {
+        const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            valSliceIds = getMilestoneSlices(mid).map(s => s.id);
+        }
+    }
+    catch { /* fall through */ }
+    // File-based fallback: parse roadmap for slice IDs when DB has no data
+    if (valSliceIds.length === 0 && roadmapPath) {
+        const roadmapContent = await loadFile(roadmapPath);
+        if (roadmapContent) {
+            valSliceIds = parseRoadmap(roadmapContent).slices.map(s => s.id);
         }
     }
+    const seenValSlices = new Set();
+    for (const sid of valSliceIds) {
+        if (seenValSlices.has(sid))
+            continue;
+        seenValSlices.add(sid);
+        const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
+        const summaryRel = relSliceFile(base, mid, sid, "SUMMARY");
+        inlined.push(await inlineFile(summaryPath, summaryRel, `${sid} Summary`));
+        const uatPath = resolveSliceFile(base, mid, sid, "UAT-RESULT");
+        const uatRel = relSliceFile(base, mid, sid, "UAT-RESULT");
+        const uatInline = await inlineFileOptional(uatPath, uatRel, `${sid} UAT Result`);
+        if (uatInline)
+            inlined.push(uatInline);
+    }
     // Inline existing VALIDATION file if this is a re-validation round
     const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
     const validationRel = relMilestoneFile(base, mid, "VALIDATION");
@@ -1354,16 +1453,27 @@ export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, o
             docList.push(`- Slice plan: \`${slicePlanRel}\``);
             const tDir = resolveTasksDir(base, mid, sid);
             if (tDir) {
-                const planContent = await loadFile(slicePlanPath);
-                if (planContent) {
-                    const plan = parsePlan(planContent);
-                    for (const task of plan.tasks) {
-                        if (!task.done) {
-                            const taskPlanPath = resolveTaskFile(base, mid, sid, task.id, "PLAN");
-                            if (taskPlanPath) {
-                                const taskRelPath = `${relSlicePath(base, mid, sid)}/tasks/${task.id}-PLAN.md`;
-                                docList.push(`- Task plan: \`${taskRelPath}\``);
-                            }
+                // DB primary path — get incomplete tasks
+                let incompleteTasks = null;
+                try {
+                    const { isDbAvailable, getSliceTasks } = await import("./gsd-db.js");
+                    if (isDbAvailable()) {
+                        incompleteTasks = getSliceTasks(mid, sid)
+                            .filter(t => t.status !== "complete" && t.status !== "done")
+                            .map(t => ({ id: t.id }));
+                    }
+                }
+                catch { /* fall through */ }
+                if (!incompleteTasks) {
+                    // DB unavailable — no task data to inline
+                    incompleteTasks = [];
+                }
+                if (incompleteTasks) {
+                    for (const task of incompleteTasks) {
+                        const taskPlanPath = resolveTaskFile(base, mid, sid, task.id, "PLAN");
+                        if (taskPlanPath) {
+                            const taskRelPath = `${relSlicePath(base, mid, sid)}/tasks/${task.id}-PLAN.md`;
+                            docList.push(`- Task plan: \`${taskRelPath}\``);
                         }
                     }
                 }