@proletariat/cli 0.3.9 → 0.3.11

package/dist/commands/roadmap/generate.js

@@ -0,0 +1,201 @@
+import { Args, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { slugify } from '../../lib/pmo/utils.js';
+import { normalizePriority, PRIORITIES } from '../../lib/pmo/types.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class RoadmapGenerate extends PMOCommand {
+    static description = 'Generate roadmap markdown file';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-roadmap',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> my-roadmap --output ./docs',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Roadmap ID to generate',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        all: Flags.boolean({
+            description: 'Generate all roadmaps',
+            default: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Output directory (default: {pmoPath}/roadmaps)',
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(RoadmapGenerate);
+        const jsonMode = shouldOutputJson(flags);
+        // Determine output directory
+        const outputDir = flags.output || path.join(this.pmoPath, 'roadmaps');
+        fs.mkdirSync(outputDir, { recursive: true });
+        if (flags.all) {
+            // Generate all roadmaps
+            const roadmaps = await this.storage.listRoadmaps();
+            if (roadmaps.length === 0) {
+                this.log(styles.muted('No roadmaps found. Create one with: prlt roadmap create'));
+                return;
+            }
+            for (const roadmap of roadmaps) {
+                // eslint-disable-next-line no-await-in-loop -- Sequential generation with user feedback
+                await this.generateRoadmap(roadmap.id, outputDir);
+            }
+            this.log(styles.success(`\nGenerated ${roadmaps.length} roadmap(s) to ${outputDir}`));
+            return;
+        }
+        // Select specific roadmap
+        let roadmapId = args.id;
+        if (!roadmapId) {
+            const roadmaps = await this.storage.listRoadmaps();
+            if (roadmaps.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_ROADMAPS', 'No roadmaps found', createMetadata('roadmap generate', flags));
+                    return;
+                }
+                this.error('No roadmaps found. Create one with: prlt roadmap create');
+            }
+            if (jsonMode) {
+                const choices = roadmaps.map(r => ({
+                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
+                    value: r.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select roadmap to generate:', choices), createMetadata('roadmap generate', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select roadmap to generate:',
+                    choices: roadmaps.map(r => ({
+                        name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
+                        value: r.id,
+                    })),
+                }]);
+            roadmapId = selected;
+        }
+        await this.generateRoadmap(roadmapId, outputDir);
+    }
+    async generateRoadmap(roadmapId, outputDir) {
+        const roadmap = await this.storage.getRoadmap(roadmapId);
+        if (!roadmap) {
+            this.error(`Roadmap not found: ${roadmapId}`);
+        }
+        const projects = await this.storage.listRoadmapProjects(roadmapId);
+        const lines = [];
+        // Header
+        lines.push(`# ${roadmap.name}`);
+        lines.push('');
+        if (roadmap.description) {
+            lines.push(roadmap.description);
+            lines.push('');
+        }
+        lines.push('Generated from PMO database. Source of truth: `workspace.db`');
+        lines.push('');
+        lines.push('---');
+        lines.push('');
+        // Process each project
+        for (let i = 0; i < projects.length; i++) {
+            const project = projects[i];
+            // eslint-disable-next-line no-await-in-loop -- Sequential processing for output generation
+            const tickets = await this.storage.listTickets(project.id);
+            if (tickets.length === 0)
+                continue;
+            // Strip leading number prefix from project name (e.g., "1. MVP Launch" -> "MVP Launch")
+            let displayName = project.name;
+            if (displayName && /^\d+\.\s/.test(displayName)) {
+                displayName = displayName.replace(/^\d+\.\s/, '');
+            }
+            lines.push(`## ${i + 1}. ${displayName}`);
+            lines.push('');
+            // Group tickets by priority
+            const ticketsByPriority = new Map();
+            for (const priority of PRIORITIES) {
+                ticketsByPriority.set(priority, []);
+            }
+            ticketsByPriority.set('unset', []);
+            for (const ticket of tickets) {
+                const normalizedPriority = normalizePriority(ticket.priority) || 'unset';
+                const group = ticketsByPriority.get(normalizedPriority) || ticketsByPriority.get('unset');
+                group.push(ticket);
+            }
+            // Sort each priority group by status category, then ticket ID
+            const categoryOrder = {
+                'started': 1,
+                'unstarted': 2,
+                'backlog': 3,
+                'completed': 4,
+                'canceled': 5,
+                'triage': 6,
+            };
+            for (const [priority, priorityTickets] of ticketsByPriority) {
+                if (priorityTickets.length === 0)
+                    continue;
+                priorityTickets.sort((a, b) => {
+                    const catA = categoryOrder[a.statusCategory || 'backlog'] || 6;
+                    const catB = categoryOrder[b.statusCategory || 'backlog'] || 6;
+                    if (catA !== catB)
+                        return catA - catB;
+                    return a.id.localeCompare(b.id);
+                });
+                // Priority header
+                const priorityLabel = priority === 'unset' ? 'Unset Priority' : `${priority} - ${this.getPriorityLabel(priority)}`;
+                lines.push(`### ${priorityLabel} (${priorityTickets.length} ticket${priorityTickets.length > 1 ? 's' : ''})`);
+                lines.push('');
+                // Table header
+                lines.push('| Ticket | Title | Status | Category | Description |');
+                lines.push('| ------ | ----- | ------ | -------- | ----------- |');
+                for (const ticket of priorityTickets) {
+                    const title = this.cleanForTable(ticket.title);
+                    const status = ticket.statusCategory || 'backlog';
+                    const category = ticket.category || '';
+                    const desc = this.truncateDescription(ticket.description || '', 150);
+                    lines.push(`| ${ticket.id} | ${title} | ${status} | ${category} | ${desc} |`);
+                }
+                lines.push('');
+            }
+            lines.push('---');
+            lines.push('');
+        }
+        // Footer
+        lines.push(`*Last updated: ${new Date().toISOString().split('T')[0]}*`);
+        lines.push('');
+        const fileName = `${slugify(roadmap.name)}.md`;
+        const filePath = path.join(outputDir, fileName);
+        fs.writeFileSync(filePath, lines.join('\n'));
+        this.log(styles.success(`Generated ${filePath}`));
+    }
+    getPriorityLabel(priority) {
+        const labels = {
+            'P0': 'Critical',
+            'P1': 'High',
+            'P2': 'Medium',
+            'P3': 'Low',
+        };
+        return labels[priority] || priority;
+    }
+    cleanForTable(text) {
+        return (text || '').replace(/\|/g, '-').replace(/\n/g, ' ').replace(/\r/g, '').trim();
+    }
+    truncateDescription(desc, maxLength) {
+        const cleaned = this.cleanForTable(desc);
+        if (cleaned.length > maxLength) {
+            return cleaned.substring(0, maxLength - 3) + '...';
+        }
+        return cleaned;
+    }
+}

package/dist/commands/roadmap/index.d.ts

@@ -0,0 +1,13 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Roadmap extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/roadmap/index.js

@@ -0,0 +1,61 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
+export default class Roadmap extends PMOCommand {
+    static description = 'Interactive menu for roadmap operations';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(Roadmap);
+        const jsonMode = shouldOutputJson(flags);
+        const menuChoices = [
+            { id: 'create', name: 'Create new roadmap', command: 'prlt roadmap create --json' },
+            { id: 'list', name: 'List all roadmaps', command: 'prlt roadmap list --json' },
+            { id: 'view', name: 'View roadmap details', command: 'prlt roadmap view --json' },
+            { id: 'generate', name: 'Generate roadmap markdown', command: 'prlt roadmap generate --json' },
+            { id: 'update', name: 'Update roadmap', command: 'prlt roadmap update --json' },
+            { id: 'delete', name: 'Delete roadmap', command: 'prlt roadmap delete --json' },
+            { id: 'add-project', name: 'Add project to roadmap', command: 'prlt roadmap add-project --json' },
+            { id: 'remove-project', name: 'Remove project from roadmap', command: 'prlt roadmap remove-project --json' },
+            { id: 'reorder', name: 'Reorder projects in roadmap', command: 'prlt roadmap reorder --json' },
+            { id: 'cancel', name: 'Cancel', command: '' },
+        ];
+        const message = 'Roadmap Operations - What would you like to do?';
+        const action = await this.selectFromList({
+            message,
+            items: menuChoices,
+            getName: (c) => c.name,
+            getValue: (c) => c.id,
+            getCommand: (c) => c.command,
+            jsonMode: jsonMode ? { flags, commandName: 'roadmap' } : null,
+        });
+        if (action === 'cancel' || !action) {
+            return;
+        }
+        const commandMap = {
+            'create': 'roadmap:create',
+            'list': 'roadmap:list',
+            'view': 'roadmap:view',
+            'generate': 'roadmap:generate',
+            'update': 'roadmap:update',
+            'delete': 'roadmap:delete',
+            'add-project': 'roadmap:add-project',
+            'remove-project': 'roadmap:remove-project',
+            'reorder': 'roadmap:reorder',
+        };
+        if (commandMap[action]) {
+            await this.config.runCommand(commandMap[action], []);
+        }
+    }
+}

package/dist/commands/roadmap/list.d.ts

@@ -0,0 +1,12 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class RoadmapList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/roadmap/list.js

@@ -0,0 +1,42 @@
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class RoadmapList extends PMOCommand {
+    static description = 'List all roadmaps';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const roadmaps = await this.storage.listRoadmaps();
+        if (roadmaps.length === 0) {
+            this.log(styles.muted('No roadmaps found. Create one with: prlt roadmap create'));
+            return;
+        }
+        this.log(styles.title('\nRoadmaps\n'));
+        // Fetch all project counts in parallel
+        const projectCounts = await Promise.all(roadmaps.map(async (roadmap) => {
+            const projects = await this.storage.listRoadmapProjects(roadmap.id);
+            return projects.length;
+        }));
+        for (let i = 0; i < roadmaps.length; i++) {
+            const roadmap = roadmaps[i];
+            const markers = [];
+            if (roadmap.isDefault)
+                markers.push(styles.success('default'));
+            const markerStr = markers.length > 0 ? ` (${markers.join(', ')})` : '';
+            this.log(`  ${styles.emphasis(roadmap.name)}${markerStr}`);
+            this.log(styles.muted(`    ID: ${roadmap.id}`));
+            // Get project count (already fetched in parallel)
+            this.log(styles.muted(`    Projects: ${projectCounts[i]}`));
+            if (roadmap.description) {
+                this.log(styles.muted(`    ${roadmap.description}`));
+            }
+            this.log('');
+        }
+    }
+}

package/dist/commands/roadmap/remove-project.d.ts

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class RoadmapRemoveProject extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        roadmap: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        project: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/roadmap/remove-project.js

@@ -0,0 +1,147 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class RoadmapRemoveProject extends PMOCommand {
+    static description = 'Remove a project from a roadmap';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-roadmap my-project',
+        '<%= config.bin %> <%= command.id %> my-roadmap  # Interactive project selection',
+        '<%= config.bin %> <%= command.id %>  # Interactive selection for both',
+    ];
+    static args = {
+        roadmap: Args.string({
+            description: 'Roadmap ID',
+            required: false,
+        }),
+        project: Args.string({
+            description: 'Project ID to remove',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(RoadmapRemoveProject);
+        const jsonMode = shouldOutputJson(flags);
+        // Select roadmap
+        let roadmapId = args.roadmap;
+        if (!roadmapId) {
+            const roadmaps = await this.storage.listRoadmaps();
+            if (roadmaps.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_ROADMAPS', 'No roadmaps found', createMetadata('roadmap remove-project', flags));
+                    return;
+                }
+                this.error('No roadmaps found');
+            }
+            if (jsonMode) {
+                const choices = roadmaps.map(r => ({
+                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
+                    value: r.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'roadmap', 'Select roadmap:', choices), createMetadata('roadmap remove-project', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select roadmap:',
+                    choices: roadmaps.map(r => ({
+                        name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
+                        value: r.id,
+                    })),
+                }]);
+            roadmapId = selected;
+        }
+        const roadmap = await this.storage.getRoadmap(roadmapId);
+        if (!roadmap) {
+            if (jsonMode) {
+                outputErrorAsJson('NOT_FOUND', `Roadmap not found: ${roadmapId}`, createMetadata('roadmap remove-project', flags));
+                return;
+            }
+            this.error(`Roadmap not found: ${roadmapId}`);
+        }
+        // Get projects in roadmap
+        const projects = await this.storage.listRoadmapProjects(roadmapId);
+        if (projects.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_PROJECTS', 'No projects in this roadmap', createMetadata('roadmap remove-project', flags));
+                return;
+            }
+            this.error('No projects in this roadmap');
+        }
+        // Select project
+        let projectId = args.project;
+        if (!projectId) {
+            if (jsonMode) {
+                const choices = projects.map((p, i) => ({
+                    name: `${i + 1}. ${p.name}`,
+                    value: p.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'project', 'Select project to remove:', choices), createMetadata('roadmap remove-project', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select project to remove:',
+                    choices: projects.map((p, i) => ({
+                        name: `${i + 1}. ${p.name}`,
+                        value: p.id,
+                    })),
+                }]);
+            projectId = selected;
+        }
+        // Verify project is in roadmap
+        const project = projects.find(p => p.id === projectId);
+        if (!project) {
+            if (jsonMode) {
+                outputErrorAsJson('NOT_IN_ROADMAP', `Project "${projectId}" is not in this roadmap`, createMetadata('roadmap remove-project', flags));
+                return;
+            }
+            this.error(`Project "${projectId}" is not in this roadmap`);
+        }
+        // Confirm removal
+        if (!flags.force) {
+            const message = `Remove "${project.name}" from "${roadmap.name}"?`;
+            if (jsonMode) {
+                const confirmChoices = [
+                    { name: 'No, cancel', value: 'false' },
+                    { name: 'Yes, remove', value: 'true' },
+                ];
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', message, confirmChoices), createMetadata('roadmap remove-project', flags));
+                return;
+            }
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message,
+                    choices: [
+                        { name: 'No, cancel', value: false },
+                        { name: 'Yes, remove', value: true },
+                    ],
+                }]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled.'));
+                return;
+            }
+        }
+        await this.storage.removeProjectFromRoadmap(roadmapId, projectId);
+        this.log(styles.success(`Removed "${project.name}" from "${roadmap.name}"`));
+    }
+}

package/dist/commands/roadmap/reorder.d.ts

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class RoadmapReorder extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        roadmap: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        position: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/roadmap/reorder.js

@@ -0,0 +1,157 @@
+import { Args, Flags } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class RoadmapReorder extends PMOCommand {
+    static description = 'Reorder projects in a roadmap';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-roadmap',
+        '<%= config.bin %> <%= command.id %> my-roadmap --project my-project --position 0',
+        '<%= config.bin %> <%= command.id %>  # Interactive selection',
+    ];
+    static args = {
+        roadmap: Args.string({
+            description: 'Roadmap ID',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        project: Flags.string({
+            char: 'p',
+            description: 'Project ID to move',
+        }),
+        position: Flags.integer({
+            description: 'New position (0-indexed)',
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(RoadmapReorder);
+        const jsonMode = shouldOutputJson(flags);
+        // Select roadmap
+        let roadmapId = args.roadmap;
+        if (!roadmapId) {
+            const roadmaps = await this.storage.listRoadmaps();
+            if (roadmaps.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_ROADMAPS', 'No roadmaps found', createMetadata('roadmap reorder', flags));
+                    return;
+                }
+                this.error('No roadmaps found');
+            }
+            if (jsonMode) {
+                const choices = roadmaps.map(r => ({
+                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
+                    value: r.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'roadmap', 'Select roadmap:', choices), createMetadata('roadmap reorder', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select roadmap:',
+                    choices: roadmaps.map(r => ({
+                        name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
+                        value: r.id,
+                    })),
+                }]);
+            roadmapId = selected;
+        }
+        const roadmap = await this.storage.getRoadmap(roadmapId);
+        if (!roadmap) {
+            if (jsonMode) {
+                outputErrorAsJson('NOT_FOUND', `Roadmap not found: ${roadmapId}`, createMetadata('roadmap reorder', flags));
+                return;
+            }
+            this.error(`Roadmap not found: ${roadmapId}`);
+        }
+        // Get projects in roadmap
+        let projects = await this.storage.listRoadmapProjects(roadmapId);
+        if (projects.length < 2) {
+            if (jsonMode) {
+                outputErrorAsJson('NOT_ENOUGH_PROJECTS', 'Need at least 2 projects to reorder', createMetadata('roadmap reorder', flags));
+                return;
+            }
+            this.error('Need at least 2 projects to reorder');
+        }
+        // If flags provided, use them
+        if (flags.project && flags.position !== undefined) {
+            const project = projects.find(p => p.id === flags.project);
+            if (!project) {
+                if (jsonMode) {
+                    outputErrorAsJson('NOT_IN_ROADMAP', `Project "${flags.project}" is not in this roadmap`, createMetadata('roadmap reorder', flags));
+                    return;
+                }
+                this.error(`Project "${flags.project}" is not in this roadmap`);
+            }
+            await this.storage.reorderRoadmapProject(roadmapId, flags.project, flags.position);
+            this.log(styles.success(`Moved "${project.name}" to position ${flags.position + 1}`));
+            return;
+        }
+        // Interactive mode
+        this.log(styles.title(`\nReorder projects in "${roadmap.name}"\n`));
+        this.log('Current order:');
+        for (let i = 0; i < projects.length; i++) {
+            this.log(`  ${i + 1}. ${projects[i].name}`);
+        }
+        this.log('');
+        // Prompt to select project to move
+        if (jsonMode) {
+            const choices = projects.map((p, i) => ({
+                name: `${i + 1}. ${p.name}`,
+                value: p.id,
+            }));
+            outputPromptAsJson(buildPromptConfig('list', 'project', 'Select project to move:', choices), createMetadata('roadmap reorder', flags));
+            return;
+        }
+        const { projectToMove } = await inquirer.prompt([{
+                type: 'list',
+                name: 'projectToMove',
+                message: 'Select project to move:',
+                choices: projects.map((p, i) => ({
+                    name: `${i + 1}. ${p.name}`,
+                    value: p.id,
+                })),
+            }]);
+        const project = projects.find(p => p.id === projectToMove);
+        const currentPosition = projects.findIndex(p => p.id === projectToMove);
+        // Generate position choices
+        const positionChoices = projects.map((p, i) => {
+            if (i === currentPosition) {
+                return { name: `${i + 1}. ${p.name} (current position)`, value: i, disabled: true };
+            }
+            const label = i < currentPosition ? `Move before ${i + 1}. ${p.name}` : `Move after ${i}. ${projects[i - 1]?.name || ''}`;
+            return { name: `Position ${i + 1}: ${label}`, value: i };
+        }).filter(c => !c.disabled);
+        // Add "move to end" option if not already at the end
+        if (currentPosition !== projects.length - 1) {
+            positionChoices.push({
+                name: `Position ${projects.length}: Move to end`,
+                value: projects.length - 1,
+            });
+        }
+        const { newPosition } = await inquirer.prompt([{
+                type: 'list',
+                name: 'newPosition',
+                message: `Move "${project.name}" to which position?`,
+                choices: positionChoices,
+            }]);
+        await this.storage.reorderRoadmapProject(roadmapId, projectToMove, newPosition);
+        // Show new order
+        projects = await this.storage.listRoadmapProjects(roadmapId);
+        this.log(styles.success(`\nReordered. New order:`));
+        for (let i = 0; i < projects.length; i++) {
+            const marker = projects[i].id === projectToMove ? styles.success(' ←') : '';
+            this.log(`  ${i + 1}. ${projects[i].name}${marker}`);
+        }
+    }
+}