@proletariat/cli 0.3.24 → 0.3.25

package/dist/commands/spec/edit.js

@@ -4,6 +4,7 @@ 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';
+import { multiLineInput } from '../../lib/multiline-input.js';
 export default class SpecEdit extends PMOCommand {
     static description = 'Edit an existing spec';
     static examples = [
@@ -114,6 +115,25 @@ export default class SpecEdit extends PMOCommand {
         const hasFlags = flags.title || flags.status || flags.type || flags.problem ||
             flags.solution || flags.decisions;
         if (flags.interactive || !hasFlags) {
+            // In JSON mode without flags, output a form prompt instead of interactive prompts
+            if (jsonMode) {
+                const { outputPromptAsJson, buildFormPromptConfig } = await import('../../lib/prompt-json.js');
+                const formConfig = buildFormPromptConfig([
+                    { type: 'input', name: 'title', message: 'Title:', default: spec.title },
+                    { type: 'list', name: 'status', message: 'Status:', choices: statusChoices, default: spec.status },
+                    { type: 'list', name: 'type', message: 'Type:', choices: typeChoices, default: spec.type || '' },
+                    { type: 'multiline', name: 'problem', message: 'Problem statement:', default: spec.problem || '' },
+                    { type: 'multiline', name: 'solution', message: 'Solution:', default: spec.solution || '' },
+                    { type: 'multiline', name: 'decisions', message: 'Design decisions:', default: spec.decisions || '' },
+                ]);
+                formConfig.context = {
+                    hint: `Edit spec with: prlt spec edit ${specId} --title "..." --problem "..." --json`,
+                    specId,
+                    currentValues: { title: spec.title, status: spec.status, type: spec.type, problem: spec.problem, solution: spec.solution, decisions: spec.decisions },
+                };
+                outputPromptAsJson(formConfig, createMetadata('spec edit', flags));
+                return; // outputPromptAsJson exits, but TypeScript doesn't know
+            }
             // Interactive mode - prompt for editable fields
             updates = await this.promptForEdits(spec, typeChoices, statusChoices);
         }
@@ -162,7 +182,8 @@ export default class SpecEdit extends PMOCommand {
         this.log(styles.muted(`View spec: prlt spec view ${updatedSpec.id}`));
     }
     async promptForEdits(spec, typeChoices, statusChoices) {
-        const answers = await inquirer.prompt([
+        // First prompt for title, status, and type
+        const basicAnswers = await inquirer.prompt([
             {
                 type: 'input',
                 name: 'title',
@@ -184,48 +205,57 @@ export default class SpecEdit extends PMOCommand {
                 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,
-            },
         ]);
+        // Prompt for problem statement using multiline input
+        const problemResult = await multiLineInput({
+            message: 'Problem statement:',
+            default: spec.problem || '',
+            hint: 'Describe the problem this spec addresses. Ctrl+D to finish, Ctrl+C to cancel',
+        });
+        if (problemResult.cancelled) {
+            throw new Error('Edit cancelled');
+        }
+        // Prompt for solution using multiline input
+        const solutionResult = await multiLineInput({
+            message: 'Solution:',
+            default: spec.solution || '',
+            hint: 'Describe the proposed solution. Ctrl+D to finish, Ctrl+C to cancel',
+        });
+        if (solutionResult.cancelled) {
+            throw new Error('Edit cancelled');
+        }
+        // Prompt for decisions using multiline input
+        const decisionsResult = await multiLineInput({
+            message: 'Design decisions:',
+            default: spec.decisions || '',
+            hint: 'Document key design decisions. Ctrl+D to finish, Ctrl+C to cancel',
+        });
+        if (decisionsResult.cancelled) {
+            throw new Error('Edit cancelled');
+        }
         // Build updates object with only changed fields
         const updates = {};
-        if (answers.title !== spec.title) {
-            updates.title = answers.title;
+        if (basicAnswers.title !== spec.title) {
+            updates.title = basicAnswers.title;
         }
-        if (answers.status !== spec.status) {
-            updates.status = answers.status;
+        if (basicAnswers.status !== spec.status) {
+            updates.status = basicAnswers.status;
         }
-        const newType = answers.type === '' ? undefined : answers.type;
+        const newType = basicAnswers.type === '' ? undefined : basicAnswers.type;
         if (newType !== spec.type) {
             updates.type = newType;
         }
-        if (answers.problem !== (spec.problem || '')) {
-            updates.problem = answers.problem || undefined;
+        if (problemResult.value !== (spec.problem || '')) {
+            // Preserve empty string to allow clearing the field
+            updates.problem = problemResult.value;
         }
-        if (answers.solution !== (spec.solution || '')) {
-            updates.solution = answers.solution || undefined;
+        if (solutionResult.value !== (spec.solution || '')) {
+            // Preserve empty string to allow clearing the field
+            updates.solution = solutionResult.value;
         }
-        if (answers.decisions !== (spec.decisions || '')) {
-            updates.decisions = answers.decisions || undefined;
+        if (decisionsResult.value !== (spec.decisions || '')) {
+            // Preserve empty string to allow clearing the field
+            updates.decisions = decisionsResult.value;
         }
         return updates;
     }

package/dist/commands/support/book.d.ts

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

package/dist/commands/support/book.js

@@ -0,0 +1,54 @@
+import { Command } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import { styles } from '../../lib/styles.js';
+import { isMachineOutput, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { SUPPORT_URLS } from './index.js';
+export default class SupportBook extends Command {
+    static description = 'Book a call for support';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(SupportBook);
+        const url = SUPPORT_URLS.calcom;
+        // In JSON mode, return the URL
+        if (isMachineOutput(flags)) {
+            outputSuccessAsJson({
+                action: 'book',
+                url,
+                message: 'Book a call for support',
+            }, createMetadata('support book', flags));
+            return;
+        }
+        // Open the URL in the browser
+        this.openUrl(url);
+        this.log(styles.success('Opening cal.com booking page...'));
+        this.log(styles.muted(`URL: ${url}`));
+    }
+    openUrl(url) {
+        const platform = process.platform;
+        try {
+            if (platform === 'darwin') {
+                execSync(`open "${url}"`);
+            }
+            else if (platform === 'linux') {
+                execSync(`xdg-open "${url}"`);
+            }
+            else if (platform === 'win32') {
+                execSync(`start "" "${url}"`);
+            }
+            else {
+                throw new Error(`Unsupported platform: ${platform}`);
+            }
+        }
+        catch {
+            this.log(styles.warning('Could not open browser automatically.'));
+            this.log(styles.info(`Please visit: ${url}`));
+        }
+    }
+}

package/dist/commands/support/discord.d.ts

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

package/dist/commands/support/discord.js

@@ -0,0 +1,54 @@
+import { Command } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import { styles } from '../../lib/styles.js';
+import { isMachineOutput, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { SUPPORT_URLS } from './index.js';
+export default class SupportDiscord extends Command {
+    static description = 'Join the Discord community';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(SupportDiscord);
+        const url = SUPPORT_URLS.discord;
+        // In JSON mode, return the URL
+        if (isMachineOutput(flags)) {
+            outputSuccessAsJson({
+                action: 'discord',
+                url,
+                message: 'Join Discord community',
+            }, createMetadata('support discord', flags));
+            return;
+        }
+        // Open the URL in the browser
+        this.openUrl(url);
+        this.log(styles.success('Opening Discord invite...'));
+        this.log(styles.muted(`URL: ${url}`));
+    }
+    openUrl(url) {
+        const platform = process.platform;
+        try {
+            if (platform === 'darwin') {
+                execSync(`open "${url}"`);
+            }
+            else if (platform === 'linux') {
+                execSync(`xdg-open "${url}"`);
+            }
+            else if (platform === 'win32') {
+                execSync(`start "" "${url}"`);
+            }
+            else {
+                throw new Error(`Unsupported platform: ${platform}`);
+            }
+        }
+        catch {
+            this.log(styles.warning('Could not open browser automatically.'));
+            this.log(styles.info(`Please visit: ${url}`));
+        }
+    }
+}

package/dist/commands/support/docs.d.ts

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

package/dist/commands/support/docs.js

@@ -0,0 +1,54 @@
+import { Command } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import { styles } from '../../lib/styles.js';
+import { isMachineOutput, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { SUPPORT_URLS } from './index.js';
+export default class SupportDocs extends Command {
+    static description = 'Open documentation in browser';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(SupportDocs);
+        const url = SUPPORT_URLS.docs;
+        // In JSON mode, return the URL
+        if (isMachineOutput(flags)) {
+            outputSuccessAsJson({
+                action: 'docs',
+                url,
+                message: 'Open documentation',
+            }, createMetadata('support docs', flags));
+            return;
+        }
+        // Open the URL in the browser
+        this.openUrl(url);
+        this.log(styles.success('Opening documentation...'));
+        this.log(styles.muted(`URL: ${url}`));
+    }
+    openUrl(url) {
+        const platform = process.platform;
+        try {
+            if (platform === 'darwin') {
+                execSync(`open "${url}"`);
+            }
+            else if (platform === 'linux') {
+                execSync(`xdg-open "${url}"`);
+            }
+            else if (platform === 'win32') {
+                execSync(`start "" "${url}"`);
+            }
+            else {
+                throw new Error(`Unsupported platform: ${platform}`);
+            }
+        }
+        catch {
+            this.log(styles.warning('Could not open browser automatically.'));
+            this.log(styles.info(`Please visit: ${url}`));
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+/**
+ * Support URLs - centralized for consistency
+ */
+export declare const SUPPORT_URLS: {
+    calcom: string;
+    discord: string;
+    issues: string;
+    docs: string;
+    npm: string;
+};
+export default class Support extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/support/index.js

@@ -0,0 +1,81 @@
+import { Command } from '@oclif/core';
+import { FlagResolver, shouldOutputJson } from '../../lib/flags/index.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+/**
+ * Support URLs - centralized for consistency
+ */
+export const SUPPORT_URLS = {
+    calcom: 'https://cal.com/chrismcdermut',
+    discord: 'https://discord.gg/tmZyjNNSvw',
+    issues: 'https://github.com/chrismcdermut/proletariat/issues',
+    docs: 'https://github.com/chrismcdermut/proletariat#readme',
+    npm: 'https://www.npmjs.com/package/@proletariat/cli',
+};
+export default class Support extends Command {
+    static description = 'Get help, troubleshoot, and connect with the community';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> book',
+        '<%= config.bin %> <%= command.id %> docs',
+        '<%= config.bin %> <%= command.id %> discord',
+        '<%= config.bin %> <%= command.id %> issues',
+        '<%= config.bin %> <%= command.id %> logs',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(Support);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Use FlagResolver for the menu selection
+        const resolver = new FlagResolver({
+            commandName: 'support',
+            baseCommand: 'prlt support',
+            jsonMode,
+            flags: {},
+        });
+        // Add prompt for action selection
+        resolver.addPrompt({
+            flagName: 'action',
+            type: 'list',
+            message: 'How can we help?',
+            choices: () => [
+                { name: 'Book a call', value: 'book', command: 'prlt support book --json' },
+                { name: 'Documentation', value: 'docs', command: 'prlt support docs --json' },
+                { name: 'Report a bug', value: 'bug', command: 'prlt feedback submit --category bug --json' },
+                { name: 'Request a feature', value: 'feature', command: 'prlt feedback submit --category feature --json' },
+                { name: 'Join Discord', value: 'discord', command: 'prlt support discord --json' },
+                { name: 'Browse issues', value: 'issues', command: 'prlt support issues --json' },
+                { name: 'Collect diagnostics', value: 'logs', command: 'prlt support logs --json' },
+            ],
+            skipAutoCommand: true,
+        });
+        // Resolve - in JSON mode this outputs the prompt and exits
+        const resolved = await resolver.resolve();
+        // Execute the selected action
+        switch (resolved.action) {
+            case 'book':
+                await this.config.runCommand('support book');
+                break;
+            case 'docs':
+                await this.config.runCommand('support docs');
+                break;
+            case 'bug':
+                await this.config.runCommand('feedback submit', ['--category', 'bug']);
+                break;
+            case 'feature':
+                await this.config.runCommand('feedback submit', ['--category', 'feature']);
+                break;
+            case 'discord':
+                await this.config.runCommand('support discord');
+                break;
+            case 'issues':
+                await this.config.runCommand('support issues');
+                break;
+            case 'logs':
+                await this.config.runCommand('support logs');
+                break;
+        }
+    }
+}

package/dist/commands/support/issues.d.ts

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

package/dist/commands/support/issues.js

@@ -0,0 +1,77 @@
+import { Command, Flags } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import { styles } from '../../lib/styles.js';
+import { isMachineOutput, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { SUPPORT_URLS } from './index.js';
+export default class SupportIssues extends Command {
+    static description = 'Browse GitHub Issues';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --browser',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+        browser: Flags.boolean({
+            description: 'Open issues in browser (default behavior)',
+            default: true,
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SupportIssues);
+        const url = SUPPORT_URLS.issues;
+        // In JSON mode, return the URL
+        if (isMachineOutput(flags)) {
+            outputSuccessAsJson({
+                action: 'issues',
+                url,
+                message: 'Browse GitHub Issues',
+            }, createMetadata('support issues', flags));
+            return;
+        }
+        // Open in browser (default)
+        if (flags.browser) {
+            this.openUrl(url);
+            this.log(styles.success('Opening GitHub Issues...'));
+            this.log(styles.muted(`URL: ${url}`));
+        }
+        else {
+            // List issues via gh CLI when --no-browser is set
+            try {
+                const output = execSync('gh issue list --repo chrismcdermut/proletariat', {
+                    encoding: 'utf-8',
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                this.log(styles.header('Open Issues'));
+                this.log(output.trim() || styles.muted('No open issues found.'));
+            }
+            catch {
+                this.log(styles.warning('Could not list issues via gh CLI.'));
+                this.log(styles.info(`Please visit: ${url}`));
+            }
+        }
+    }
+    openUrl(url) {
+        const platform = process.platform;
+        try {
+            if (platform === 'darwin') {
+                execSync(`open "${url}"`);
+            }
+            else if (platform === 'linux') {
+                execSync(`xdg-open "${url}"`);
+            }
+            else if (platform === 'win32') {
+                execSync(`start "" "${url}"`);
+            }
+            else {
+                throw new Error(`Unsupported platform: ${platform}`);
+            }
+        }
+        catch {
+            this.log(styles.warning('Could not open browser automatically.'));
+            this.log(styles.info(`Please visit: ${url}`));
+        }
+    }
+}

package/dist/commands/support/logs.d.ts

@@ -0,0 +1,18 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SupportLogs extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        clipboard: 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 execute(): Promise<void>;
+    private collectDiagnostics;
+    private checkGh;
+    private checkDocker;
+    private checkTmux;
+    private getWorkspaceInfo;
+    private formatDiagnostics;
+    private copyToClipboard;
+}