project-roadmap-tracking 0.1.0

package/dist/commands/complete.js

@@ -0,0 +1,35 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { readConfigFile } from '../util/read-config.js';
+import { readRoadmapFile } from '../util/read-roadmap.js';
+import { STATUS } from '../util/types.js';
+import { updateTaskInRoadmap } from '../util/update-task.js';
+import { writeRoadmapFile } from '../util/write-roadmap.js';
+export default class Complete extends Command {
+    static args = {
+        taskID: Args.string({ description: 'ID of the task to complete', required: true }),
+    };
+    static description = 'Mark a task as completed';
+    static examples = ['<%= config.bin %> <%= command.id %> F-001 --tests'];
+    static flags = {
+        // flag with no value (-f, --force)
+        // force: Flags.boolean({char: 'f'}),
+        // flag with a value (-n, --name=VALUE)
+        // name: Flags.string({char: 'n', description: 'name to print'}),
+        tests: Flags.boolean({ char: 't', description: 'mark task as passes-tests' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Complete);
+        const config = await readConfigFile();
+        const roadmap = await readRoadmapFile(config.path);
+        const updatedRoadmap = await updateTaskInRoadmap(roadmap, args.taskID, flags.tests
+            ? {
+                'passes-tests': true,
+                status: STATUS.Completed,
+            }
+            : {
+                status: STATUS.Completed,
+            });
+        await writeRoadmapFile(config.path, updatedRoadmap);
+        this.log(`Task ${args.taskID} marked as completed.`);
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,26 @@
+import { Command } from '@oclif/core';
+import { Config, Roadmap } from '../util/types.js';
+export default class Init extends Command {
+    static args: {
+        folder: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        withSampleTasks: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    buildBlankRoadmap({ description, name, withSampleTasks, }: {
+        description: string;
+        name: string;
+        withSampleTasks: boolean;
+    }): Roadmap;
+    buildConfig({ description, name, path }: {
+        description: string;
+        name: string;
+        path: string;
+    }): Config;
+    run(): Promise<void>;
+}

package/dist/commands/init.js

@@ -0,0 +1,111 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { mkdir, readdir, writeFile } from 'node:fs/promises';
+import { PRIORITY, STATUS, TASK_TYPE } from '../util/types.js';
+export default class Init extends Command {
+    static args = {
+        folder: Args.string({ description: 'folder to initialize the project roadmap in' }),
+    };
+    static description = 'initialize a new project roadmap (prt.json and prt.config.json)';
+    static examples = ['<%= config.bin %> <%= command.id %> [path/to/directory]'];
+    static flags = {
+        // flag with no value (-f, --force)
+        description: Flags.string({ char: 'd', description: 'description to print' }),
+        force: Flags.boolean({ char: 'f', description: 'force initialization even if files already exist' }),
+        // flag with a value (-n, --name=VALUE)
+        name: Flags.string({ char: 'n', description: 'name to print' }),
+        withSampleTasks: Flags.boolean({ description: 'include sample tasks in the initialized roadmap' }),
+    };
+    buildBlankRoadmap({ description, name, withSampleTasks, }) {
+        return {
+            $schema: 'https://raw.githubusercontent.com/ZacharyEggert/project-roadmap-tracking/refs/heads/master/schemas/roadmap/v1.json',
+            metadata: {
+                createdAt: new Date().toISOString(),
+                createdBy: `project-roadmap-tracking CLI`,
+                description: `${description}`,
+                name: `${name}`,
+            },
+            tasks: withSampleTasks
+                ? [
+                    {
+                        assignedTo: null,
+                        blocks: [],
+                        createdAt: new Date().toISOString(),
+                        'depends-on': [],
+                        details: 'This is a sample task to get you started.',
+                        dueDate: null,
+                        id: 'F-001',
+                        'passes-tests': true,
+                        priority: PRIORITY.Medium,
+                        status: STATUS.NotStarted,
+                        tags: ['sample'],
+                        title: 'Sample Task',
+                        type: TASK_TYPE.Feature,
+                        updatedAt: new Date().toISOString(),
+                    },
+                ]
+                : [],
+        };
+    }
+    buildConfig({ description, name, path }) {
+        return {
+            $schema: 'https://raw.githubusercontent.com/ZacharyEggert/project-roadmap-tracking/refs/heads/master/schemas/config/v1.json',
+            metadata: {
+                description: `${description}`,
+                name: `${name}`,
+            },
+            path: `${path}/prt.json`,
+        };
+    }
+    async run() {
+        const { args, flags } = await this.parse(Init);
+        const path = args.folder ?? '.';
+        this.log(`creating project roadmap in${path === '.' ? ' current directory' : ': ' + args.folder}`);
+        const name = flags.name ?? 'My Project Roadmap';
+        const description = flags.description ?? 'A project roadmap managed by Project Roadmap Tracking';
+        // create prt.json and prt.config.json files here
+        const config = this.buildConfig({ description, name, path });
+        const roadmap = this.buildBlankRoadmap({ description, name, withSampleTasks: flags.withSampleTasks ?? false });
+        if (path !== '.') {
+            // check if target directory exists
+            // if it does not, create it
+            await readdir(path).catch(async (error) => {
+                if (error) {
+                    this.log(`target directory does not exist, creating: ${path}`);
+                    try {
+                        // create the directory
+                        await mkdir(path, { recursive: true });
+                    }
+                    catch (error) {
+                        this.error(`failed to create target directory: ${error.message}`);
+                    }
+                }
+            });
+        }
+        // check if config already exists in the target directory
+        // if it does, and --force is not set, throw an error
+        // if it does, and --force is set, overwrite the files
+        await readdir('.')
+            .then(async (files) => {
+            if (!flags.force && (files.includes('prt.json') || files.includes('prt.config.json'))) {
+                this.error('prt.config.json already exist in the current directory. Use --force to overwrite.');
+            }
+            await writeFile(`./.prtrc.json`, JSON.stringify(config, null, 2));
+            this.log('project roadmap config initialized');
+        })
+            .catch((error) => {
+            this.error(`failed to read current directory: ${error.message}`);
+        });
+        // create prt.json and prt.config.json files in specified directory
+        await readdir(path)
+            .then(async (files) => {
+            if (!flags.force && files.includes('prt.json')) {
+                this.error('prt.json already exists in the target directory. Use --force to overwrite.');
+            }
+            await writeFile(`${path}/prt.json`, JSON.stringify(roadmap, null, 2));
+            this.log('project roadmap initialized');
+        })
+            .catch((error) => {
+            this.error(`failed to read directory: ${error.message}`);
+        });
+    }
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,13 @@
+import { /* Args, */ Command } from '@oclif/core';
+export default class List extends Command {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        incomplete: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        priority: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sort: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/list.js

@@ -0,0 +1,101 @@
+import { /* Args, */ Command, Flags } from '@oclif/core';
+import { readConfigFile } from '../util/read-config.js';
+import { readRoadmapFile } from '../util/read-roadmap.js';
+import { STATUS } from '../util/types.js';
+export default class List extends Command {
+    static args = {
+    // file: Args.string({description: 'file to read'}),
+    };
+    static description = 'list tasks in the project roadmap';
+    static examples = ['<%= config.bin %> <%= command.id %> -p=h --incomplete --sort=createdAt'];
+    static flags = {
+        // flag with no value (-f, --force)
+        // force: Flags.boolean({char: 'f'}),
+        // flag with a value (-n, --name=VALUE)
+        // name: Flags.string({char: 'n', description: 'name to print'}),
+        incomplete: Flags.boolean({ char: 'i', description: 'filter tasks to show in-progress and not-started only' }),
+        priority: Flags.string({
+            char: 'p',
+            description: 'filter tasks by priority (high, medium, low)',
+            options: ['high', 'medium', 'low', 'h', 'm', 'l'],
+        }),
+        sort: Flags.string({
+            char: 'o',
+            description: 'sort tasks by field (dueDate, priority, createdAt)',
+            options: ['dueDate', 'priority', 'createdAt'],
+        }),
+        status: Flags.string({
+            char: 's',
+            description: 'filter tasks by status (completed, in-progress, not-started)',
+            options: ['completed', 'in-progress', 'not-started'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(List);
+        const incompleteOnly = flags.incomplete ?? false;
+        const priority = (flags.priority ?? null);
+        const sortBy = (flags.sort ?? null);
+        const statusFilter = (flags.status ?? null);
+        const priorityFilter = (priority
+            ? priority === 'high' || priority === 'h'
+                ? 'high'
+                : priority === 'medium' || priority === 'm'
+                    ? 'medium'
+                    : priority === 'low' || priority === 'l'
+                        ? 'low'
+                        : null
+            : null);
+        // if statusFilter is set, it overrides incompleteOnly
+        const effectiveStatusFilter = statusFilter
+            ? [statusFilter]
+            : incompleteOnly
+                ? ['in-progress', 'not-started']
+                : ['completed', 'in-progress', 'not-started'];
+        const config = await readConfigFile().catch((error) => {
+            this.error(`failed to read config file: ${error ? error.message : String(error)}`);
+        });
+        const roadmapPath = config.path;
+        const roadmap = await readRoadmapFile(roadmapPath);
+        const tasks = roadmap.tasks
+            .filter((task) => effectiveStatusFilter.includes(task.status))
+            .filter((task) => priorityFilter === null || task.priority === priorityFilter)
+            .sort((a, b) => {
+            if (sortBy === 'dueDate') {
+                const dateA = a.dueDate ? new Date(a.dueDate).getTime() : Infinity;
+                const dateB = b.dueDate ? new Date(b.dueDate).getTime() : Infinity;
+                return dateA - dateB;
+            }
+            if (sortBy === 'priority') {
+                const priorityOrder = {
+                    high: 1,
+                    low: 3,
+                    medium: 2,
+                };
+                return priorityOrder[a.priority] - priorityOrder[b.priority];
+            }
+            if (sortBy === 'createdAt') {
+                const createdA = a.createdAt ? new Date(a.createdAt).getTime() : Infinity;
+                const createdB = b.createdAt ? new Date(b.createdAt).getTime() : Infinity;
+                return createdA - createdB;
+            }
+            return 0;
+        });
+        // Display
+        console.log(`\nTasks (${tasks.length} total):\n`);
+        for (const task of tasks) {
+            const status = task.status === STATUS.Completed ? '✓' : task.status === STATUS.InProgress ? '~' : '○';
+            const tests = task['passes-tests'] ? '✓' : '✗';
+            const prioritySymbol = {
+                high: 'H',
+                low: 'L',
+                medium: 'M',
+            }[task.priority];
+            console.log(`${status} [${prioritySymbol}] [${task.id}] ${task.title}`);
+            console.log(`   Type: ${task.type} | Tests: ${tests} | Deps: ${task['depends-on'].length}`);
+            if (task['depends-on'].length > 0) {
+                console.log(`   Depends on: ${task['depends-on'].join(', ')}`);
+            }
+            console.log();
+        }
+    }
+}

package/dist/commands/pass-test.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class PassTest extends Command {
+    static args: {
+        taskID: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<void>;
+}

package/dist/commands/pass-test.js

@@ -0,0 +1,28 @@
+import { Args, Command } from '@oclif/core';
+import { readConfigFile } from '../util/read-config.js';
+import { readRoadmapFile } from '../util/read-roadmap.js';
+import { updateTaskInRoadmap } from '../util/update-task.js';
+import { writeRoadmapFile } from '../util/write-roadmap.js';
+export default class PassTest extends Command {
+    static args = {
+        taskID: Args.string({ description: 'ID of the task to mark as passing tests', required: true }),
+    };
+    static description = 'Mark a task as passes-tests';
+    static examples = ['<%= config.bin %> <%= command.id %> F-001'];
+    static flags = {
+    // flag with no value (-f, --force)
+    // force: Flags.boolean({char: 'f'}),
+    // flag with a value (-n, --name=VALUE)
+    // name: Flags.string({char: 'n', description: 'name to print'}),
+    };
+    async run() {
+        const { args } = await this.parse(PassTest);
+        const config = await readConfigFile();
+        const roadmap = await readRoadmapFile(config.path);
+        const updatedRoadmap = await updateTaskInRoadmap(roadmap, args.taskID, {
+            'passes-tests': true,
+        });
+        await writeRoadmapFile(config.path, updatedRoadmap);
+        this.log(`Task ${args.taskID} marked as passing tests.`);
+    }
+}

package/dist/commands/show.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Show extends Command {
+    static args: {
+        task: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<void>;
+}

package/dist/commands/show.js

@@ -0,0 +1,73 @@
+import { Args, Command /* , Flags */ } from '@oclif/core';
+import { readConfigFile } from '../util/read-config.js';
+import { readRoadmapFile } from '../util/read-roadmap.js';
+export default class Show extends Command {
+    static args = {
+        task: Args.string({ description: 'task ID to show', required: true }),
+    };
+    static description = 'show details of a specific task in the project roadmap';
+    static examples = ['<%= config.bin %> <%= command.id %> F-001'];
+    static flags = {
+    // flag with no value (-f, --force)
+    // force: Flags.boolean({char: 'f'}),
+    // flag with a value (-n, --name=VALUE)
+    // name: Flags.string({char: 'n', description: 'name to print'}),
+    };
+    async run() {
+        const { args } = await this.parse(Show);
+        const config = await readConfigFile().catch((error) => {
+            this.error(`failed to read config file: ${error ? error.message : String(error)}`);
+        });
+        const roadmapPath = config.path;
+        const roadmap = await readRoadmapFile(roadmapPath);
+        const task = roadmap.tasks.find((t) => t.id === args.task);
+        if (!task) {
+            this.error(`task with ID ${args.task} not found in roadmap \n  see list of tasks with: 'prt list'`);
+        }
+        const completeStatus = task.status === 'completed' ? '✓' : task.status === 'in-progress' ? '~' : '○';
+        const testStatus = task['passes-tests'] ? '✓' : '✗';
+        const priorityLabel = {
+            high: 'High',
+            low: 'Low',
+            medium: 'Medium',
+        }[task.priority];
+        console.log(`\nTask: ${task.id}\n`);
+        console.log(`Title: ${task.title}`);
+        console.log(`Type: ${task.type}`);
+        console.log(`Priority: ${priorityLabel}`);
+        console.log(`Status: ${completeStatus} ${task.status
+            .replaceAll('-', ' ')
+            .split(' ')
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ')} | ${testStatus} Tests Passing`);
+        console.log(`\nDetails:\n${task.details}`);
+        // Dependencies
+        if (task['depends-on'].length > 0) {
+            console.log(`\nDepends On: ${task['depends-on'].join(', ')}`);
+        }
+        else {
+            console.log(`\nDepends On: None`);
+        }
+        // Blocks (optional)
+        if (task.blocks && task.blocks.length > 0) {
+            console.log(`Blocks: ${task.blocks.join(', ')}`);
+        }
+        // Timestamps
+        console.log(`\nCreated: ${task.createdAt}`);
+        console.log(`Updated: ${task.updatedAt}`);
+        // Optional fields - only display if present
+        if (task.tags && task.tags.length > 0) {
+            console.log(`\nTags: ${task.tags.join(', ')}`);
+        }
+        if (task.effort !== undefined) {
+            console.log(`Effort: ${task.effort}`);
+        }
+        if (task['github-refs'] && task['github-refs'].length > 0) {
+            console.log(`GitHub Refs: ${task['github-refs'].join(', ')}`);
+        }
+        if (task.notes) {
+            console.log(`\nNotes:\n${task.notes}`);
+        }
+        console.log('');
+    }
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class Update extends Command {
+    static args: {
+        taskID: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'clear-notes': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        deps: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        notes: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        tested: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/update.js

@@ -0,0 +1,78 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { readConfigFile } from '../util/read-config.js';
+import { readRoadmapFile } from '../util/read-roadmap.js';
+import { STATUS } from '../util/types.js';
+import { updateTaskInRoadmap } from '../util/update-task.js';
+import { validateTaskID } from '../util/validate-task-id.js';
+import { writeRoadmapFile } from '../util/write-roadmap.js';
+export default class Update extends Command {
+    static args = {
+        taskID: Args.string({ description: 'ID of the task to update', required: true }),
+    };
+    static description = 'Update a task in place';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> F-001 --status=completed --tested=true --notes="Fixed all bugs"',
+        '<%= config.bin %> <%= command.id %> F-002 --deps="F-001" --clear-notes',
+    ];
+    static flags = {
+        'clear-notes': Flags.boolean({ description: 'clear all notes from the task' }),
+        deps: Flags.string({
+            char: 'd',
+            description: 'update the dependencies of the task (comma-separated list of task IDs)',
+        }),
+        notes: Flags.string({ char: 'n', description: 'append notes to the task' }),
+        status: Flags.string({
+            char: 's',
+            description: 'set the status of the task (completed, in-progress, not-started)',
+            options: [STATUS.Completed, STATUS.InProgress, STATUS.NotStarted],
+        }),
+        tested: Flags.string({
+            char: 't',
+            description: 'update whether the task passes tests',
+            options: ['true', 'false'],
+        }),
+        // flag with no value (-f, --force)
+        // force: Flags.boolean({char: 'f'}),
+        // flag with a value (-n, --name=VALUE)
+        // name: Flags.string({char: 'n', description: 'name to print'}),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Update);
+        const config = await readConfigFile();
+        const roadmap = await readRoadmapFile(config.path);
+        const updateObject = {};
+        if (flags['clear-notes']) {
+            updateObject.notes = '';
+        }
+        if (flags.notes) {
+            let existingNotes = '';
+            if (!flags['clear-notes']) {
+                const existingTask = roadmap.tasks.find((task) => task.id === args.taskID);
+                existingNotes = existingTask?.notes ? existingTask.notes + '\n' : '';
+            }
+            updateObject.notes = existingNotes + flags.notes;
+        }
+        if (flags.status) {
+            updateObject.status = flags.status;
+        }
+        if (flags.tested) {
+            updateObject['passes-tests'] = flags.tested === 'true';
+        }
+        if (flags.deps) {
+            const depsArray = flags.deps.split(',').map((dep) => dep.trim());
+            // checking that each depArray item matches TaskID format
+            for (const dep of depsArray) {
+                try {
+                    validateTaskID(dep);
+                }
+                catch {
+                    this.error(`Invalid task ID in dependencies: ${dep}`);
+                }
+            }
+            updateObject['depends-on'] = depsArray;
+        }
+        const updatedRoadmap = await updateTaskInRoadmap(roadmap, args.taskID, updateObject);
+        await writeRoadmapFile(config.path, updatedRoadmap);
+        this.log(`Task ${args.taskID} updated.`);
+    }
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class Validate extends Command {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<void>;
+}

package/dist/commands/validate.js

@@ -0,0 +1,49 @@
+import { Command } from '@oclif/core';
+import { readFile } from 'node:fs/promises';
+import { readConfigFile } from '../util/read-config.js';
+import { validateTask } from '../util/validate-task.js';
+export default class Validate extends Command {
+    static args = {
+    // file: Args.string({description: 'file to read'}),
+    };
+    static description = 'describe the command here';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+    // flag with no value (-f, --force)
+    // force: Flags.boolean({char: 'f'}),
+    // flag with a value (-n, --name=VALUE)
+    // name: Flags.string({char: 'n', description: 'name to print'}),
+    };
+    async run() {
+        await this.parse(Validate);
+        this.log(`validating roadmap...`);
+        const config = await readConfigFile().catch((error) => {
+            this.error(`failed to read config file: ${error ? error.message : String(error)}`);
+        });
+        const roadmapPath = config.path;
+        const roadmapData = await readFile(roadmapPath, 'utf8');
+        let roadmap;
+        try {
+            roadmap = JSON.parse(roadmapData);
+            this.log(`roadmap at ${roadmapPath} is valid JSON`);
+        }
+        catch (error) {
+            this.error(`roadmap at ${roadmapPath} is not valid JSON: ${error ? error.message : String(error)}`);
+        }
+        if (roadmap.tasks.length === 0) {
+            this.log('roadmap contains no tasks to validate');
+            this.log('roadmap validation complete');
+            return;
+        }
+        for (const task of roadmap.tasks) {
+            try {
+                validateTask(task);
+            }
+            catch (error) {
+                this.error(`task ID ${task.id} is invalid: ${error ? error.message : String(error)}`);
+            }
+        }
+        this.log(roadmap.tasks.length > 1 ? `all ${roadmap.tasks.length} tasks are valid` : `1 task is valid`);
+        this.log(`roadmap validation complete`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/util/read-config.d.ts

@@ -0,0 +1,2 @@
+import { Config } from './types.js';
+export declare function readConfigFile(): Promise<Config>;

package/dist/util/read-config.js

@@ -0,0 +1,5 @@
+import { readFile } from 'node:fs/promises';
+export async function readConfigFile() {
+    const data = await readFile('.prtrc.json', 'utf8');
+    return JSON.parse(data);
+}

package/dist/util/read-roadmap.d.ts

@@ -0,0 +1,2 @@
+import { Roadmap } from './types.js';
+export declare function readRoadmapFile(path: string): Promise<Roadmap>;

package/dist/util/read-roadmap.js

@@ -0,0 +1,5 @@
+import { readFile } from 'node:fs/promises';
+export async function readRoadmapFile(path) {
+    const data = await readFile(path, 'utf8');
+    return JSON.parse(data);
+}