@howaboua/opencode-roadmap-plugin 0.1.4 → 0.1.5

package/dist/src/descriptions/loader.js

@@ -7,9 +7,10 @@ export async function loadDescription(filename) {
         return await fs.readFile(filePath, "utf-8");
     }
     catch (error) {
-        if (error.code === "ENOENT") {
+        const err = error;
+        if (err?.code === "ENOENT") {
             throw new Error(`Description file not found: ${filename}. Looked in: ${filePath}. Please ensure asset files are correctly located.`);
         }
-        throw error;
+        throw err ?? new Error("Unknown error while loading description");
     }
 }

package/dist/src/errors/loader.js

@@ -11,10 +11,11 @@ export async function loadErrorTemplate(filename) {
         return ERROR_CACHE[filename];
     }
     catch (error) {
-        if (error.code === "ENOENT") {
+        const err = error;
+        if (err?.code === "ENOENT") {
             throw new Error(`Error template not found: ${filename} at ${filePath}`);
         }
-        throw error;
+        throw err ?? new Error("Unknown error loading error template");
     }
 }
 export async function getErrorMessage(filename, params = {}) {

package/dist/src/index.js

@@ -1,7 +1,7 @@
 import { createCreateRoadmapTool } from "./tools/createroadmap.js";
 import { createUpdateRoadmapTool } from "./tools/updateroadmap.js";
 import { createReadRoadmapTool } from "./tools/readroadmap.js";
-export const RoadmapPlugin = async ({ project, directory, worktree, $ }) => {
+export const RoadmapPlugin = async ({ directory }) => {
     return {
         tool: {
             createroadmap: await createCreateRoadmapTool(directory),

package/dist/src/storage.d.ts

@@ -1,6 +1,6 @@
 import type { Roadmap, RoadmapStorage, ValidationError } from "./types.js";
 export declare class FileStorage implements RoadmapStorage {
-    private directory;
+    private readonly directory;
     constructor(directory: string);
     exists(): Promise<boolean>;
     read(): Promise<Roadmap | null>;
@@ -8,18 +8,18 @@ export declare class FileStorage implements RoadmapStorage {
     archive(): Promise<string>;
 }
 export declare class RoadmapValidator {
-    static validateFeatureNumber(number: string): Promise<ValidationError | null>;
-    static validateActionNumber(number: string): Promise<ValidationError | null>;
-    static validateActionSequence(actions: Array<{
+    static validateFeatureNumber(number: string): ValidationError | null;
+    static validateActionNumber(number: string): ValidationError | null;
+    static validateActionSequence(actions: {
         number: string;
-    }>, globalSeenNumbers?: Set<string>, featureNumber?: string): Promise<ValidationError[]>;
-    static validateFeatureSequence(features: Array<{
+    }[], globalSeenNumbers?: Set<string>, featureNumber?: string): ValidationError[];
+    static validateFeatureSequence(features: {
         number: string;
-        actions: Array<{
+        actions: {
             number: string;
-        }>;
-    }>): Promise<ValidationError[]>;
-    static validateTitle(title: string, fieldType: "feature" | "action"): Promise<ValidationError | null>;
-    static validateDescription(description: string, fieldType: "feature" | "action"): Promise<ValidationError | null>;
-    static validateStatusProgression(currentStatus: string, newStatus: string): Promise<ValidationError | null>;
+        }[];
+    }[]): ValidationError[];
+    static validateTitle(title: string, fieldType: "feature" | "action"): ValidationError | null;
+    static validateDescription(description: string, fieldType: "feature" | "action"): ValidationError | null;
+    static validateStatusProgression(currentStatus: string, newStatus: string): ValidationError | null;
 }

package/dist/src/storage.js

@@ -1,6 +1,6 @@
 import { promises as fs } from "fs";
 import { join } from "path";
-import { getErrorMessage } from "./errors/loader.js";
+import { Roadmap as RoadmapSchema } from "./types.js";
 const ROADMAP_FILE = "roadmap.json";
 export class FileStorage {
     directory;
@@ -24,13 +24,8 @@ export class FileStorage {
                 return null;
             }
             const parsed = JSON.parse(data);
-            if (!parsed || typeof parsed !== "object") {
-                throw new Error("Invalid roadmap format: not an object");
-            }
-            if (!Array.isArray(parsed.features)) {
-                throw new Error("Invalid roadmap format: missing or invalid features array");
-            }
-            return parsed;
+            const validated = RoadmapSchema.parse(parsed);
+            return validated;
         }
         catch (error) {
             if (error instanceof SyntaxError) {
@@ -39,7 +34,10 @@ export class FileStorage {
             if (error instanceof Error && error.message.includes("ENOENT")) {
                 return null;
             }
-            throw error;
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error("Unknown error while reading roadmap");
         }
     }
     async write(roadmap) {
@@ -57,7 +55,10 @@ export class FileStorage {
             catch {
                 // Ignore cleanup errors
             }
-            throw error;
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error("Unknown error while writing roadmap");
         }
     }
     async archive() {
@@ -70,42 +71,41 @@ export class FileStorage {
     }
 }
 export class RoadmapValidator {
-    static async validateFeatureNumber(number) {
+    static validateFeatureNumber(number) {
         if (!number || typeof number !== "string") {
             return {
                 code: "INVALID_FEATURE_NUMBER",
-                message: await getErrorMessage("invalid_feature_id", { id: "undefined" }),
+                message: "Invalid feature ID: must be a string.",
             };
         }
         if (!/^\d+$/.test(number)) {
             return {
                 code: "INVALID_FEATURE_NUMBER_FORMAT",
-                message: await getErrorMessage("invalid_feature_id", { id: number }),
+                message: "Invalid feature ID format: must be a simple number.",
             };
         }
         return null;
     }
-    static async validateActionNumber(number) {
+    static validateActionNumber(number) {
         if (!number || typeof number !== "string") {
             return {
                 code: "INVALID_ACTION_NUMBER",
-                message: await getErrorMessage("invalid_action_id", { id: "undefined" }),
+                message: "Invalid action ID: must be a string.",
             };
         }
         if (!/^\d+\.\d{2}$/.test(number)) {
             return {
                 code: "INVALID_ACTION_NUMBER_FORMAT",
-                message: await getErrorMessage("invalid_action_id", { id: number }),
+                message: "Invalid action ID format: must be X.YY (e.g., 1.01).",
             };
         }
         return null;
     }
-    static async validateActionSequence(actions, globalSeenNumbers, featureNumber) {
+    static validateActionSequence(actions, globalSeenNumbers, featureNumber) {
         const errors = [];
         const seenNumbers = new Set();
-        for (let i = 0; i < actions.length; i++) {
-            const action = actions[i];
-            const numberError = await this.validateActionNumber(action.number);
+        for (const action of actions) {
+            const numberError = this.validateActionNumber(action.number);
             if (numberError) {
                 errors.push(numberError);
                 continue;
@@ -116,7 +116,7 @@ export class RoadmapValidator {
                 if (actionFeaturePrefix !== featureNumber) {
                     errors.push({
                         code: "ACTION_FEATURE_MISMATCH",
-                        message: await getErrorMessage("action_mismatch", { action: action.number, feature: featureNumber }),
+                        message: `Action "${action.number}" does not belong to feature "${featureNumber}".`,
                     });
                 }
             }
@@ -139,13 +139,12 @@ export class RoadmapValidator {
         }
         return errors;
     }
-    static async validateFeatureSequence(features) {
+    static validateFeatureSequence(features) {
         const errors = [];
         const seenNumbers = new Set();
         const seenActionNumbers = new Set();
-        for (let i = 0; i < features.length; i++) {
-            const feature = features[i];
-            const numberError = await this.validateFeatureNumber(feature.number);
+        for (const feature of features) {
+            const numberError = this.validateFeatureNumber(feature.number);
             if (numberError) {
                 errors.push(numberError);
                 continue;
@@ -157,12 +156,12 @@ export class RoadmapValidator {
                 });
             }
             seenNumbers.add(feature.number);
-            const actionErrors = await this.validateActionSequence(feature.actions, seenActionNumbers, feature.number);
+            const actionErrors = this.validateActionSequence(feature.actions, seenActionNumbers, feature.number);
             errors.push(...actionErrors);
         }
         return errors;
     }
-    static async validateTitle(title, fieldType) {
+    static validateTitle(title, fieldType) {
         if (!title || typeof title !== "string") {
             return {
                 code: "INVALID_TITLE",
@@ -177,7 +176,7 @@ export class RoadmapValidator {
         }
         return null;
     }
-    static async validateDescription(description, fieldType) {
+    static validateDescription(description, fieldType) {
         if (!description || typeof description !== "string") {
             return {
                 code: "INVALID_DESCRIPTION",
@@ -192,7 +191,7 @@ export class RoadmapValidator {
         }
         return null;
     }
-    static async validateStatusProgression(currentStatus, newStatus) {
+    static validateStatusProgression(currentStatus, newStatus) {
         const statusFlow = {
             pending: ["in_progress", "completed"],
             in_progress: ["completed"],
@@ -202,11 +201,7 @@ export class RoadmapValidator {
         if (!allowedTransitions.includes(newStatus)) {
             return {
                 code: "INVALID_STATUS_TRANSITION",
-                message: await getErrorMessage("invalid_transition", {
-                    from: currentStatus,
-                    to: newStatus,
-                    allowed: allowedTransitions.length > 0 ? allowedTransitions.join(", ") : "None (terminal state)"
-                }),
+                message: `Invalid transition from "${currentStatus}" to "${newStatus}". Allowed: ${allowedTransitions.length > 0 ? allowedTransitions.join(", ") : "None (terminal state)"}`,
             };
         }
         return null;

package/dist/src/tools/createroadmap.js

@@ -48,20 +48,20 @@ export async function createCreateRoadmapTool(directory) {
                 if (!feature.actions || feature.actions.length === 0) {
                     throw new Error(`Feature "${feature.number}" must have at least one action. Each feature needs at least one action to be valid.`);
                 }
-                const titleError = await RoadmapValidator.validateTitle(feature.title, "feature");
+                const titleError = RoadmapValidator.validateTitle(feature.title, "feature");
                 if (titleError)
                     validationErrors.push(titleError);
-                const descError = await RoadmapValidator.validateDescription(feature.description, "feature");
+                const descError = RoadmapValidator.validateDescription(feature.description, "feature");
                 if (descError)
                     validationErrors.push(descError);
                 for (const action of feature.actions) {
-                    const actionTitleError = await RoadmapValidator.validateTitle(action.description, "action");
+                    const actionTitleError = RoadmapValidator.validateTitle(action.description, "action");
                     if (actionTitleError)
                         validationErrors.push(actionTitleError);
                 }
             }
             // Validate sequence consistency of input (internal consistency)
-            const sequenceErrors = await RoadmapValidator.validateFeatureSequence(args.features);
+            const sequenceErrors = RoadmapValidator.validateFeatureSequence(args.features);
             validationErrors.push(...sequenceErrors);
             if (validationErrors.length > 0) {
                 const errorMessages = validationErrors.map((err) => err.message).join("\n");
@@ -118,7 +118,7 @@ export async function createCreateRoadmapTool(directory) {
             // Final Sort of Features
             roadmap.features.sort((a, b) => parseInt(a.number) - parseInt(b.number));
             // Final Validation of the Merged Roadmap
-            const finalErrors = await RoadmapValidator.validateFeatureSequence(roadmap.features);
+            const finalErrors = RoadmapValidator.validateFeatureSequence(roadmap.features);
             if (finalErrors.length > 0) {
                 throw new Error(`Resulting roadmap would be invalid:\n${finalErrors.map(e => e.message).join("\n")}`);
             }

package/dist/src/tools/readroadmap.js

@@ -1,7 +1,6 @@
 import { tool } from "@opencode-ai/plugin";
 import { FileStorage, RoadmapValidator } from "../storage.js";
 import { loadDescription } from "../descriptions/index.js";
-import { getErrorMessage } from "../errors/loader.js";
 export async function createReadRoadmapTool(directory) {
     const description = await loadDescription("readroadmap.txt");
     return tool({
@@ -19,17 +18,17 @@ export async function createReadRoadmapTool(directory) {
         async execute(args) {
             const storage = new FileStorage(directory);
             if (!(await storage.exists())) {
-                throw new Error(await getErrorMessage("roadmap_not_found"));
+                throw new Error("Roadmap not found. Use CreateRoadmap to create one.");
             }
             const roadmap = await storage.read();
             if (!roadmap) {
-                throw new Error(await getErrorMessage("roadmap_corrupted"));
+                throw new Error("Roadmap file is corrupted. Please fix manually.");
             }
             if (args.actionNumber && args.featureNumber) {
                 throw new Error("Cannot specify both actionNumber and featureNumber. Use one or the other, or neither for full roadmap.");
             }
             if (args.actionNumber) {
-                const actionNumberError = await RoadmapValidator.validateActionNumber(args.actionNumber);
+                const actionNumberError = RoadmapValidator.validateActionNumber(args.actionNumber);
                 if (actionNumberError) {
                     throw new Error(`${actionNumberError.message} Use ReadRoadmap to see valid action numbers.`);
                 }
@@ -46,7 +45,7 @@ export async function createReadRoadmapTool(directory) {
                 throw new Error(`Action "${args.actionNumber}" not found. Use ReadRoadmap with no arguments to see all available actions.`);
             }
             if (args.featureNumber) {
-                const featureNumberError = await RoadmapValidator.validateFeatureNumber(args.featureNumber);
+                const featureNumberError = RoadmapValidator.validateFeatureNumber(args.featureNumber);
                 if (featureNumberError) {
                     throw new Error(`${featureNumberError.message} Use ReadRoadmap to see valid feature numbers.`);
                 }

package/dist/src/tools/updateroadmap.js

@@ -1,7 +1,6 @@
 import { tool } from "@opencode-ai/plugin";
 import { FileStorage, RoadmapValidator } from "../storage.js";
 import { loadDescription } from "../descriptions/index.js";
-import { getErrorMessage } from "../errors/loader.js";
 export async function createUpdateRoadmapTool(directory) {
     const description = await loadDescription("updateroadmap.txt");
     return tool({
@@ -20,13 +19,13 @@ export async function createUpdateRoadmapTool(directory) {
         async execute(args) {
             const storage = new FileStorage(directory);
             if (!(await storage.exists())) {
-                throw new Error(await getErrorMessage("roadmap_not_found"));
+                throw new Error("Roadmap not found. Use CreateRoadmap to create one.");
             }
             const roadmap = await storage.read();
             if (!roadmap) {
-                throw new Error(await getErrorMessage("roadmap_corrupted"));
+                throw new Error("Roadmap file is corrupted. Please fix manually.");
             }
-            const actionNumberError = await RoadmapValidator.validateActionNumber(args.actionNumber);
+            const actionNumberError = RoadmapValidator.validateActionNumber(args.actionNumber);
             if (actionNumberError) {
                 throw new Error(`${actionNumberError.message} Use ReadRoadmap to see valid action numbers.`);
             }
@@ -43,17 +42,21 @@ export async function createUpdateRoadmapTool(directory) {
                 }
             }
             if (!actionFound) {
-                throw new Error(await getErrorMessage("action_not_found", { id: args.actionNumber }));
+                throw new Error(`Action "${args.actionNumber}" not found. Use ReadRoadmap to see valid action numbers.`);
+            }
+            // TypeScript: we know targetAction and targetFeature are not null here
+            if (!targetAction || !targetFeature) {
+                throw new Error("Internal error: target action not found.");
             }
             // Validate that at least one field is being updated
             if (args.description === undefined && args.status === undefined) {
-                throw new Error(await getErrorMessage("no_changes_specified"));
+                throw new Error("No changes specified. Please provide description and/or status.");
             }
             const oldStatus = targetAction.status;
             const oldDescription = targetAction.description;
             // Validate description if provided
             if (args.description !== undefined) {
-                const descError = await RoadmapValidator.validateDescription(args.description, "action");
+                const descError = RoadmapValidator.validateDescription(args.description, "action");
                 if (descError) {
                     throw new Error(`${descError.message}`);
                 }
@@ -61,7 +64,7 @@ export async function createUpdateRoadmapTool(directory) {
             }
             // Validate and update status if provided
             if (args.status !== undefined) {
-                const statusTransitionError = await RoadmapValidator.validateStatusProgression(targetAction.status, args.status);
+                const statusTransitionError = RoadmapValidator.validateStatusProgression(targetAction.status, args.status);
                 if (statusTransitionError) {
                     throw new Error(`${statusTransitionError.message} Current status: "${targetAction.status}", requested: "${args.status}"`);
                 }

package/dist/src/types.d.ts

@@ -129,21 +129,21 @@ export interface ValidationResult {
     errors: ValidationError[];
 }
 export interface CreateRoadmapInput {
-    features: Array<{
+    features: {
         number: string;
         title: string;
         description: string;
-        actions: Array<{
+        actions: {
             number: string;
             description: string;
             status: "pending";
-        }>;
-    }>;
+        }[];
+    }[];
 }
 export interface UpdateRoadmapInput {
     actionNumber: string;
     description?: string;
-    status: ActionStatus;
+    status?: ActionStatus;
 }
 export interface ReadRoadmapInput {
     actionNumber?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/opencode-roadmap-plugin",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Strategic roadmap planning and multi-agent coordination for OpenCode",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,16 +25,20 @@
   "devDependencies": {
     "@opencode-ai/plugin": "^1.0.0",
     "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "zod": "^3.22.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "zod": "^3.22.0"
   },
-
   "scripts": {
     "build": "tsc -p tsconfig.json && npm run copy-assets",
     "copy-assets": "mkdir -p dist/src/descriptions dist/src/errors && cp src/descriptions/*.txt dist/src/descriptions/ && cp src/errors/*.txt dist/src/errors/",
+    "lint": "eslint . --ext .ts",
     "prepublishOnly": "npm run build"
   },
   "opencode": {