@proletariat/cli 0.3.18 → 0.3.20

package/dist/commands/project/update.js

@@ -0,0 +1,163 @@
+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, outputSuccessAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+export default class ProjectUpdate extends PMOCommand {
+    static description = 'Update project metadata (name, description)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-project --name "New Project Name"',
+        '<%= config.bin %> <%= command.id %> my-project --description "Updated description"',
+        '<%= config.bin %> <%= command.id %> my-project --name "New Name" --description "New description"',
+        '<%= config.bin %> <%= command.id %> my-project  # Interactive mode',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Project ID or name',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'New project name',
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'New project description',
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(ProjectUpdate);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('project update', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Agent mode config for prompts
+        const agentConfig = jsonMode ? { flags, commandName: 'project update' } : null;
+        // Get project ID - from args or prompt
+        let projectId = args.id;
+        if (!projectId) {
+            // List available projects for selection
+            const projects = await this.storage.listProjects({ isArchived: false });
+            if (projects.length === 0) {
+                return handleError('NO_PROJECTS', 'No projects found. Create one with: prlt project create');
+            }
+            const projectChoices = projects.map(p => ({
+                name: `${p.id} - ${p.name}`,
+                value: p.id,
+                command: `prlt project update ${p.id} --json`,
+            }));
+            // Handle JSON mode for project selection
+            if (jsonMode) {
+                outputPromptAsJson({
+                    type: 'list',
+                    name: 'projectId',
+                    message: 'Select project to update:',
+                    choices: projectChoices,
+                }, createMetadata('project update', flags));
+                return;
+            }
+            const { selectedProjectId } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedProjectId',
+                    message: 'Select project to update:',
+                    choices: projectChoices,
+                }]);
+            projectId = selectedProjectId;
+        }
+        // Get the project
+        const project = await this.storage.getProject(projectId);
+        if (!project) {
+            return handleError('PROJECT_NOT_FOUND', `Project "${projectId}" not found.`);
+        }
+        // Determine what to update
+        let newName = flags.name;
+        let newDescription = flags.description;
+        // If no flags provided, enter interactive mode
+        if (newName === undefined && newDescription === undefined) {
+            const fields = [
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Project name:',
+                    default: project.name,
+                },
+                {
+                    type: 'input',
+                    name: 'description',
+                    message: 'Project description:',
+                    default: project.description || '',
+                },
+            ];
+            // Handle JSON mode for field input
+            if (jsonMode) {
+                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('project update', flags));
+                return;
+            }
+            const answers = await inquirer.prompt(fields.map(field => ({
+                ...field,
+                validate: field.name === 'name'
+                    ? ((input) => input.length > 0 || 'Name is required')
+                    : undefined,
+            })));
+            newName = answers.name;
+            newDescription = answers.description;
+        }
+        // Build changes object - only include fields that are different
+        const changes = {};
+        if (newName !== undefined && newName !== project.name) {
+            changes.name = newName;
+        }
+        if (newDescription !== undefined && newDescription !== (project.description || '')) {
+            // Allow clearing description with empty string (storage layer converts '' to null)
+            changes.description = newDescription;
+        }
+        // Check if anything changed
+        if (Object.keys(changes).length === 0) {
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    projectId: project.id,
+                    projectName: project.name,
+                    description: project.description,
+                    noChanges: true,
+                }, createMetadata('project update', flags));
+                return;
+            }
+            this.log(styles.muted('No changes made.'));
+            return;
+        }
+        // Update the project
+        const updated = await this.storage.updateProject(project.id, changes);
+        // Output success
+        if (jsonMode) {
+            outputSuccessAsJson({
+                projectId: updated.id,
+                projectName: updated.name,
+                description: updated.description,
+                changes: Object.keys(changes),
+            }, createMetadata('project update', flags));
+            return;
+        }
+        this.log(styles.success(`\nUpdated project "${styles.emphasis(updated.name)}"`));
+        this.log(styles.muted(`  ID: ${updated.id}`));
+        if (changes.name) {
+            this.log(styles.muted(`  Name: ${project.name} → ${updated.name}`));
+        }
+        if ('description' in changes) {
+            const oldDesc = project.description || '(none)';
+            const newDesc = updated.description || '(none)';
+            this.log(styles.muted(`  Description: ${oldDesc} → ${newDesc}`));
+        }
+    }
+}

package/dist/commands/roadmap/create.js

@@ -94,6 +94,11 @@ export default class RoadmapCreate extends PMOCommand {
             description: roadmapData.description,
             isDefault: roadmapData.isDefault,
         });
+        // In JSON mode, output roadmap data and return (skip interactive prompts)
+        if (jsonMode) {
+            this.log(JSON.stringify(roadmap, null, 2));
+            return;
+        }
         this.log(styles.success(`\nCreated roadmap "${styles.emphasis(roadmap.name)}"`));
         this.log(styles.muted(`  ID: ${roadmap.id}`));
         if (roadmap.description) {

package/dist/commands/spec/delete.d.ts

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SpecDelete extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: 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/spec/delete.js

@@ -0,0 +1,111 @@
+import { Args, Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputErrorAsJson, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { FlagResolver } from '../../lib/flags/index.js';
+export default class SpecDelete extends PMOCommand {
+    static description = 'Delete a spec';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-spec',
+        '<%= config.bin %> <%= command.id %> my-spec --force',
+        '<%= config.bin %> <%= command.id %>  # Interactive selection',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Spec ID to delete',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(SpecDelete);
+        const jsonMode = shouldOutputJson(flags);
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('spec delete', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        let specId = args.id;
+        // Interactive selection if no ID provided
+        if (!specId) {
+            const specs = await this.storage.listSpecs();
+            if (specs.length === 0) {
+                return handleError('NO_SPECS', 'No specs found');
+            }
+            const resolver = new FlagResolver({
+                commandName: 'spec delete',
+                baseCommand: 'prlt spec delete',
+                jsonMode,
+                flags: {},
+            });
+            resolver.addPrompt({
+                flagName: 'spec',
+                type: 'list',
+                message: 'Select spec to delete:',
+                choices: () => specs.map(s => ({
+                    name: `${s.title} [${s.status}]${s.type ? ` (${s.type})` : ''}`,
+                    value: s.id,
+                })),
+                getCommand: (value) => `prlt spec delete ${value} --json`,
+            });
+            const resolved = await resolver.resolve();
+            specId = resolved.spec;
+        }
+        // Get spec details
+        const spec = await this.storage.getSpec(specId);
+        if (!spec) {
+            return handleError('SPEC_NOT_FOUND', `Spec not found: ${specId}`);
+        }
+        // Confirmation prompt
+        if (!flags.force) {
+            const resolver = new FlagResolver({
+                commandName: 'spec delete',
+                baseCommand: `prlt spec delete ${specId}`,
+                jsonMode,
+                flags: {},
+            });
+            resolver.addPrompt({
+                flagName: 'confirmed',
+                type: 'list',
+                message: `Delete spec "${spec.title}"?`,
+                choices: () => [
+                    { name: 'No', value: false },
+                    { name: 'Yes', value: true },
+                ],
+                getCommand: (value) => value
+                    ? `prlt spec delete ${specId} --force --json`
+                    : '',
+            });
+            const resolved = await resolver.resolve();
+            if (!resolved.confirmed) {
+                this.log(styles.muted('Cancelled'));
+                return;
+            }
+        }
+        // Delete the spec
+        await this.storage.deleteSpec(specId);
+        // JSON response for agents
+        if (jsonMode) {
+            outputSuccessAsJson({
+                specId: spec.id,
+                title: spec.title,
+                deleted: true,
+            }, createMetadata('spec delete', flags));
+            return;
+        }
+        // Human-readable response
+        this.log(styles.success(`\nDeleted spec "${styles.emphasis(spec.title)}"`));
+    }
+}

package/dist/commands/spec/edit.d.ts

@@ -0,0 +1,23 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SpecEdit extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        spec: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        spec: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        title: 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>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        problem: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        solution: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        decisions: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: 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>;
+    };
+    execute(): Promise<void>;
+    private promptForEdits;
+}

package/dist/commands/spec/edit.js

@@ -0,0 +1,232 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { FlagResolver } from '../../lib/flags/index.js';
+export default class SpecEdit extends PMOCommand {
+    static description = 'Edit an existing spec';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> user-authentication',
+        '<%= config.bin %> <%= command.id %> --spec api-design --title "New API Design"',
+        '<%= config.bin %> <%= command.id %> user-auth --status active',
+        '<%= config.bin %> <%= command.id %> user-auth --type product --problem "Need better auth"',
+        '<%= config.bin %> <%= command.id %> -i  # Interactive mode',
+    ];
+    static args = {
+        spec: Args.string({
+            description: 'Spec ID to edit',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        spec: Flags.string({
+            char: 's',
+            description: 'Spec ID to edit',
+        }),
+        title: Flags.string({
+            char: 't',
+            description: 'New spec title',
+        }),
+        status: Flags.string({
+            description: 'Spec status',
+            options: ['draft', 'active', 'implemented'],
+        }),
+        type: Flags.string({
+            description: 'Spec type',
+            options: ['product', 'platform', 'infra', 'integration', 'none'],
+        }),
+        problem: Flags.string({
+            description: 'Problem statement',
+        }),
+        solution: Flags.string({
+            description: 'Solution description',
+        }),
+        decisions: Flags.string({
+            description: 'Design decisions',
+        }),
+        interactive: Flags.boolean({
+            char: 'i',
+            description: 'Interactive mode - prompts for all fields',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(SpecEdit);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('spec edit', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get spec ID from args or flags
+        let specId = args.spec || flags.spec;
+        if (!specId) {
+            // List specs for selection
+            const specs = await this.storage.listSpecs();
+            if (specs.length === 0) {
+                return handleError('NO_SPECS', 'No specs found. Create one first with: prlt spec create');
+            }
+            // Use FlagResolver for spec selection
+            const resolver = new FlagResolver({
+                commandName: 'spec edit',
+                baseCommand: 'prlt spec edit',
+                jsonMode,
+                flags: { spec: flags.spec },
+            });
+            resolver.addPrompt({
+                flagName: 'spec',
+                type: 'list',
+                message: 'Select spec to edit:',
+                choices: () => specs.map(s => ({
+                    name: `${s.title} [${s.status}]${s.type ? ` (${s.type})` : ''}`,
+                    value: s.id,
+                })),
+            });
+            const resolved = await resolver.resolve();
+            specId = resolved.spec;
+        }
+        // Get current spec
+        const spec = await this.storage.getSpec(specId);
+        if (!spec) {
+            return handleError('NOT_FOUND', `Spec "${specId}" not found.`);
+        }
+        // Build choices for prompts
+        const typeChoices = [
+            { name: 'Product (user-facing feature)', value: 'product' },
+            { name: 'Platform (internal tooling)', value: 'platform' },
+            { name: 'Infra (technical infrastructure)', value: 'infra' },
+            { name: 'Integration (external service)', value: 'integration' },
+            { name: 'None', value: '' },
+        ];
+        const statusChoices = [
+            { name: 'Draft (planning)', value: 'draft' },
+            { name: 'Active (in progress)', value: 'active' },
+            { name: 'Implemented (complete)', value: 'implemented' },
+        ];
+        // Determine what to update
+        let updates = {};
+        const hasFlags = flags.title || flags.status || flags.type || flags.problem ||
+            flags.solution || flags.decisions;
+        if (flags.interactive || !hasFlags) {
+            // Interactive mode - prompt for editable fields
+            updates = await this.promptForEdits(spec, typeChoices, statusChoices);
+        }
+        else {
+            // Use flag values
+            if (flags.title)
+                updates.title = flags.title;
+            if (flags.status)
+                updates.status = flags.status;
+            if (flags.type) {
+                updates.type = flags.type === 'none' ? undefined : flags.type;
+            }
+            if (flags.problem)
+                updates.problem = flags.problem;
+            if (flags.solution)
+                updates.solution = flags.solution;
+            if (flags.decisions)
+                updates.decisions = flags.decisions;
+        }
+        // Check if anything changed
+        if (Object.keys(updates).length === 0) {
+            this.log(styles.muted('\nNo changes made.'));
+            return;
+        }
+        // Update the spec
+        const updatedSpec = await this.storage.updateSpec(specId, updates);
+        // Display updated spec
+        this.log(styles.success(`\n✅ Updated spec "${styles.emphasis(updatedSpec.title)}"`));
+        const changedFields = [];
+        if (updates.title)
+            changedFields.push(`Title: ${updatedSpec.title}`);
+        if (updates.status)
+            changedFields.push(`Status: ${updatedSpec.status}`);
+        if (updates.type !== undefined)
+            changedFields.push(`Type: ${updatedSpec.type || 'none'}`);
+        if (updates.problem !== undefined)
+            changedFields.push(`Problem: ${updates.problem ? 'updated' : '(cleared)'}`);
+        if (updates.solution !== undefined)
+            changedFields.push(`Solution: ${updates.solution ? 'updated' : '(cleared)'}`);
+        if (updates.decisions !== undefined)
+            changedFields.push(`Decisions: ${updates.decisions ? 'updated' : '(cleared)'}`);
+        for (const field of changedFields) {
+            this.log(styles.muted(`   ${field}`));
+        }
+        this.log('');
+        this.log(styles.muted(`View spec: prlt spec view ${updatedSpec.id}`));
+    }
+    async promptForEdits(spec, typeChoices, statusChoices) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'title',
+                message: 'Title:',
+                default: spec.title,
+                validate: (input) => input.length > 0 || 'Title is required',
+            },
+            {
+                type: 'list',
+                name: 'status',
+                message: 'Status:',
+                choices: statusChoices,
+                default: spec.status,
+            },
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Type:',
+                choices: typeChoices,
+                default: spec.type || '',
+            },
+            {
+                type: 'editor',
+                name: 'problem',
+                message: 'Problem statement (opens $EDITOR):',
+                default: spec.problem || '',
+                waitForUseInput: false,
+            },
+            {
+                type: 'editor',
+                name: 'solution',
+                message: 'Solution (opens $EDITOR):',
+                default: spec.solution || '',
+                waitForUseInput: false,
+            },
+            {
+                type: 'editor',
+                name: 'decisions',
+                message: 'Design decisions (opens $EDITOR):',
+                default: spec.decisions || '',
+                waitForUseInput: false,
+            },
+        ]);
+        // Build updates object with only changed fields
+        const updates = {};
+        if (answers.title !== spec.title) {
+            updates.title = answers.title;
+        }
+        if (answers.status !== spec.status) {
+            updates.status = answers.status;
+        }
+        const newType = answers.type === '' ? undefined : answers.type;
+        if (newType !== spec.type) {
+            updates.type = newType;
+        }
+        if (answers.problem !== (spec.problem || '')) {
+            updates.problem = answers.problem || undefined;
+        }
+        if (answers.solution !== (spec.solution || '')) {
+            updates.solution = answers.solution || undefined;
+        }
+        if (answers.decisions !== (spec.decisions || '')) {
+            updates.decisions = answers.decisions || undefined;
+        }
+        return updates;
+    }
+}

package/dist/commands/spec/index.js

@@ -21,6 +21,7 @@ export default class Spec extends PMOCommand {
             { name: 'Create new spec', value: 'create' },
             { name: 'List all specs', value: 'list' },
             { name: 'View spec', value: 'view' },
+            { name: 'Delete spec', value: 'delete' },
             { name: 'Generate tickets from spec', value: 'generate' },
             { name: 'Assign ticket to spec', value: 'ticket' },
             { name: 'Manage dependencies', value: 'link' },
@@ -44,6 +45,7 @@ export default class Spec extends PMOCommand {
                     create: 'prlt spec create --json',
                     list: 'prlt spec list --json',
                     view: 'prlt spec view --json',
+                    delete: 'prlt spec delete --json',
                     generate: 'prlt spec plan --json',
                     ticket: 'prlt spec ticket --json',
                     link: 'prlt spec link --json',
@@ -68,6 +70,9 @@ export default class Spec extends PMOCommand {
             case 'view':
                 await this.config.runCommand('spec:view', []);
                 break;
+            case 'delete':
+                await this.config.runCommand('spec:delete', []);
+                break;
             case 'generate':
                 await this.config.runCommand('spec:generate-tickets', []);
                 break;

package/dist/commands/status/create.js

@@ -88,40 +88,44 @@ export default class StatusCreate extends PMOCommand {
             default: flags.category || 'backlog',
             when: (ctx) => !ctx.flags.category || flags.interactive,
         });
-        // Add color prompt
-        resolver.addPrompt({
-            flagName: 'color',
-            type: 'input',
-            message: 'Color (hex, optional):',
-            default: flags.color,
-            validate: (value) => {
-                const v = value;
-                if (!v)
-                    return true;
-                return /^#[0-9A-Fa-f]{6}$/.test(v) || 'Invalid hex color (e.g., #FF0000)';
-            },
-            when: (ctx) => ctx.flags.color === undefined || flags.interactive,
-        });
-        // Add description prompt
-        resolver.addPrompt({
-            flagName: 'description',
-            type: 'input',
-            message: 'Description (optional):',
-            default: flags.description,
-            when: (ctx) => ctx.flags.description === undefined || flags.interactive,
-        });
-        // Add default prompt
-        resolver.addPrompt({
-            flagName: 'default',
-            type: 'list',
-            message: 'Set as default status for new tickets?',
-            choices: () => [
-                { name: 'No', value: false, command: 'prlt status create --json' },
-                { name: 'Yes', value: true, command: 'prlt status create --default --json' },
-            ],
-            default: flags.default || false,
-            when: (ctx) => ctx.flags.default === undefined || flags.interactive,
-        });
+        // Optional prompts - only shown in interactive mode
+        // In JSON/machine mode, optional fields should be passed as flags or omitted
+        if (flags.interactive) {
+            // Add color prompt
+            resolver.addPrompt({
+                flagName: 'color',
+                type: 'input',
+                message: 'Color (hex, optional):',
+                default: flags.color,
+                validate: (value) => {
+                    const v = value;
+                    if (!v)
+                        return true;
+                    return /^#[0-9A-Fa-f]{6}$/.test(v) || 'Invalid hex color (e.g., #FF0000)';
+                },
+                when: (ctx) => ctx.flags.color === undefined,
+            });
+            // Add description prompt
+            resolver.addPrompt({
+                flagName: 'description',
+                type: 'input',
+                message: 'Description (optional):',
+                default: flags.description,
+                when: (ctx) => ctx.flags.description === undefined,
+            });
+            // Add default prompt
+            resolver.addPrompt({
+                flagName: 'default',
+                type: 'list',
+                message: 'Set as default status for new tickets?',
+                choices: () => [
+                    { name: 'No', value: false, command: 'prlt status create --json' },
+                    { name: 'Yes', value: true, command: 'prlt status create --default --json' },
+                ],
+                default: flags.default || false,
+                when: (ctx) => ctx.flags.default === undefined,
+            });
+        }
         // Resolve all flags
         const resolved = await resolver.resolve();
         const status = await this.storage.createStatus(projectId, {