@howaboua/opencode-roadmap-plugin 0.1.6 → 0.1.9

package/dist/src/validators.js

@@ -0,0 +1,135 @@
+export class RoadmapValidator {
+    static validateFeatureNumber(number) {
+        if (!number || typeof number !== "string") {
+            return {
+                code: "INVALID_FEATURE_NUMBER",
+                message: "Invalid feature ID: must be a string.",
+            };
+        }
+        if (!/^\d+$/.test(number)) {
+            return {
+                code: "INVALID_FEATURE_NUMBER_FORMAT",
+                message: "Invalid feature ID format: must be a simple number.",
+            };
+        }
+        return null;
+    }
+    static validateActionNumber(number) {
+        if (!number || typeof number !== "string") {
+            return {
+                code: "INVALID_ACTION_NUMBER",
+                message: "Invalid action ID: must be a string.",
+            };
+        }
+        if (!/^\d+\.\d{2}$/.test(number)) {
+            return {
+                code: "INVALID_ACTION_NUMBER_FORMAT",
+                message: "Invalid action ID format: must be X.YY (e.g., 1.01).",
+            };
+        }
+        return null;
+    }
+    static validateActionSequence(actions, globalSeenNumbers, featureNumber) {
+        const errors = [];
+        const seenNumbers = new Set();
+        for (const action of actions) {
+            const numberError = this.validateActionNumber(action.number);
+            if (numberError) {
+                errors.push(numberError);
+                continue;
+            }
+            if (featureNumber) {
+                const actionFeaturePrefix = action.number.split(".")[0];
+                if (actionFeaturePrefix !== featureNumber) {
+                    errors.push({
+                        code: "ACTION_FEATURE_MISMATCH",
+                        message: `Action "${action.number}" does not belong to feature "${featureNumber}".`,
+                    });
+                }
+            }
+            if (seenNumbers.has(action.number)) {
+                errors.push({
+                    code: "DUPLICATE_ACTION_NUMBER",
+                    message: `Duplicate action ID "${action.number}".`,
+                });
+            }
+            if (globalSeenNumbers?.has(action.number)) {
+                errors.push({
+                    code: "DUPLICATE_ACTION_NUMBER_GLOBAL",
+                    message: `Duplicate action ID "${action.number}" (exists in another feature).`,
+                });
+            }
+            seenNumbers.add(action.number);
+            globalSeenNumbers?.add(action.number);
+        }
+        return errors;
+    }
+    static validateFeatureSequence(features) {
+        const errors = [];
+        const seenNumbers = new Set();
+        const seenActionNumbers = new Set();
+        for (const feature of features) {
+            const numberError = this.validateFeatureNumber(feature.number);
+            if (numberError) {
+                errors.push(numberError);
+                continue;
+            }
+            if (seenNumbers.has(feature.number)) {
+                errors.push({
+                    code: "DUPLICATE_FEATURE_NUMBER",
+                    message: `Duplicate feature ID "${feature.number}".`,
+                });
+            }
+            seenNumbers.add(feature.number);
+            const actionErrors = this.validateActionSequence(feature.actions, seenActionNumbers, feature.number);
+            errors.push(...actionErrors);
+        }
+        return errors;
+    }
+    static validateTitle(title, fieldType) {
+        if (!title || typeof title !== "string") {
+            return {
+                code: "INVALID_TITLE",
+                message: `Invalid ${fieldType} title. Must be non-empty string.`,
+            };
+        }
+        if (title.trim() === "") {
+            return {
+                code: "EMPTY_TITLE",
+                message: `${fieldType.charAt(0).toUpperCase() + fieldType.slice(1)} title cannot be empty.`,
+            };
+        }
+        return null;
+    }
+    static validateDescription(description, fieldType) {
+        if (!description || typeof description !== "string") {
+            return {
+                code: "INVALID_DESCRIPTION",
+                message: `Invalid ${fieldType} description. Must be non-empty string.`,
+            };
+        }
+        if (description.trim() === "") {
+            return {
+                code: "EMPTY_DESCRIPTION",
+                message: `${fieldType.charAt(0).toUpperCase() + fieldType.slice(1)} description cannot be empty.`,
+            };
+        }
+        return null;
+    }
+    static validateStatusProgression(currentStatus, newStatus) {
+        const validStatuses = ["pending", "in_progress", "completed", "cancelled"];
+        if (!validStatuses.includes(newStatus)) {
+            return {
+                code: "INVALID_STATUS",
+                message: `Invalid status "${newStatus}". Valid: ${validStatuses.join(", ")}`,
+            };
+        }
+        if (currentStatus === "cancelled") {
+            return {
+                code: "INVALID_STATUS_TRANSITION",
+                message: "Cannot change status of cancelled action. Create a new action instead.",
+            };
+        }
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/opencode-roadmap-plugin",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "Strategic roadmap planning and multi-agent coordination for OpenCode",
   "type": "module",
   "main": "./dist/index.js",