gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -0,0 +1,205 @@
+import { clearParseCache } from "../files.js";
+import { transaction, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { renderRoadmapFromDb } from "../markdown-renderer.js";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function validateStringArray(value, field) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${field} must be an array`);
+    }
+    if (value.some((item) => !isNonEmptyString(item))) {
+        throw new Error(`${field} must contain only non-empty strings`);
+    }
+    return value;
+}
+function validateRiskEntries(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("keyRisks must be an array");
+    }
+    return value.map((entry, index) => {
+        if (!entry || typeof entry !== "object") {
+            throw new Error(`keyRisks[${index}] must be an object`);
+        }
+        const risk = entry.risk;
+        const whyItMatters = entry.whyItMatters;
+        if (!isNonEmptyString(risk) || !isNonEmptyString(whyItMatters)) {
+            throw new Error(`keyRisks[${index}] must include non-empty risk and whyItMatters`);
+        }
+        return { risk, whyItMatters };
+    });
+}
+function validateProofStrategy(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("proofStrategy must be an array");
+    }
+    return value.map((entry, index) => {
+        if (!entry || typeof entry !== "object") {
+            throw new Error(`proofStrategy[${index}] must be an object`);
+        }
+        const riskOrUnknown = entry.riskOrUnknown;
+        const retireIn = entry.retireIn;
+        const whatWillBeProven = entry.whatWillBeProven;
+        if (!isNonEmptyString(riskOrUnknown) || !isNonEmptyString(retireIn) || !isNonEmptyString(whatWillBeProven)) {
+            throw new Error(`proofStrategy[${index}] must include non-empty riskOrUnknown, retireIn, and whatWillBeProven`);
+        }
+        return { riskOrUnknown, retireIn, whatWillBeProven };
+    });
+}
+function validateSlices(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error("slices must be a non-empty array");
+    }
+    const seen = new Set();
+    return value.map((entry, index) => {
+        if (!entry || typeof entry !== "object") {
+            throw new Error(`slices[${index}] must be an object`);
+        }
+        const obj = entry;
+        const sliceId = obj.sliceId;
+        const title = obj.title;
+        const risk = obj.risk;
+        const depends = obj.depends;
+        const demo = obj.demo;
+        const goal = obj.goal;
+        const successCriteria = obj.successCriteria;
+        const proofLevel = obj.proofLevel;
+        const integrationClosure = obj.integrationClosure;
+        const observabilityImpact = obj.observabilityImpact;
+        if (!isNonEmptyString(sliceId))
+            throw new Error(`slices[${index}].sliceId must be a non-empty string`);
+        if (seen.has(sliceId))
+            throw new Error(`slices[${index}].sliceId must be unique`);
+        seen.add(sliceId);
+        if (!isNonEmptyString(title))
+            throw new Error(`slices[${index}].title must be a non-empty string`);
+        if (!isNonEmptyString(risk))
+            throw new Error(`slices[${index}].risk must be a non-empty string`);
+        if (!Array.isArray(depends) || depends.some((item) => !isNonEmptyString(item))) {
+            throw new Error(`slices[${index}].depends must be an array of non-empty strings`);
+        }
+        if (!isNonEmptyString(demo))
+            throw new Error(`slices[${index}].demo must be a non-empty string`);
+        if (!isNonEmptyString(goal))
+            throw new Error(`slices[${index}].goal must be a non-empty string`);
+        if (!isNonEmptyString(successCriteria))
+            throw new Error(`slices[${index}].successCriteria must be a non-empty string`);
+        if (!isNonEmptyString(proofLevel))
+            throw new Error(`slices[${index}].proofLevel must be a non-empty string`);
+        if (!isNonEmptyString(integrationClosure))
+            throw new Error(`slices[${index}].integrationClosure must be a non-empty string`);
+        if (!isNonEmptyString(observabilityImpact))
+            throw new Error(`slices[${index}].observabilityImpact must be a non-empty string`);
+        return {
+            sliceId,
+            title,
+            risk,
+            depends,
+            demo,
+            goal,
+            successCriteria,
+            proofLevel,
+            integrationClosure,
+            observabilityImpact,
+        };
+    });
+}
+function validateParams(params) {
+    if (!isNonEmptyString(params?.milestoneId))
+        throw new Error("milestoneId is required");
+    if (!isNonEmptyString(params?.title))
+        throw new Error("title is required");
+    if (!isNonEmptyString(params?.vision))
+        throw new Error("vision is required");
+    if (!isNonEmptyString(params?.verificationContract))
+        throw new Error("verificationContract is required");
+    if (!isNonEmptyString(params?.verificationIntegration))
+        throw new Error("verificationIntegration is required");
+    if (!isNonEmptyString(params?.verificationOperational))
+        throw new Error("verificationOperational is required");
+    if (!isNonEmptyString(params?.verificationUat))
+        throw new Error("verificationUat is required");
+    if (!isNonEmptyString(params?.requirementCoverage))
+        throw new Error("requirementCoverage is required");
+    if (!isNonEmptyString(params?.boundaryMapMarkdown))
+        throw new Error("boundaryMapMarkdown is required");
+    return {
+        ...params,
+        dependsOn: params.dependsOn ? validateStringArray(params.dependsOn, "dependsOn") : [],
+        successCriteria: validateStringArray(params.successCriteria, "successCriteria"),
+        keyRisks: validateRiskEntries(params.keyRisks),
+        proofStrategy: validateProofStrategy(params.proofStrategy),
+        definitionOfDone: validateStringArray(params.definitionOfDone, "definitionOfDone"),
+        slices: validateSlices(params.slices),
+    };
+}
+export async function handlePlanMilestone(rawParams, basePath) {
+    let params;
+    try {
+        params = validateParams(rawParams);
+    }
+    catch (err) {
+        return { error: `validation failed: ${err.message}` };
+    }
+    try {
+        transaction(() => {
+            insertMilestone({
+                id: params.milestoneId,
+                title: params.title,
+                status: params.status ?? "active",
+                depends_on: params.dependsOn ?? [],
+            });
+            upsertMilestonePlanning(params.milestoneId, {
+                vision: params.vision,
+                successCriteria: params.successCriteria,
+                keyRisks: params.keyRisks,
+                proofStrategy: params.proofStrategy,
+                verificationContract: params.verificationContract,
+                verificationIntegration: params.verificationIntegration,
+                verificationOperational: params.verificationOperational,
+                verificationUat: params.verificationUat,
+                definitionOfDone: params.definitionOfDone,
+                requirementCoverage: params.requirementCoverage,
+                boundaryMapMarkdown: params.boundaryMapMarkdown,
+            });
+            for (const slice of params.slices) {
+                insertSlice({
+                    id: slice.sliceId,
+                    milestoneId: params.milestoneId,
+                    title: slice.title,
+                    status: "pending",
+                    risk: slice.risk,
+                    depends: slice.depends,
+                    demo: slice.demo,
+                });
+                upsertSlicePlanning(params.milestoneId, slice.sliceId, {
+                    goal: slice.goal,
+                    successCriteria: slice.successCriteria,
+                    proofLevel: slice.proofLevel,
+                    integrationClosure: slice.integrationClosure,
+                    observabilityImpact: slice.observabilityImpact,
+                });
+            }
+        });
+    }
+    catch (err) {
+        return { error: `db write failed: ${err.message}` };
+    }
+    let roadmapPath;
+    try {
+        const renderResult = await renderRoadmapFromDb(basePath, params.milestoneId);
+        roadmapPath = renderResult.roadmapPath;
+    }
+    catch (renderErr) {
+        process.stderr.write(`gsd-db: plan_milestone — render failed (DB rows preserved for debugging): ${renderErr.message}\n`);
+        invalidateStateCache();
+        return { error: `render failed: ${renderErr.message}` };
+    }
+    invalidateStateCache();
+    clearParseCache();
+    return {
+        milestoneId: params.milestoneId,
+        roadmapPath,
+    };
+}

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -0,0 +1,155 @@
+import { clearParseCache } from "../files.js";
+import { transaction, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, } from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { renderPlanFromDb } from "../markdown-renderer.js";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function validateStringArray(value, field) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${field} must be an array`);
+    }
+    if (value.some((item) => !isNonEmptyString(item))) {
+        throw new Error(`${field} must contain only non-empty strings`);
+    }
+    return value;
+}
+function validateTasks(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error("tasks must be a non-empty array");
+    }
+    const seen = new Set();
+    return value.map((entry, index) => {
+        if (!entry || typeof entry !== "object") {
+            throw new Error(`tasks[${index}] must be an object`);
+        }
+        const obj = entry;
+        const taskId = obj.taskId;
+        const title = obj.title;
+        const description = obj.description;
+        const estimate = obj.estimate;
+        const files = obj.files;
+        const verify = obj.verify;
+        const inputs = obj.inputs;
+        const expectedOutput = obj.expectedOutput;
+        const observabilityImpact = obj.observabilityImpact;
+        if (!isNonEmptyString(taskId))
+            throw new Error(`tasks[${index}].taskId must be a non-empty string`);
+        if (seen.has(taskId))
+            throw new Error(`tasks[${index}].taskId must be unique`);
+        seen.add(taskId);
+        if (!isNonEmptyString(title))
+            throw new Error(`tasks[${index}].title must be a non-empty string`);
+        if (!isNonEmptyString(description))
+            throw new Error(`tasks[${index}].description must be a non-empty string`);
+        if (!isNonEmptyString(estimate))
+            throw new Error(`tasks[${index}].estimate must be a non-empty string`);
+        if (!Array.isArray(files) || files.some((item) => !isNonEmptyString(item))) {
+            throw new Error(`tasks[${index}].files must be an array of non-empty strings`);
+        }
+        if (!isNonEmptyString(verify))
+            throw new Error(`tasks[${index}].verify must be a non-empty string`);
+        if (!Array.isArray(inputs) || inputs.some((item) => !isNonEmptyString(item))) {
+            throw new Error(`tasks[${index}].inputs must be an array of non-empty strings`);
+        }
+        if (!Array.isArray(expectedOutput) || expectedOutput.some((item) => !isNonEmptyString(item))) {
+            throw new Error(`tasks[${index}].expectedOutput must be an array of non-empty strings`);
+        }
+        if (observabilityImpact !== undefined && !isNonEmptyString(observabilityImpact)) {
+            throw new Error(`tasks[${index}].observabilityImpact must be a non-empty string when provided`);
+        }
+        return {
+            taskId,
+            title,
+            description,
+            estimate,
+            files,
+            verify,
+            inputs,
+            expectedOutput,
+            observabilityImpact: typeof observabilityImpact === "string" ? observabilityImpact : "",
+        };
+    });
+}
+function validateParams(params) {
+    if (!isNonEmptyString(params?.milestoneId))
+        throw new Error("milestoneId is required");
+    if (!isNonEmptyString(params?.sliceId))
+        throw new Error("sliceId is required");
+    if (!isNonEmptyString(params?.goal))
+        throw new Error("goal is required");
+    if (!isNonEmptyString(params?.successCriteria))
+        throw new Error("successCriteria is required");
+    if (!isNonEmptyString(params?.proofLevel))
+        throw new Error("proofLevel is required");
+    if (!isNonEmptyString(params?.integrationClosure))
+        throw new Error("integrationClosure is required");
+    if (!isNonEmptyString(params?.observabilityImpact))
+        throw new Error("observabilityImpact is required");
+    return {
+        ...params,
+        tasks: validateTasks(params.tasks),
+    };
+}
+export async function handlePlanSlice(rawParams, basePath) {
+    let params;
+    try {
+        params = validateParams(rawParams);
+    }
+    catch (err) {
+        return { error: `validation failed: ${err.message}` };
+    }
+    const parentSlice = getSlice(params.milestoneId, params.sliceId);
+    if (!parentSlice) {
+        return { error: `missing parent slice: ${params.milestoneId}/${params.sliceId}` };
+    }
+    try {
+        transaction(() => {
+            upsertSlicePlanning(params.milestoneId, params.sliceId, {
+                goal: params.goal,
+                successCriteria: params.successCriteria,
+                proofLevel: params.proofLevel,
+                integrationClosure: params.integrationClosure,
+                observabilityImpact: params.observabilityImpact,
+            });
+            for (const task of params.tasks) {
+                insertTask({
+                    id: task.taskId,
+                    sliceId: params.sliceId,
+                    milestoneId: params.milestoneId,
+                    title: task.title,
+                    status: "pending",
+                });
+                upsertTaskPlanning(params.milestoneId, params.sliceId, task.taskId, {
+                    title: task.title,
+                    description: task.description,
+                    estimate: task.estimate,
+                    files: task.files,
+                    verify: task.verify,
+                    inputs: task.inputs,
+                    expectedOutput: task.expectedOutput,
+                    observabilityImpact: task.observabilityImpact ?? "",
+                });
+            }
+        });
+    }
+    catch (err) {
+        return { error: `db write failed: ${err.message}` };
+    }
+    try {
+        const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+        invalidateStateCache();
+        clearParseCache();
+        return {
+            milestoneId: params.milestoneId,
+            sliceId: params.sliceId,
+            planPath: renderResult.planPath,
+            taskPlanPaths: renderResult.taskPlanPaths,
+        };
+    }
+    catch (renderErr) {
+        process.stderr.write(`gsd-db: plan_slice — render failed (DB rows preserved for debugging): ${renderErr.message}\n`);
+        invalidateStateCache();
+        return { error: `render failed: ${renderErr.message}` };
+    }
+}

package/dist/resources/extensions/gsd/tools/plan-task.js

@@ -0,0 +1,94 @@
+import { clearParseCache } from "../files.js";
+import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning } from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { renderTaskPlanFromDb } from "../markdown-renderer.js";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function validateStringArray(value, field) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${field} must be an array`);
+    }
+    if (value.some((item) => !isNonEmptyString(item))) {
+        throw new Error(`${field} must contain only non-empty strings`);
+    }
+    return value;
+}
+function validateParams(params) {
+    if (!isNonEmptyString(params?.milestoneId))
+        throw new Error("milestoneId is required");
+    if (!isNonEmptyString(params?.sliceId))
+        throw new Error("sliceId is required");
+    if (!isNonEmptyString(params?.taskId))
+        throw new Error("taskId is required");
+    if (!isNonEmptyString(params?.title))
+        throw new Error("title is required");
+    if (!isNonEmptyString(params?.description))
+        throw new Error("description is required");
+    if (!isNonEmptyString(params?.estimate))
+        throw new Error("estimate is required");
+    if (!isNonEmptyString(params?.verify))
+        throw new Error("verify is required");
+    if (params.observabilityImpact !== undefined && !isNonEmptyString(params.observabilityImpact)) {
+        throw new Error("observabilityImpact must be a non-empty string when provided");
+    }
+    return {
+        ...params,
+        files: validateStringArray(params.files, "files"),
+        inputs: validateStringArray(params.inputs, "inputs"),
+        expectedOutput: validateStringArray(params.expectedOutput, "expectedOutput"),
+    };
+}
+export async function handlePlanTask(rawParams, basePath) {
+    let params;
+    try {
+        params = validateParams(rawParams);
+    }
+    catch (err) {
+        return { error: `validation failed: ${err.message}` };
+    }
+    const parentSlice = getSlice(params.milestoneId, params.sliceId);
+    if (!parentSlice) {
+        return { error: `missing parent slice: ${params.milestoneId}/${params.sliceId}` };
+    }
+    try {
+        transaction(() => {
+            if (!getTask(params.milestoneId, params.sliceId, params.taskId)) {
+                insertTask({
+                    id: params.taskId,
+                    sliceId: params.sliceId,
+                    milestoneId: params.milestoneId,
+                    title: params.title,
+                    status: "pending",
+                });
+            }
+            upsertTaskPlanning(params.milestoneId, params.sliceId, params.taskId, {
+                title: params.title,
+                description: params.description,
+                estimate: params.estimate,
+                files: params.files,
+                verify: params.verify,
+                inputs: params.inputs,
+                expectedOutput: params.expectedOutput,
+                observabilityImpact: params.observabilityImpact ?? "",
+            });
+        });
+    }
+    catch (err) {
+        return { error: `db write failed: ${err.message}` };
+    }
+    try {
+        const renderResult = await renderTaskPlanFromDb(basePath, params.milestoneId, params.sliceId, params.taskId);
+        invalidateStateCache();
+        clearParseCache();
+        return {
+            milestoneId: params.milestoneId,
+            sliceId: params.sliceId,
+            taskId: params.taskId,
+            taskPlanPath: renderResult.taskPlanPath,
+        };
+    }
+    catch (err) {
+        return { error: `render failed: ${err.message}` };
+    }
+}

package/dist/resources/extensions/gsd/tools/reassess-roadmap.js

@@ -0,0 +1,152 @@
+import { clearParseCache } from "../files.js";
+import { transaction, getMilestone, getMilestoneSlices, insertSlice, updateSliceFields, insertAssessment, deleteSlice, } from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
+import { join } from "node:path";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function validateParams(params) {
+    if (!isNonEmptyString(params?.milestoneId))
+        throw new Error("milestoneId is required");
+    if (!isNonEmptyString(params?.completedSliceId))
+        throw new Error("completedSliceId is required");
+    if (!isNonEmptyString(params?.verdict))
+        throw new Error("verdict is required");
+    if (!isNonEmptyString(params?.assessment))
+        throw new Error("assessment is required");
+    if (!params.sliceChanges || typeof params.sliceChanges !== "object") {
+        throw new Error("sliceChanges must be an object");
+    }
+    if (!Array.isArray(params.sliceChanges.modified)) {
+        throw new Error("sliceChanges.modified must be an array");
+    }
+    if (!Array.isArray(params.sliceChanges.added)) {
+        throw new Error("sliceChanges.added must be an array");
+    }
+    if (!Array.isArray(params.sliceChanges.removed)) {
+        throw new Error("sliceChanges.removed must be an array");
+    }
+    // Validate each modified slice
+    for (let i = 0; i < params.sliceChanges.modified.length; i++) {
+        const s = params.sliceChanges.modified[i];
+        if (!s || typeof s !== "object")
+            throw new Error(`sliceChanges.modified[${i}] must be an object`);
+        if (!isNonEmptyString(s.sliceId))
+            throw new Error(`sliceChanges.modified[${i}].sliceId is required`);
+        if (!isNonEmptyString(s.title))
+            throw new Error(`sliceChanges.modified[${i}].title is required`);
+    }
+    // Validate each added slice
+    for (let i = 0; i < params.sliceChanges.added.length; i++) {
+        const s = params.sliceChanges.added[i];
+        if (!s || typeof s !== "object")
+            throw new Error(`sliceChanges.added[${i}] must be an object`);
+        if (!isNonEmptyString(s.sliceId))
+            throw new Error(`sliceChanges.added[${i}].sliceId is required`);
+        if (!isNonEmptyString(s.title))
+            throw new Error(`sliceChanges.added[${i}].title is required`);
+    }
+    return params;
+}
+export async function handleReassessRoadmap(rawParams, basePath) {
+    // ── Validate ──────────────────────────────────────────────────────
+    let params;
+    try {
+        params = validateParams(rawParams);
+    }
+    catch (err) {
+        return { error: `validation failed: ${err.message}` };
+    }
+    // ── Verify milestone exists ───────────────────────────────────────
+    const milestone = getMilestone(params.milestoneId);
+    if (!milestone) {
+        return { error: `milestone not found: ${params.milestoneId}` };
+    }
+    // ── Structural enforcement ────────────────────────────────────────
+    const existingSlices = getMilestoneSlices(params.milestoneId);
+    const completedSliceIds = new Set();
+    for (const slice of existingSlices) {
+        if (slice.status === "complete" || slice.status === "done") {
+            completedSliceIds.add(slice.id);
+        }
+    }
+    // Reject modifications to completed slices
+    for (const modifiedSlice of params.sliceChanges.modified) {
+        if (completedSliceIds.has(modifiedSlice.sliceId)) {
+            return { error: `cannot modify completed slice ${modifiedSlice.sliceId}` };
+        }
+    }
+    // Reject removal of completed slices
+    for (const removedId of params.sliceChanges.removed) {
+        if (completedSliceIds.has(removedId)) {
+            return { error: `cannot remove completed slice ${removedId}` };
+        }
+    }
+    // ── Compute assessment artifact path ──────────────────────────────
+    // Assessment lives in the completed slice's directory
+    const assessmentRelPath = join(".gsd", "milestones", params.milestoneId, "slices", params.completedSliceId, `${params.completedSliceId}-ASSESSMENT.md`);
+    // ── Transaction: DB mutations ─────────────────────────────────────
+    try {
+        transaction(() => {
+            // Record assessment
+            insertAssessment({
+                path: assessmentRelPath,
+                milestoneId: params.milestoneId,
+                sliceId: params.completedSliceId,
+                status: params.verdict,
+                scope: "roadmap",
+                fullContent: params.assessment,
+            });
+            // Apply slice modifications
+            for (const mod of params.sliceChanges.modified) {
+                updateSliceFields(params.milestoneId, mod.sliceId, {
+                    title: mod.title,
+                    risk: mod.risk,
+                    depends: mod.depends,
+                    demo: mod.demo,
+                });
+            }
+            // Insert new slices
+            for (const added of params.sliceChanges.added) {
+                insertSlice({
+                    id: added.sliceId,
+                    milestoneId: params.milestoneId,
+                    title: added.title,
+                    status: "pending",
+                    risk: added.risk,
+                    depends: added.depends,
+                    demo: added.demo ?? "",
+                });
+            }
+            // Delete removed slices
+            for (const removedId of params.sliceChanges.removed) {
+                deleteSlice(params.milestoneId, removedId);
+            }
+        });
+    }
+    catch (err) {
+        return { error: `db write failed: ${err.message}` };
+    }
+    // ── Render artifacts ──────────────────────────────────────────────
+    try {
+        const roadmapResult = await renderRoadmapFromDb(basePath, params.milestoneId);
+        const assessmentResult = await renderAssessmentFromDb(basePath, params.milestoneId, params.completedSliceId, {
+            verdict: params.verdict,
+            assessment: params.assessment,
+            completedSliceId: params.completedSliceId,
+        });
+        // ── Invalidate caches ─────────────────────────────────────────
+        invalidateStateCache();
+        clearParseCache();
+        return {
+            milestoneId: params.milestoneId,
+            completedSliceId: params.completedSliceId,
+            assessmentPath: assessmentResult.assessmentPath,
+            roadmapPath: roadmapResult.roadmapPath,
+        };
+    }
+    catch (err) {
+        return { error: `render failed: ${err.message}` };
+    }
+}