@howaboua/opencode-roadmap-plugin 0.1.4 → 0.1.6

package/dist/tools/createroadmap.js

@@ -1,135 +0,0 @@
-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 createCreateRoadmapTool(directory) {
-    const description = await loadDescription("createroadmap.txt");
-    return tool({
-        description,
-        args: {
-            features: tool.schema
-                .array(tool.schema.object({
-                number: tool.schema.string().describe('Feature number as string ("1", "2", "3...")'),
-                title: tool.schema.string().describe("Feature title"),
-                description: tool.schema.string().describe("Brief description of what this feature accomplishes"),
-                actions: tool.schema
-                    .array(tool.schema.object({
-                    number: tool.schema
-                        .string()
-                        .describe('Action number as string with two decimals ("1.01", "1.02", etc.)'),
-                    description: tool.schema.string().describe("Action description"),
-                    status: tool.schema.enum(["pending"]).describe('Initial action status (must be "pending")'),
-                }))
-                    .describe("List of actions for this feature in order"),
-            }))
-                .describe("Array of features for roadmap"),
-        },
-        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.`);
-                }
-                const titleError = await RoadmapValidator.validateTitle(feature.title, "feature");
-                if (titleError)
-                    validationErrors.push(titleError);
-                const descError = await RoadmapValidator.validateDescription(feature.description, "feature");
-                if (descError)
-                    validationErrors.push(descError);
-                for (const action of feature.actions) {
-                    const actionTitleError = await RoadmapValidator.validateTitle(action.description, "action");
-                    if (actionTitleError)
-                        validationErrors.push(actionTitleError);
-                }
-            }
-            // Validate sequence consistency of input (internal consistency)
-            const sequenceErrors = await 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,
-                            });
-                            // 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,
-                        })),
-                    });
-                }
-            }
-            // 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);
-            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;
-        },
-    });
-}

package/dist/tools/readroadmap.d.ts

@@ -1,2 +0,0 @@
-import { type ToolDefinition } from "@opencode-ai/plugin";
-export declare function createReadRoadmapTool(directory: string): Promise<ToolDefinition>;

package/dist/tools/readroadmap.js

@@ -1,90 +0,0 @@
-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({
-        description,
-        args: {
-            actionNumber: tool.schema
-                .string()
-                .optional()
-                .describe('Specific action to read ("1.01", "1.02", etc.). If not provided, reads entire roadmap.'),
-            featureNumber: tool.schema
-                .string()
-                .optional()
-                .describe('Specific feature to read ("1", "2", etc.). Use only if not providing actionNumber.'),
-        },
-        async execute(args) {
-            const storage = new FileStorage(directory);
-            if (!(await storage.exists())) {
-                throw new Error(await getErrorMessage("roadmap_not_found"));
-            }
-            const roadmap = await storage.read();
-            if (!roadmap) {
-                throw new Error(await getErrorMessage("roadmap_corrupted"));
-            }
-            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);
-                if (actionNumberError) {
-                    throw new Error(`${actionNumberError.message} Use ReadRoadmap to see valid action numbers.`);
-                }
-                for (const feature of roadmap.features) {
-                    const action = feature.actions.find((a) => a.number === args.actionNumber);
-                    if (action) {
-                        return (`Action ${args.actionNumber} from Feature "${feature.title}":\n` +
-                            `Description: ${action.description}\n` +
-                            `Status: ${action.status}\n` +
-                            `Feature: ${feature.number} - ${feature.title}\n` +
-                            `Feature Description: ${feature.description}`);
-                    }
-                }
-                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);
-                if (featureNumberError) {
-                    throw new Error(`${featureNumberError.message} Use ReadRoadmap to see valid feature numbers.`);
-                }
-                const feature = roadmap.features.find((f) => f.number === args.featureNumber);
-                if (!feature) {
-                    throw new Error(`Feature "${args.featureNumber}" not found. Use ReadRoadmap with no arguments to see all available features.`);
-                }
-                const actionList = feature.actions
-                    .map((action) => `  ${action.number}: ${action.description} [${action.status}]`)
-                    .join("\n");
-                const completedCount = feature.actions.filter((a) => a.status === "completed").length;
-                const totalCount = feature.actions.length;
-                return (`Feature ${feature.number}: ${feature.title}\n` +
-                    `Description: ${feature.description}\n` +
-                    `Progress: ${completedCount}/${totalCount} actions completed\n` +
-                    `Actions:\n${actionList}`);
-            }
-            const totalActions = roadmap.features.reduce((sum, feature) => sum + feature.actions.length, 0);
-            const completedActions = roadmap.features.reduce((sum, feature) => sum + feature.actions.filter((a) => a.status === "completed").length, 0);
-            const inProgressActions = roadmap.features.reduce((sum, feature) => sum + feature.actions.filter((a) => a.status === "in_progress").length, 0);
-            const pendingActions = totalActions - completedActions - inProgressActions;
-            let output = `Project Roadmap Overview\n` +
-                `========================\n` +
-                `Features: ${roadmap.features.length}\n` +
-                `Total Actions: ${totalActions}\n` +
-                `Progress: ${completedActions} completed, ${inProgressActions} in progress, ${pendingActions} pending\n\n`;
-            for (const feature of roadmap.features) {
-                const featureCompleted = feature.actions.filter((a) => a.status === "completed").length;
-                const featureTotal = feature.actions.length;
-                output += `Feature ${feature.number}: ${feature.title} (${featureCompleted}/${featureTotal} complete)\n`;
-                output += `  Description: ${feature.description}\n`;
-                for (const action of feature.actions) {
-                    const statusIcon = action.status === "completed" ? "✓" : action.status === "in_progress" ? "→" : "○";
-                    output += `  ${action.number} ${statusIcon} ${action.description} [${action.status}]\n`;
-                }
-                output += "\n";
-            }
-            return output.trim();
-        },
-    });
-}

package/dist/tools/updateroadmap.d.ts

@@ -1,2 +0,0 @@
-import { type ToolDefinition } from "@opencode-ai/plugin";
-export declare function createUpdateRoadmapTool(directory: string): Promise<ToolDefinition>;

package/dist/tools/updateroadmap.js

@@ -1,107 +0,0 @@
-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({
-        description,
-        args: {
-            actionNumber: tool.schema.string().describe('Action number to update ("1.01", "1.02", "2.01", etc.) - required'),
-            description: tool.schema
-                .string()
-                .optional()
-                .describe("New action description (full overwrite). If not provided, only status is updated."),
-            status: tool.schema
-                .enum(["pending", "in_progress", "completed"])
-                .optional()
-                .describe("New action status - optional if only updating description"),
-        },
-        async execute(args) {
-            const storage = new FileStorage(directory);
-            if (!(await storage.exists())) {
-                throw new Error(await getErrorMessage("roadmap_not_found"));
-            }
-            const roadmap = await storage.read();
-            if (!roadmap) {
-                throw new Error(await getErrorMessage("roadmap_corrupted"));
-            }
-            const actionNumberError = await 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;
-                }
-            }
-            if (!actionFound) {
-                throw new Error(await getErrorMessage("action_not_found", { id: args.actionNumber }));
-            }
-            // Validate that at least one field is being updated
-            if (args.description === undefined && args.status === undefined) {
-                throw new Error(await getErrorMessage("no_changes_specified"));
-            }
-            const oldStatus = targetAction.status;
-            const oldDescription = targetAction.description;
-            // Validate description if provided
-            if (args.description !== undefined) {
-                const descError = await RoadmapValidator.validateDescription(args.description, "action");
-                if (descError) {
-                    throw new Error(`${descError.message}`);
-                }
-                targetAction.description = args.description;
-            }
-            // Validate and update status if provided
-            if (args.status !== undefined) {
-                const statusTransitionError = await RoadmapValidator.validateStatusProgression(targetAction.status, args.status);
-                if (statusTransitionError) {
-                    throw new Error(`${statusTransitionError.message} Current status: "${targetAction.status}", requested: "${args.status}"`);
-                }
-                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 (!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}`;
-        },
-    });
-}

package/dist/types.d.ts

@@ -1,151 +0,0 @@
-import { z } from "zod";
-export declare const ActionStatus: z.ZodEnum<["pending", "in_progress", "completed"]>;
-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"]>;
-}, "strip", z.ZodTypeAny, {
-    number: string;
-    status: "pending" | "in_progress" | "completed";
-    description: string;
-}, {
-    number: string;
-    status: "pending" | "in_progress" | "completed";
-    description: string;
-}>;
-export type Action = z.infer<typeof Action>;
-export declare const Feature: z.ZodObject<{
-    number: z.ZodString;
-    title: z.ZodString;
-    description: z.ZodString;
-    actions: z.ZodArray<z.ZodObject<{
-        number: z.ZodString;
-        description: z.ZodString;
-        status: z.ZodEnum<["pending", "in_progress", "completed"]>;
-    }, "strip", z.ZodTypeAny, {
-        number: string;
-        status: "pending" | "in_progress" | "completed";
-        description: string;
-    }, {
-        number: string;
-        status: "pending" | "in_progress" | "completed";
-        description: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    number: string;
-    description: string;
-    title: string;
-    actions: {
-        number: string;
-        status: "pending" | "in_progress" | "completed";
-        description: string;
-    }[];
-}, {
-    number: string;
-    description: string;
-    title: string;
-    actions: {
-        number: string;
-        status: "pending" | "in_progress" | "completed";
-        description: string;
-    }[];
-}>;
-export type Feature = z.infer<typeof Feature>;
-export declare const Roadmap: z.ZodObject<{
-    features: z.ZodArray<z.ZodObject<{
-        number: z.ZodString;
-        title: z.ZodString;
-        description: z.ZodString;
-        actions: z.ZodArray<z.ZodObject<{
-            number: z.ZodString;
-            description: z.ZodString;
-            status: z.ZodEnum<["pending", "in_progress", "completed"]>;
-        }, "strip", z.ZodTypeAny, {
-            number: string;
-            status: "pending" | "in_progress" | "completed";
-            description: string;
-        }, {
-            number: string;
-            status: "pending" | "in_progress" | "completed";
-            description: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        number: string;
-        description: string;
-        title: string;
-        actions: {
-            number: string;
-            status: "pending" | "in_progress" | "completed";
-            description: string;
-        }[];
-    }, {
-        number: string;
-        description: string;
-        title: string;
-        actions: {
-            number: string;
-            status: "pending" | "in_progress" | "completed";
-            description: string;
-        }[];
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    features: {
-        number: string;
-        description: string;
-        title: string;
-        actions: {
-            number: string;
-            status: "pending" | "in_progress" | "completed";
-            description: string;
-        }[];
-    }[];
-}, {
-    features: {
-        number: string;
-        description: string;
-        title: string;
-        actions: {
-            number: string;
-            status: "pending" | "in_progress" | "completed";
-            description: string;
-        }[];
-    }[];
-}>;
-export type Roadmap = z.infer<typeof Roadmap>;
-export interface RoadmapStorage {
-    read(): Promise<Roadmap | null>;
-    write(roadmap: Roadmap): Promise<void>;
-    exists(): Promise<boolean>;
-    archive(): Promise<string>;
-}
-export interface ValidationError {
-    code: string;
-    message: string;
-    tutorial?: string;
-}
-export interface ValidationResult {
-    isValid: boolean;
-    errors: ValidationError[];
-}
-export interface CreateRoadmapInput {
-    features: Array<{
-        number: string;
-        title: string;
-        description: string;
-        actions: Array<{
-            number: string;
-            description: string;
-            status: "pending";
-        }>;
-    }>;
-}
-export interface UpdateRoadmapInput {
-    actionNumber: string;
-    description?: string;
-    status: ActionStatus;
-}
-export interface ReadRoadmapInput {
-    actionNumber?: string;
-    featureNumber?: string;
-}

package/dist/types.js

@@ -1,18 +0,0 @@
-import { z } from "zod";
-export const ActionStatus = z.enum(["pending", "in_progress", "completed"]);
-export const Action = z.object({
-    number: z
-        .string()
-        .describe('Action number as string with two decimals ("1.01", "1.02", etc.) - canonical ID, never changes'),
-    description: z.string().describe("Action description - MUTABLE (overwrite only)"),
-    status: ActionStatus.describe("Current status of this action - MUTABLE"),
-});
-export const Feature = z.object({
-    number: z.string().describe('Feature number as string ("1", "2", "3...") - canonical ID, never changes'),
-    title: z.string().describe("Feature title"),
-    description: z.string().describe("Brief description of what this feature accomplishes"),
-    actions: z.array(Action).describe("Array of actions for this feature"),
-});
-export const Roadmap = z.object({
-    features: z.array(Feature).describe("Array of features in the roadmap"),
-});