@proletariat/cli 0.3.24 → 0.3.26

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;
+}

package/dist/commands/support/logs.js

@@ -0,0 +1,247 @@
+import { Flags } from '@oclif/core';
+import * as os from 'node:os';
+import { execSync } from 'node:child_process';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { isMachineOutput, outputSuccessAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class SupportLogs extends PMOCommand {
+    static description = 'Collect diagnostic info for troubleshooting';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --clipboard',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        clipboard: Flags.boolean({
+            description: 'Copy diagnostics to clipboard',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(SupportLogs);
+        const diagnostics = await this.collectDiagnostics();
+        // In JSON mode, return structured object
+        if (isMachineOutput(flags)) {
+            outputSuccessAsJson(diagnostics, createMetadata('support logs', flags));
+            return;
+        }
+        // Format as readable text
+        const text = this.formatDiagnostics(diagnostics);
+        // Copy to clipboard if requested
+        if (flags.clipboard) {
+            const copied = this.copyToClipboard(text);
+            if (copied) {
+                this.log(styles.success('Diagnostics copied to clipboard!'));
+                this.log('');
+            }
+        }
+        // Display diagnostics
+        this.log(text);
+    }
+    async collectDiagnostics() {
+        const diagnostics = {
+            prlt: {
+                version: this.config.version,
+            },
+            node: {
+                version: process.version,
+            },
+            os: {
+                platform: process.platform,
+                release: os.release(),
+                arch: os.arch(),
+            },
+            shell: process.env.SHELL,
+            tools: {
+                gh: this.checkGh(),
+                docker: this.checkDocker(),
+                tmux: this.checkTmux(),
+            },
+        };
+        // Add workspace info if available
+        try {
+            const workspaceInfo = await this.getWorkspaceInfo();
+            if (workspaceInfo) {
+                diagnostics.workspace = workspaceInfo;
+            }
+        }
+        catch {
+            // PMO may not be initialized
+        }
+        return diagnostics;
+    }
+    checkGh() {
+        try {
+            const versionOutput = execSync('gh --version', {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            const version = versionOutput.split('\n')[0]?.replace('gh version ', '').trim();
+            let authenticated = false;
+            try {
+                execSync('gh auth status', { stdio: 'ignore' });
+                authenticated = true;
+            }
+            catch {
+                authenticated = false;
+            }
+            return { installed: true, version, authenticated };
+        }
+        catch {
+            return { installed: false };
+        }
+    }
+    checkDocker() {
+        try {
+            execSync('docker --version', { stdio: 'ignore' });
+            let running = false;
+            try {
+                execSync('docker info', { stdio: 'ignore' });
+                running = true;
+            }
+            catch {
+                running = false;
+            }
+            return { installed: true, running };
+        }
+        catch {
+            return { installed: false };
+        }
+    }
+    checkTmux() {
+        try {
+            const versionOutput = execSync('tmux -V', {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            const version = versionOutput.trim();
+            return { installed: true, version };
+        }
+        catch {
+            return { installed: false };
+        }
+    }
+    async getWorkspaceInfo() {
+        try {
+            const projects = await this.storage.listProjects();
+            let totalTickets = 0;
+            for (const project of projects) {
+                // eslint-disable-next-line no-await-in-loop
+                const tickets = await this.storage.listTickets(project.id);
+                totalTickets += tickets.length;
+            }
+            // Get agents count by checking for agents directory
+            let agentCount = 0;
+            try {
+                const { getWorkspaceInfo } = await import('../../lib/agents/commands.js');
+                const wsInfo = getWorkspaceInfo();
+                agentCount = wsInfo.agents?.length || 0;
+            }
+            catch {
+                // Agents module may not be available
+            }
+            return {
+                path: this.pmoPath,
+                name: projects[0]?.name,
+                repoCount: projects.length,
+                agentCount,
+                ticketCount: totalTickets,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    formatDiagnostics(d) {
+        const lines = [];
+        lines.push(styles.title('Diagnostic Information'));
+        lines.push('');
+        // System info
+        lines.push(styles.header('System'));
+        lines.push(`  prlt version:   ${d.prlt.version}`);
+        lines.push(`  Node version:   ${d.node.version}`);
+        lines.push(`  OS:             ${d.os.platform} ${d.os.release} (${d.os.arch})`);
+        lines.push(`  Shell:          ${d.shell || 'unknown'}`);
+        lines.push('');
+        // Tools
+        lines.push(styles.header('Tools'));
+        // gh
+        if (d.tools.gh.installed) {
+            const authStatus = d.tools.gh.authenticated ? styles.success('authenticated') : styles.warning('not authenticated');
+            lines.push(`  gh CLI:         ${styles.success('installed')} (${d.tools.gh.version}) - ${authStatus}`);
+        }
+        else {
+            lines.push(`  gh CLI:         ${styles.warning('not installed')}`);
+        }
+        // docker
+        if (d.tools.docker.installed) {
+            const runStatus = d.tools.docker.running ? styles.success('running') : styles.warning('not running');
+            lines.push(`  Docker:         ${styles.success('installed')} - ${runStatus}`);
+        }
+        else {
+            lines.push(`  Docker:         ${styles.warning('not installed')}`);
+        }
+        // tmux
+        if (d.tools.tmux.installed) {
+            lines.push(`  tmux:           ${styles.success('installed')} (${d.tools.tmux.version})`);
+        }
+        else {
+            lines.push(`  tmux:           ${styles.muted('not installed')}`);
+        }
+        lines.push('');
+        // Workspace
+        if (d.workspace) {
+            lines.push(styles.header('Workspace'));
+            lines.push(`  Path:           ${d.workspace.path}`);
+            if (d.workspace.name) {
+                lines.push(`  Name:           ${d.workspace.name}`);
+            }
+            lines.push(`  Projects:       ${d.workspace.repoCount ?? 0}`);
+            lines.push(`  Agents:         ${d.workspace.agentCount ?? 0}`);
+            lines.push(`  Tickets:        ${d.workspace.ticketCount ?? 0}`);
+        }
+        else {
+            lines.push(styles.header('Workspace'));
+            lines.push(styles.muted('  No workspace initialized'));
+        }
+        return lines.join('\n');
+    }
+    copyToClipboard(text) {
+        const platform = process.platform;
+        // Strip ANSI codes for clipboard
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional ANSI escape code stripping
+        const plainText = text.replace(/\x1b\[[0-9;]*m/g, '');
+        try {
+            if (platform === 'darwin') {
+                execSync('pbcopy', { input: plainText, encoding: 'utf-8' });
+                return true;
+            }
+            else if (platform === 'linux') {
+                // Try xclip first, then xsel
+                try {
+                    execSync('xclip -selection clipboard', { input: plainText, encoding: 'utf-8' });
+                    return true;
+                }
+                catch {
+                    try {
+                        execSync('xsel --clipboard --input', { input: plainText, encoding: 'utf-8' });
+                        return true;
+                    }
+                    catch {
+                        this.log(styles.warning('Install xclip or xsel to enable clipboard support.'));
+                        return false;
+                    }
+                }
+            }
+            else if (platform === 'win32') {
+                execSync('clip', { input: plainText, encoding: 'utf-8' });
+                return true;
+            }
+        }
+        catch {
+            this.log(styles.warning('Could not copy to clipboard.'));
+        }
+        return false;
+    }
+}