@proletariat/cli 0.1.4 → 0.3.0

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

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Workflow extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        builtin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        custom: 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/workflow/index.js

@@ -0,0 +1,75 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class Workflow extends PMOCommand {
+    static description = 'List all available workflows (alias for workflow list)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --builtin',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        builtin: Flags.boolean({
+            description: 'Show only built-in workflows',
+            default: false,
+        }),
+        custom: Flags.boolean({
+            description: 'Show only custom workflows',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(Workflow);
+        // Build filter
+        const filter = {};
+        if (flags.builtin)
+            filter.isBuiltin = true;
+        if (flags.custom)
+            filter.isBuiltin = false;
+        const workflows = await this.storage.listWorkflows(Object.keys(filter).length > 0 ? filter : undefined);
+        if (flags.json) {
+            this.log(JSON.stringify(workflows, null, 2));
+            return;
+        }
+        if (workflows.length === 0) {
+            this.log(styles.muted('\nNo workflows found.'));
+            this.log(styles.muted('Create one: prlt workflow create "My Workflow"'));
+            return;
+        }
+        this.log(`\n${styles.emphasis('Workflows')}`);
+        this.log('═'.repeat(60));
+        // Group by builtin vs custom
+        const builtinWorkflows = workflows.filter(w => w.isBuiltin);
+        const customWorkflows = workflows.filter(w => !w.isBuiltin);
+        if (builtinWorkflows.length > 0 && !flags.custom) {
+            this.log(`\n${styles.emphasis('Built-in')}`);
+            this.log('─'.repeat(40));
+            for (const workflow of builtinWorkflows) {
+                this.log(`  ${styles.emphasis(workflow.name)} ${styles.muted(`(${workflow.id})`)}`);
+                if (workflow.description) {
+                    this.log(`    ${styles.muted(workflow.description)}`);
+                }
+            }
+        }
+        if (customWorkflows.length > 0 && !flags.builtin) {
+            this.log(`\n${styles.emphasis('Custom')}`);
+            this.log('─'.repeat(40));
+            for (const workflow of customWorkflows) {
+                this.log(`  ${styles.emphasis(workflow.name)} ${styles.muted(`(${workflow.id})`)}`);
+                if (workflow.description) {
+                    this.log(`    ${styles.muted(workflow.description)}`);
+                }
+            }
+        }
+        this.log('');
+        this.log(styles.muted('View details: prlt workflow view <id>'));
+    }
+}

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

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkflowList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        builtin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        custom: 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/workflow/list.js

@@ -0,0 +1,75 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class WorkflowList extends PMOCommand {
+    static description = 'List all available workflows';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --builtin',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        builtin: Flags.boolean({
+            description: 'Show only built-in workflows',
+            default: false,
+        }),
+        custom: Flags.boolean({
+            description: 'Show only custom workflows',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(WorkflowList);
+        // Build filter
+        const filter = {};
+        if (flags.builtin)
+            filter.isBuiltin = true;
+        if (flags.custom)
+            filter.isBuiltin = false;
+        const workflows = await this.storage.listWorkflows(Object.keys(filter).length > 0 ? filter : undefined);
+        if (flags.json) {
+            this.log(JSON.stringify(workflows, null, 2));
+            return;
+        }
+        if (workflows.length === 0) {
+            this.log(styles.muted('\nNo workflows found.'));
+            this.log(styles.muted('Create one: prlt workflow create "My Workflow"'));
+            return;
+        }
+        this.log(`\n${styles.emphasis('Workflows')}`);
+        this.log('═'.repeat(60));
+        // Group by builtin vs custom
+        const builtinWorkflows = workflows.filter(w => w.isBuiltin);
+        const customWorkflows = workflows.filter(w => !w.isBuiltin);
+        if (builtinWorkflows.length > 0 && !flags.custom) {
+            this.log(`\n${styles.emphasis('Built-in')}`);
+            this.log('─'.repeat(40));
+            for (const workflow of builtinWorkflows) {
+                this.log(`  ${styles.emphasis(workflow.name)} ${styles.muted(`(${workflow.id})`)}`);
+                if (workflow.description) {
+                    this.log(`    ${styles.muted(workflow.description)}`);
+                }
+            }
+        }
+        if (customWorkflows.length > 0 && !flags.builtin) {
+            this.log(`\n${styles.emphasis('Custom')}`);
+            this.log('─'.repeat(40));
+            for (const workflow of customWorkflows) {
+                this.log(`  ${styles.emphasis(workflow.name)} ${styles.muted(`(${workflow.id})`)}`);
+                if (workflow.description) {
+                    this.log(`    ${styles.muted(workflow.description)}`);
+                }
+            }
+        }
+        this.log('');
+        this.log(styles.muted('View details: prlt workflow view <id>'));
+    }
+}

package/dist/commands/workflow/switch.d.ts

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

package/dist/commands/workflow/switch.js

@@ -0,0 +1,117 @@
+import { Flags, Args } from '@oclif/core';
+import inquirer from 'inquirer';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class WorkflowSwitch extends PMOCommand {
+    static description = 'Switch a project to use a different workflow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> kanban',
+        '<%= config.bin %> <%= command.id %> linear --project my-project',
+        '<%= config.bin %> <%= command.id %> --force  # Skip confirmation',
+    ];
+    static args = {
+        workflow: Args.string({
+            description: 'Workflow ID to switch to',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(WorkflowSwitch);
+        const projectId = await this.requireProject();
+        // Get workflow - prompt for selection if not provided
+        let workflowId = args.workflow;
+        if (!workflowId) {
+            const workflows = await this.storage.listWorkflows();
+            if (workflows.length === 0) {
+                this.error('No workflows found.\nCreate one with: prlt workflow create "Workflow Name"');
+            }
+            const { selectedWorkflow } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedWorkflow',
+                    message: 'Select a workflow:',
+                    choices: workflows.map(w => ({
+                        name: `${w.name}${w.description ? ` - ${w.description}` : ''}`,
+                        value: w.id,
+                    })),
+                }]);
+            workflowId = selectedWorkflow;
+        }
+        // Verify workflow exists
+        const workflow = await this.storage.getWorkflow(workflowId);
+        if (!workflow) {
+            this.error(`Workflow not found: ${workflowId}\nRun 'prlt workflow list' to see available workflows.`);
+        }
+        // Get current project info
+        const project = await this.storage.getProject(projectId);
+        const currentWorkflowId = project?.workflowId;
+        // Check if already using this workflow
+        if (currentWorkflowId === workflowId) {
+            this.log(styles.muted(`Project is already using workflow "${workflow.name}".`));
+            return;
+        }
+        // Get tickets that will be affected
+        const tickets = await this.storage.listTickets(projectId);
+        if (tickets.length > 0 && !flags.force) {
+            const projectName = await this.getProjectName(projectId);
+            this.log(styles.warning(`\nProject "${projectName}" has ${tickets.length} ticket(s).`));
+            this.log(styles.warning('Tickets will be mapped to matching status categories in the new workflow.'));
+            this.log('');
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'confirm',
+                    message: `Switch to workflow "${workflow.name}"?`,
+                    choices: [
+                        { name: 'No', value: false },
+                        { name: 'Yes, switch workflow', value: true },
+                    ],
+                },
+            ]);
+            if (!confirm) {
+                this.log(styles.muted('Cancelled'));
+                return;
+            }
+        }
+        // Get new workflow statuses
+        const newStatuses = await this.storage.listStatuses(workflowId);
+        // Build category -> status mapping for the new workflow
+        const categoryToStatus = {};
+        for (const status of newStatuses) {
+            if (!categoryToStatus[status.category]) {
+                categoryToStatus[status.category] = { id: status.id, name: status.name };
+            }
+        }
+        // Find default status
+        const defaultStatus = newStatuses.find(s => s.isDefault) || newStatuses[0];
+        // Update project workflow_id
+        await this.storage.updateProject(projectId, { workflowId: workflowId });
+        // Migrate tickets to new statuses
+        let migratedCount = 0;
+        for (const ticket of tickets) {
+            // Get old status category
+            const oldCategory = ticket.statusCategory || 'backlog';
+            // Find matching status in new workflow, or use default
+            const newStatus = categoryToStatus[oldCategory] ||
+                (defaultStatus ? { id: defaultStatus.id, name: defaultStatus.name } : null);
+            if (newStatus) {
+                await this.storage.moveTicket(projectId, ticket.id, newStatus.name);
+                migratedCount++;
+            }
+        }
+        const projectName = await this.getProjectName(projectId);
+        this.log(styles.success(`\nSwitched project "${projectName}" to workflow "${styles.emphasis(workflow.name)}"`));
+        if (migratedCount > 0) {
+            this.log(styles.muted(`Migrated ${migratedCount} ticket(s) to matching statuses.`));
+        }
+        this.log('');
+        this.log(styles.muted(`View statuses: prlt status list`));
+    }
+}

package/dist/commands/workflow/view.d.ts

@@ -0,0 +1,16 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class WorkflowView extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    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/workflow/view.js

@@ -0,0 +1,114 @@
+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 WorkflowView extends PMOCommand {
+    static description = 'View details of a workflow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> default',
+        '<%= config.bin %> <%= command.id %>  # Interactive selection',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Workflow ID - prompts with dropdown if not provided',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(WorkflowView);
+        // 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('workflow view', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Get workflow ID - prompt if not provided
+        let workflowId = args.id;
+        if (!workflowId) {
+            const workflows = await this.storage.listWorkflows();
+            if (workflows.length === 0) {
+                return handleError('NO_WORKFLOWS', 'No workflows found.');
+            }
+            // In JSON mode, output workflow selection prompt
+            if (jsonMode) {
+                const workflowChoices = workflows.map(w => ({
+                    name: `${w.name}${w.isBuiltin ? ' (built-in)' : ''}`,
+                    value: w.id,
+                }));
+                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select workflow to view:', workflowChoices), createMetadata('workflow view', flags));
+                return;
+            }
+            const { selectedId } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedId',
+                    message: 'Select workflow to view:',
+                    choices: workflows.map(w => ({
+                        name: `${w.name}${w.isBuiltin ? ' (built-in)' : ''}`,
+                        value: w.id,
+                    })),
+                }]);
+            workflowId = selectedId;
+        }
+        // Get workflow details
+        const workflow = await this.storage.getWorkflow(workflowId);
+        if (!workflow) {
+            return handleError('WORKFLOW_NOT_FOUND', `Workflow not found: ${workflowId}`);
+        }
+        // Get workflow statuses
+        const statuses = await this.storage.listStatuses(workflowId);
+        if (flags.json) {
+            this.log(JSON.stringify({ workflow, statuses }, null, 2));
+            return;
+        }
+        this.log(`\n${styles.emphasis('Workflow:')} ${workflow.name}`);
+        this.log('═'.repeat(60));
+        this.log(styles.muted(`  ID: ${workflow.id}`));
+        if (workflow.description) {
+            this.log(styles.muted(`  Description: ${workflow.description}`));
+        }
+        this.log(styles.muted(`  Type: ${workflow.isBuiltin ? 'Built-in' : 'Custom'}`));
+        this.log(styles.muted(`  Created: ${workflow.createdAt.toLocaleDateString()}`));
+        if (statuses.length > 0) {
+            this.log(`\n${styles.emphasis('Statuses:')}`);
+            this.log('─'.repeat(40));
+            // Group by category
+            const byCategory = new Map();
+            for (const status of statuses) {
+                const existing = byCategory.get(status.category) || [];
+                existing.push(status);
+                byCategory.set(status.category, existing);
+            }
+            const categoryOrder = ['backlog', 'unstarted', 'started', 'completed', 'canceled'];
+            for (const category of categoryOrder) {
+                const categoryStatuses = byCategory.get(category);
+                if (categoryStatuses && categoryStatuses.length > 0) {
+                    this.log(`\n  ${styles.emphasis(category.toUpperCase())}`);
+                    for (const status of categoryStatuses.sort((a, b) => a.position - b.position)) {
+                        const defaultBadge = status.isDefault ? styles.muted(' (default)') : '';
+                        this.log(`    • ${status.name}${defaultBadge}`);
+                    }
+                }
+            }
+        }
+        else {
+            this.log(styles.muted('\nNo statuses defined.'));
+        }
+        this.log('');
+    }
+}

package/dist/commands/workspace/add.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceAdd extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workspace/add.js

@@ -0,0 +1,74 @@
+import { Command, Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { registerWorkspace, normalizePath, isWorkspaceRegistered, getWorkspaceNameFromPath, } from '../../lib/machine-config.js';
+export default class WorkspaceAdd extends Command {
+    static description = 'Register an existing workspace in the machine config';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> /path/to/workspace',
+        '<%= config.bin %> <%= command.id %> . --name my-workspace',
+        '<%= config.bin %> <%= command.id %> ~/projects/my-hq',
+    ];
+    static args = {
+        path: Args.string({
+            description: 'Path to the workspace to register',
+            required: true,
+        }),
+    };
+    static flags = {
+        name: Flags.string({
+            char: 'n',
+            description: 'Custom name for the workspace (defaults to directory basename or workspace config name)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkspaceAdd);
+        // Normalize the path
+        const workspacePath = normalizePath(args.path);
+        // Check if path exists
+        if (!fs.existsSync(workspacePath)) {
+            this.error(`Path does not exist: ${workspacePath}`);
+        }
+        // Check if it's a directory
+        const stats = fs.statSync(workspacePath);
+        if (!stats.isDirectory()) {
+            this.error(`Path is not a directory: ${workspacePath}`);
+        }
+        // Validate it's a valid HQ workspace
+        const configPath = path.join(workspacePath, '.proletariat', 'config.json');
+        if (!fs.existsSync(configPath)) {
+            this.error(`Not a valid workspace: missing .proletariat/config.json\n` +
+                `Run "prlt init" to create a new workspace.`);
+        }
+        // Read config to validate type
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (config.type !== 'hq') {
+                this.error(`Invalid workspace type: ${config.type}\n` +
+                    `Only HQ workspaces can be registered.`);
+            }
+        }
+        catch (error) {
+            this.error(`Failed to read workspace config: ${error.message}`);
+        }
+        // Check if already registered
+        if (isWorkspaceRegistered(workspacePath)) {
+            this.log(chalk.yellow(`Workspace is already registered: ${workspacePath}`));
+            this.log(chalk.gray('Use "prlt workspace use" to set it as active.'));
+            return;
+        }
+        // Determine workspace name
+        const workspaceName = flags.name || getWorkspaceNameFromPath(workspacePath);
+        // Register the workspace
+        try {
+            const entry = registerWorkspace(workspacePath, workspaceName, true);
+            this.log(chalk.green(`Registered workspace: ${entry.name}`));
+            this.log(chalk.gray(`  Path: ${entry.path}`));
+            this.log(chalk.gray(`  Registered at: ${entry.registeredAt}`));
+        }
+        catch (error) {
+            this.error(`Failed to register workspace: ${error.message}`);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class WorkspaceList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}