@howaboua/opencode-roadmap-plugin 0.1.5 → 0.1.7

package/dist/src/tools/createroadmap.js

@@ -1,3 +1,7 @@
+/**
+ * Tool for creating and appending to project roadmaps.
+ * Supports merge logic for adding new features/actions to existing roadmaps.
+ */
 import { tool } from "@opencode-ai/plugin";
 import { FileStorage, RoadmapValidator } from "../storage.js";
 import { loadDescription } from "../descriptions/index.js";
@@ -26,110 +30,110 @@ export async function createCreateRoadmapTool(directory) {
         },
         async execute(args) {
             const storage = new FileStorage(directory);
-            let roadmap;
-            let isUpdate = false;
-            if (await storage.exists()) {
-                const existing = await storage.read();
-                if (!existing) {
-                    throw new Error("Existing roadmap file is corrupted. Please fix manually.");
-                }
-                roadmap = existing;
-                isUpdate = true;
-            }
-            else {
-                roadmap = { features: [] };
-            }
             if (!args.features || args.features.length === 0) {
                 throw new Error('Roadmap must have at least one feature with at least one action. Example: {"features": [{"number": "1", "title": "Feature 1", "description": "Description", "actions": [{"number": "1.01", "description": "Action 1", "status": "pending"}]}]}');
             }
-            const validationErrors = [];
-            // First pass: structural validation of input
-            for (const feature of args.features) {
-                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.`);
+            return await storage.update(async (current) => {
+                const roadmap = current ?? { features: [] };
+                const isUpdate = current !== null;
+                const validationErrors = [];
+                // First pass: structural validation of input
+                for (const feature of args.features) {
+                    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 = RoadmapValidator.validateTitle(feature.title, "feature");
+                    if (titleError)
+                        validationErrors.push(titleError);
+                    const descError = RoadmapValidator.validateDescription(feature.description, "feature");
+                    if (descError)
+                        validationErrors.push(descError);
+                    for (const action of feature.actions) {
+                        const actionTitleError = RoadmapValidator.validateTitle(action.description, "action");
+                        if (actionTitleError)
+                            validationErrors.push(actionTitleError);
+                    }
                 }
-                const titleError = RoadmapValidator.validateTitle(feature.title, "feature");
-                if (titleError)
-                    validationErrors.push(titleError);
-                const descError = RoadmapValidator.validateDescription(feature.description, "feature");
-                if (descError)
-                    validationErrors.push(descError);
-                for (const action of feature.actions) {
-                    const actionTitleError = RoadmapValidator.validateTitle(action.description, "action");
-                    if (actionTitleError)
-                        validationErrors.push(actionTitleError);
+                // Validate sequence consistency of input (internal consistency)
+                const sequenceErrors = RoadmapValidator.validateFeatureSequence(args.features);
+                validationErrors.push(...sequenceErrors);
+                if (validationErrors.length > 0) {
+                    const errorMessages = validationErrors.map((err) => err.message).join("\n");
+                    throw new Error(`Validation errors:\n${errorMessages}\n\nPlease fix these issues and try again.`);
                 }
-            }
-            // Validate sequence consistency of input (internal consistency)
-            const sequenceErrors = RoadmapValidator.validateFeatureSequence(args.features);
-            validationErrors.push(...sequenceErrors);
-            if (validationErrors.length > 0) {
-                const errorMessages = validationErrors.map((err) => err.message).join("\n");
-                throw new Error(`Validation errors:\n${errorMessages}\n\nPlease fix these issues and try again.`);
-            }
-            // Merge Logic
-            for (const inputFeature of args.features) {
-                const existingFeature = roadmap.features.find((f) => f.number === inputFeature.number);
-                if (existingFeature) {
-                    // Feature exists: Validate Immutability
-                    if (existingFeature.title !== inputFeature.title || existingFeature.description !== inputFeature.description) {
-                        const msg = await getErrorMessage("immutable_feature", {
-                            id: inputFeature.number,
-                            oldTitle: existingFeature.title,
-                            oldDesc: existingFeature.description,
-                            newTitle: inputFeature.title,
-                            newDesc: inputFeature.description
-                        });
-                        throw new Error(msg);
-                    }
-                    // Process Actions
-                    for (const inputAction of inputFeature.actions) {
-                        const existingAction = existingFeature.actions.find((a) => a.number === inputAction.number);
-                        if (existingAction) {
-                            // Action exists: skip (immutable)
-                            continue;
-                        }
-                        else {
-                            // New Action: Append
-                            existingFeature.actions.push({
-                                number: inputAction.number,
-                                description: inputAction.description,
-                                status: inputAction.status,
+                // Merge Logic
+                for (const inputFeature of args.features) {
+                    const existingFeature = roadmap.features.find((f) => f.number === inputFeature.number);
+                    if (existingFeature) {
+                        // Feature exists: Validate Immutability
+                        if (existingFeature.title !== inputFeature.title ||
+                            existingFeature.description !== inputFeature.description) {
+                            const msg = await getErrorMessage("immutable_feature", {
+                                id: inputFeature.number,
+                                oldTitle: existingFeature.title,
+                                oldDesc: existingFeature.description,
+                                newTitle: inputFeature.title,
+                                newDesc: inputFeature.description,
                             });
-                            // Sort actions to ensure order
-                            existingFeature.actions.sort((a, b) => parseFloat(a.number) - parseFloat(b.number));
+                            throw new Error(msg);
+                        }
+                        // Process Actions
+                        for (const inputAction of inputFeature.actions) {
+                            const existingAction = existingFeature.actions.find((a) => a.number === inputAction.number);
+                            if (existingAction) {
+                                // Action exists: skip (immutable)
+                                continue;
+                            }
+                            else {
+                                // New Action: Append
+                                existingFeature.actions.push({
+                                    number: inputAction.number,
+                                    description: inputAction.description,
+                                    status: inputAction.status,
+                                });
+                                // Sort actions to ensure order
+                                existingFeature.actions.sort((a, b) => parseFloat(a.number) - parseFloat(b.number));
+                            }
                         }
                     }
+                    else {
+                        // New Feature: Append
+                        roadmap.features.push({
+                            number: inputFeature.number,
+                            title: inputFeature.title,
+                            description: inputFeature.description,
+                            actions: inputFeature.actions.map((a) => ({
+                                number: a.number,
+                                description: a.description,
+                                status: a.status,
+                            })),
+                        });
+                    }
                 }
-                else {
-                    // New Feature: Append
-                    roadmap.features.push({
-                        number: inputFeature.number,
-                        title: inputFeature.title,
-                        description: inputFeature.description,
-                        actions: inputFeature.actions.map((a) => ({
-                            number: a.number,
-                            description: a.description,
-                            status: a.status,
-                        })),
-                    });
+                // Final Sort of Features
+                roadmap.features.sort((a, b) => parseInt(a.number) - parseInt(b.number));
+                // Safety check: ensure no feature ended up with zero actions after merge
+                for (const feature of roadmap.features) {
+                    if (feature.actions.length === 0) {
+                        throw new Error(`Feature "${feature.number}" has no actions. This indicates a merge error.`);
+                    }
                 }
-            }
-            // Final Sort of Features
-            roadmap.features.sort((a, b) => parseInt(a.number) - parseInt(b.number));
-            // Final Validation of the Merged Roadmap
-            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")}`);
-            }
-            await storage.write(roadmap);
-            const totalActions = roadmap.features.reduce((sum, feature) => sum + feature.actions.length, 0);
-            const action = isUpdate ? "Updated" : "Created";
-            const summary = `${action} roadmap with ${roadmap.features.length} features and ${totalActions} actions:\n` +
-                roadmap.features
-                    .map((feature) => `  Feature ${feature.number}: ${feature.title} (${feature.actions.length} actions)`)
-                    .join("\n");
-            return summary;
+                // Final Validation of the Merged Roadmap
+                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")}`);
+                }
+                const totalActions = roadmap.features.reduce((sum, feature) => sum + feature.actions.length, 0);
+                const action = isUpdate ? "Updated" : "Created";
+                const summary = `${action} roadmap with ${roadmap.features.length} features and ${totalActions} actions:\n` +
+                    roadmap.features
+                        .map((feature) => `  Feature ${feature.number}: ${feature.title} (${feature.actions.length} actions)`)
+                        .join("\n");
+                return {
+                    roadmap,
+                    buildResult: () => summary,
+                };
+            });
         },
     });
 }

package/dist/src/tools/readroadmap.d.ts

@@ -1,2 +1,6 @@
+/**
+ * Tool for reading roadmap state, progress, and details.
+ * Supports filtering by feature or action number.
+ */
 import { type ToolDefinition } from "@opencode-ai/plugin";
 export declare function createReadRoadmapTool(directory: string): Promise<ToolDefinition>;

package/dist/src/tools/readroadmap.js

@@ -1,3 +1,7 @@
+/**
+ * Tool for reading roadmap state, progress, and details.
+ * Supports filtering by feature or action number.
+ */
 import { tool } from "@opencode-ai/plugin";
 import { FileStorage, RoadmapValidator } from "../storage.js";
 import { loadDescription } from "../descriptions/index.js";

package/dist/src/tools/updateroadmap.d.ts

@@ -1,2 +1,6 @@
+/**
+ * Tool for updating action status and descriptions in a roadmap.
+ * Enforces forward-only status progression and archives when complete.
+ */
 import { type ToolDefinition } from "@opencode-ai/plugin";
 export declare function createUpdateRoadmapTool(directory: string): Promise<ToolDefinition>;

package/dist/src/tools/updateroadmap.js

@@ -1,3 +1,7 @@
+/**
+ * Tool for updating action status and descriptions in a roadmap.
+ * Enforces forward-only status progression and archives when complete.
+ */
 import { tool } from "@opencode-ai/plugin";
 import { FileStorage, RoadmapValidator } from "../storage.js";
 import { loadDescription } from "../descriptions/index.js";
@@ -12,99 +16,103 @@ export async function createUpdateRoadmapTool(directory) {
                 .optional()
                 .describe("New action description (full overwrite). If not provided, only status is updated."),
             status: tool.schema
-                .enum(["pending", "in_progress", "completed"])
+                .enum(["pending", "in_progress", "completed", "cancelled"])
                 .optional()
-                .describe("New action status - optional if only updating description"),
+                .describe("New action status. Flexible transitions allowed except from cancelled."),
         },
         async execute(args) {
             const storage = new FileStorage(directory);
-            if (!(await storage.exists())) {
-                throw new Error("Roadmap not found. Use CreateRoadmap to create one.");
-            }
-            const roadmap = await storage.read();
-            if (!roadmap) {
-                throw new Error("Roadmap file is corrupted. Please fix manually.");
-            }
             const actionNumberError = RoadmapValidator.validateActionNumber(args.actionNumber);
             if (actionNumberError) {
                 throw new Error(`${actionNumberError.message} Use ReadRoadmap to see valid action numbers.`);
             }
-            let targetAction = null;
-            let targetFeature = null;
-            let actionFound = false;
-            for (const feature of roadmap.features) {
-                const action = feature.actions.find((a) => a.number === args.actionNumber);
-                if (action) {
-                    targetAction = action;
-                    targetFeature = feature;
-                    actionFound = true;
-                    break;
+            return await storage.update((roadmap) => {
+                if (!roadmap) {
+                    throw new Error("Roadmap not found. Use CreateRoadmap to create one.");
                 }
-            }
-            if (!actionFound) {
-                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("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 = RoadmapValidator.validateDescription(args.description, "action");
-                if (descError) {
-                    throw new Error(`${descError.message}`);
+                let targetAction = null;
+                let targetFeature = null;
+                let actionFound = false;
+                for (const feature of roadmap.features) {
+                    const action = feature.actions.find((a) => a.number === args.actionNumber);
+                    if (action) {
+                        targetAction = action;
+                        targetFeature = feature;
+                        actionFound = true;
+                        break;
+                    }
                 }
-                targetAction.description = args.description;
-            }
-            // Validate and update status if provided
-            if (args.status !== undefined) {
-                const statusTransitionError = RoadmapValidator.validateStatusProgression(targetAction.status, args.status);
-                if (statusTransitionError) {
-                    throw new Error(`${statusTransitionError.message} Current status: "${targetAction.status}", requested: "${args.status}"`);
+                if (!actionFound) {
+                    throw new Error(`Action "${args.actionNumber}" not found. Use ReadRoadmap to see valid action numbers.`);
                 }
-                targetAction.status = args.status;
-            }
-            await storage.write(roadmap);
-            const changes = [];
-            if (args.description !== undefined && oldDescription !== args.description) {
-                changes.push(`description updated`);
-            }
-            if (args.status !== undefined && oldStatus !== args.status) {
-                changes.push(`status: "${oldStatus}" → "${args.status}"`);
-            }
-            // Check if all actions are completed
-            let allCompleted = true;
-            for (const feature of roadmap.features) {
-                for (const action of feature.actions) {
-                    if (action.status !== "completed") {
-                        allCompleted = false;
-                        break;
+                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("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 = RoadmapValidator.validateDescription(args.description, "action");
+                    if (descError) {
+                        throw new Error(`${descError.message}`);
                     }
+                    targetAction.description = args.description;
                 }
-                if (!allCompleted)
-                    break;
-            }
-            let archiveMsg = "";
-            if (allCompleted) {
-                const archiveName = await storage.archive();
-                archiveMsg = `\n\n🎉 All actions completed! Roadmap archived to "${archiveName}".`;
-            }
-            // Format feature context
-            const featureCompleted = targetFeature.actions.filter((a) => a.status === "completed").length;
-            const featureTotal = targetFeature.actions.length;
-            let featureContext = `\n\nFeature ${targetFeature.number}: ${targetFeature.title} (${featureCompleted}/${featureTotal} complete)\n`;
-            featureContext += `Description: ${targetFeature.description}\n`;
-            for (const action of targetFeature.actions) {
-                const statusIcon = action.status === "completed" ? "✓" : action.status === "in_progress" ? "→" : "○";
-                featureContext += `${action.number} ${statusIcon} ${action.description} [${action.status}]\n`;
-            }
-            return `Updated action ${args.actionNumber} in feature "${targetFeature.title}": ${changes.join(", ")}${featureContext}${archiveMsg}`;
+                // Validate and update status if provided
+                if (args.status !== undefined) {
+                    const statusTransitionError = RoadmapValidator.validateStatusProgression(targetAction.status, args.status);
+                    if (statusTransitionError) {
+                        throw new Error(`${statusTransitionError.message} Current status: "${targetAction.status}", requested: "${args.status}"`);
+                    }
+                    targetAction.status = args.status;
+                }
+                const changes = [];
+                if (args.description !== undefined && oldDescription !== args.description) {
+                    changes.push("description updated");
+                }
+                if (args.status !== undefined && oldStatus !== args.status) {
+                    changes.push(`status: "${oldStatus}" → "${args.status}"`);
+                }
+                if (changes.length === 0) {
+                    return {
+                        roadmap,
+                        buildResult: () => `Action ${args.actionNumber} unchanged. Provided values match current state.`,
+                    };
+                }
+                // Check if all actions are completed
+                let allCompleted = true;
+                for (const feature of roadmap.features) {
+                    for (const action of feature.actions) {
+                        if (action.status !== "completed") {
+                            allCompleted = false;
+                            break;
+                        }
+                    }
+                    if (!allCompleted)
+                        break;
+                }
+                // Format feature context
+                const featureCompleted = targetFeature.actions.filter((a) => a.status === "completed").length;
+                const featureTotal = targetFeature.actions.length;
+                let featureContext = `\n\nFeature ${targetFeature.number}: ${targetFeature.title} (${featureCompleted}/${featureTotal} complete)\n`;
+                featureContext += `Description: ${targetFeature.description}\n`;
+                for (const action of targetFeature.actions) {
+                    const statusIcon = action.status === "completed" ? "✓" : action.status === "in_progress" ? "→" : "○";
+                    featureContext += `${action.number} ${statusIcon} ${action.description} [${action.status}]\n`;
+                }
+                return {
+                    roadmap,
+                    archive: allCompleted,
+                    buildResult: (archiveName) => {
+                        const archiveMsg = archiveName ? `\n\nAll actions completed! Roadmap archived to "${archiveName}".` : "";
+                        return `Updated action ${args.actionNumber} in feature "${targetFeature.title}": ${changes.join(", ")}${featureContext}${archiveMsg}`;
+                    },
+                };
+            });
         },
     });
 }

package/dist/src/types.d.ts

@@ -1,17 +1,17 @@
 import { z } from "zod";
-export declare const ActionStatus: z.ZodEnum<["pending", "in_progress", "completed"]>;
+export declare const ActionStatus: z.ZodEnum<["pending", "in_progress", "completed", "cancelled"]>;
 export type ActionStatus = z.infer<typeof ActionStatus>;
 export declare const Action: z.ZodObject<{
     number: z.ZodString;
     description: z.ZodString;
-    status: z.ZodEnum<["pending", "in_progress", "completed"]>;
+    status: z.ZodEnum<["pending", "in_progress", "completed", "cancelled"]>;
 }, "strip", z.ZodTypeAny, {
     number: string;
-    status: "pending" | "in_progress" | "completed";
+    status: "pending" | "in_progress" | "completed" | "cancelled";
     description: string;
 }, {
     number: string;
-    status: "pending" | "in_progress" | "completed";
+    status: "pending" | "in_progress" | "completed" | "cancelled";
     description: string;
 }>;
 export type Action = z.infer<typeof Action>;
@@ -22,14 +22,14 @@ export declare const Feature: z.ZodObject<{
     actions: z.ZodArray<z.ZodObject<{
         number: z.ZodString;
         description: z.ZodString;
-        status: z.ZodEnum<["pending", "in_progress", "completed"]>;
+        status: z.ZodEnum<["pending", "in_progress", "completed", "cancelled"]>;
     }, "strip", z.ZodTypeAny, {
         number: string;
-        status: "pending" | "in_progress" | "completed";
+        status: "pending" | "in_progress" | "completed" | "cancelled";
         description: string;
     }, {
         number: string;
-        status: "pending" | "in_progress" | "completed";
+        status: "pending" | "in_progress" | "completed" | "cancelled";
         description: string;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
@@ -38,7 +38,7 @@ export declare const Feature: z.ZodObject<{
     title: string;
     actions: {
         number: string;
-        status: "pending" | "in_progress" | "completed";
+        status: "pending" | "in_progress" | "completed" | "cancelled";
         description: string;
     }[];
 }, {
@@ -47,7 +47,7 @@ export declare const Feature: z.ZodObject<{
     title: string;
     actions: {
         number: string;
-        status: "pending" | "in_progress" | "completed";
+        status: "pending" | "in_progress" | "completed" | "cancelled";
         description: string;
     }[];
 }>;
@@ -60,14 +60,14 @@ export declare const Roadmap: z.ZodObject<{
         actions: z.ZodArray<z.ZodObject<{
             number: z.ZodString;
             description: z.ZodString;
-            status: z.ZodEnum<["pending", "in_progress", "completed"]>;
+            status: z.ZodEnum<["pending", "in_progress", "completed", "cancelled"]>;
         }, "strip", z.ZodTypeAny, {
             number: string;
-            status: "pending" | "in_progress" | "completed";
+            status: "pending" | "in_progress" | "completed" | "cancelled";
             description: string;
         }, {
             number: string;
-            status: "pending" | "in_progress" | "completed";
+            status: "pending" | "in_progress" | "completed" | "cancelled";
             description: string;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
@@ -76,7 +76,7 @@ export declare const Roadmap: z.ZodObject<{
         title: string;
         actions: {
             number: string;
-            status: "pending" | "in_progress" | "completed";
+            status: "pending" | "in_progress" | "completed" | "cancelled";
             description: string;
         }[];
     }, {
@@ -85,7 +85,7 @@ export declare const Roadmap: z.ZodObject<{
         title: string;
         actions: {
             number: string;
-            status: "pending" | "in_progress" | "completed";
+            status: "pending" | "in_progress" | "completed" | "cancelled";
             description: string;
         }[];
     }>, "many">;
@@ -96,7 +96,7 @@ export declare const Roadmap: z.ZodObject<{
         title: string;
         actions: {
             number: string;
-            status: "pending" | "in_progress" | "completed";
+            status: "pending" | "in_progress" | "completed" | "cancelled";
             description: string;
         }[];
     }[];
@@ -107,7 +107,7 @@ export declare const Roadmap: z.ZodObject<{
         title: string;
         actions: {
             number: string;
-            status: "pending" | "in_progress" | "completed";
+            status: "pending" | "in_progress" | "completed" | "cancelled";
             description: string;
         }[];
     }[];

package/dist/src/types.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export const ActionStatus = z.enum(["pending", "in_progress", "completed"]);
+export const ActionStatus = z.enum(["pending", "in_progress", "completed", "cancelled"]);
 export const Action = z.object({
     number: z
         .string()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/opencode-roadmap-plugin",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Strategic roadmap planning and multi-agent coordination for OpenCode",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,7 +32,6 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "typescript": "^5.0.0",
     "zod": "^3.22.0"
   },
   "scripts": {
@@ -41,6 +40,9 @@
     "lint": "eslint . --ext .ts",
     "prepublishOnly": "npm run build"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "opencode": {
     "type": "plugin",
     "tools": [

package/dist/descriptions/index.d.ts

@@ -1 +0,0 @@
-export { loadDescription } from "./loader";

package/dist/descriptions/index.js

@@ -1 +0,0 @@
-export { loadDescription } from "./loader.js";

package/dist/descriptions/loader.d.ts

@@ -1 +0,0 @@
-export declare function loadDescription(filename: string): Promise<string>;

package/dist/descriptions/loader.js

@@ -1,17 +0,0 @@
-import { promises as fs } from "fs";
-import { join } from "path";
-export async function loadDescription(filename) {
-    // In the compiled output, __dirname is .../dist/descriptions, but the assets are in .../src/descriptions.
-    // This path adjustment ensures the assets are found regardless of the build process.
-    const descriptionsDir = join(__dirname, "..", "..", "src", "descriptions");
-    const filePath = join(descriptionsDir, filename);
-    try {
-        return await fs.readFile(filePath, "utf-8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            throw new Error(`Description file not found: ${filename}. Looked in: ${filePath}. Please ensure asset files are correctly located.`);
-        }
-        throw error;
-    }
-}

package/dist/errors/loader.d.ts

@@ -1,2 +0,0 @@
-export declare function loadErrorTemplate(filename: string): Promise<string>;
-export declare function getErrorMessage(filename: string, params?: Record<string, string>): Promise<string>;

package/dist/errors/loader.js

@@ -1,24 +0,0 @@
-import { promises as fs } from "fs";
-import { join } from "path";
-const ERROR_CACHE = {};
-export async function loadErrorTemplate(filename) {
-    if (ERROR_CACHE[filename])
-        return ERROR_CACHE[filename];
-    const errorsDir = join(__dirname, "..", "..", "src", "errors");
-    const filePath = join(errorsDir, filename + ".txt");
-    try {
-        const content = await fs.readFile(filePath, "utf-8");
-        ERROR_CACHE[filename] = content.trim();
-        return ERROR_CACHE[filename];
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            throw new Error(`Error template not found: ${filename} at ${filePath}`);
-        }
-        throw error;
-    }
-}
-export async function getErrorMessage(filename, params = {}) {
-    const template = await loadErrorTemplate(filename);
-    return template.replace(/\{(\w+)\}/g, (_, key) => params[key] || `{${key}}`);
-}