@proletariat/cli 0.1.4 → 0.3.0

package/dist/commands/autocomplete/setup.js

@@ -0,0 +1,154 @@
+import { Command, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import chalk from 'chalk';
+export default class AutocompleteSetup extends Command {
+    static description = 'Auto-detect shell and set up autocomplete';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --install',
+        '<%= config.bin %> <%= command.id %> --shell zsh',
+    ];
+    static flags = {
+        install: Flags.boolean({
+            char: 'i',
+            description: 'Automatically install to shell config file',
+            default: false,
+        }),
+        shell: Flags.string({
+            char: 's',
+            description: 'Override shell detection (zsh, bash, powershell)',
+            options: ['zsh', 'bash', 'powershell'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AutocompleteSetup);
+        const shell = flags.shell || this.detectShell();
+        if (shell === 'unknown') {
+            this.log(chalk.yellow('Could not detect shell type.'));
+            this.log(chalk.dim('Use --shell to specify: prlt autocomplete setup --shell zsh'));
+            return;
+        }
+        this.log(chalk.cyan(`Detected shell: ${shell}`));
+        this.log('');
+        const { configFile, snippet } = this.getShellConfig(shell);
+        if (flags.install) {
+            await this.installAutocomplete(shell, configFile, snippet);
+        }
+        else {
+            this.showInstructions(shell, configFile, snippet);
+        }
+    }
+    detectShell() {
+        // Check for PowerShell first (works on all platforms)
+        if (process.env.PSModulePath) {
+            return 'powershell';
+        }
+        // Check $SHELL environment variable (Unix/macOS)
+        const shellEnv = process.env.SHELL || '';
+        if (shellEnv.includes('zsh')) {
+            return 'zsh';
+        }
+        if (shellEnv.includes('bash')) {
+            return 'bash';
+        }
+        // Check $0 or parent process on Windows
+        if (process.platform === 'win32') {
+            const comspec = process.env.COMSPEC || '';
+            if (comspec.toLowerCase().includes('powershell')) {
+                return 'powershell';
+            }
+        }
+        // Default based on platform
+        if (process.platform === 'darwin') {
+            return 'zsh'; // macOS default since Catalina
+        }
+        return 'unknown';
+    }
+    getShellConfig(shell) {
+        const home = os.homedir();
+        switch (shell) {
+            case 'zsh':
+                return {
+                    configFile: path.join(home, '.zshrc'),
+                    snippet: 'eval "$(prlt autocomplete:script zsh)"',
+                };
+            case 'bash':
+                // Use .bashrc on Linux, .bash_profile on macOS
+                const bashConfig = process.platform === 'darwin'
+                    ? path.join(home, '.bash_profile')
+                    : path.join(home, '.bashrc');
+                return {
+                    configFile: bashConfig,
+                    snippet: 'eval "$(prlt autocomplete:script bash)"',
+                };
+            case 'powershell':
+                // PowerShell profile location varies
+                const psProfile = process.env.PROFILE ||
+                    path.join(home, 'Documents', 'PowerShell', 'Microsoft.PowerShell_profile.ps1');
+                return {
+                    configFile: psProfile,
+                    snippet: 'prlt autocomplete:script powershell | Out-String | Invoke-Expression',
+                };
+            default:
+                return { configFile: '', snippet: '' };
+        }
+    }
+    showInstructions(shell, configFile, snippet) {
+        this.log(chalk.bold('To enable autocomplete, add this to your shell config:'));
+        this.log('');
+        this.log(chalk.dim(`  # File: ${configFile}`));
+        this.log(chalk.green(`  ${snippet}`));
+        this.log('');
+        this.log(chalk.dim('Then restart your shell or run:'));
+        if (shell === 'powershell') {
+            this.log(chalk.cyan(`  . $PROFILE`));
+        }
+        else {
+            this.log(chalk.cyan(`  source ${configFile}`));
+        }
+        this.log('');
+        this.log(chalk.dim('Or run with --install to add automatically:'));
+        this.log(chalk.cyan('  prlt autocomplete setup --install'));
+    }
+    async installAutocomplete(shell, configFile, snippet) {
+        // Check if config file exists
+        const configExists = fs.existsSync(configFile);
+        if (configExists) {
+            // Check if already installed
+            const content = fs.readFileSync(configFile, 'utf-8');
+            if (content.includes('prlt autocomplete')) {
+                this.log(chalk.yellow('Autocomplete already configured in ' + configFile));
+                return;
+            }
+        }
+        // Create directory if needed (for PowerShell profile)
+        const configDir = path.dirname(configFile);
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        // Append to config file
+        const addition = `\n# Proletariat CLI autocomplete\n${snippet}\n`;
+        fs.appendFileSync(configFile, addition);
+        this.log(chalk.green(`✅ Autocomplete installed to ${configFile}`));
+        this.log('');
+        this.log(chalk.dim('Restart your shell or run:'));
+        if (shell === 'powershell') {
+            this.log(chalk.cyan(`  . $PROFILE`));
+        }
+        else {
+            this.log(chalk.cyan(`  source ${configFile}`));
+        }
+        // Also refresh the autocomplete cache
+        this.log('');
+        this.log(chalk.dim('Refreshing autocomplete cache...'));
+        try {
+            await this.config.runCommand('autocomplete', [shell, '--refresh-cache']);
+            this.log(chalk.green('✅ Autocomplete cache refreshed'));
+        }
+        catch {
+            this.log(chalk.dim('Run "prlt autocomplete --refresh-cache" to update completions'));
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class Board extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    execute(): Promise<void>;
+    private viewBoard;
+    private outputTicketCompact;
+    private outputTicketFull;
+    private showMarkdown;
+    private exportMarkdown;
+    private syncFromMarkdown;
+    private openInObsidian;
+}

package/dist/commands/board/index.js

@@ -0,0 +1,255 @@
+import * as fs from 'node:fs';
+import { execSync } from 'node:child_process';
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { parseBoard, findAddedTickets, findRemovedTickets, findModifiedTickets, getBoardPath, PMOCommand, pmoBaseFlags, } from '../../lib/pmo/index.js';
+import { styles, formatPriority, formatCategory, getColumnStyle, getColumnEmoji, divider, } from '../../lib/styles.js';
+import { shouldOutputJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class Board extends PMOCommand {
+    static description = 'Interactive menu for board operations';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(Board);
+        // Board operations require project context
+        const projectId = await this.requireProject();
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Define choices once, use for both JSON and interactive modes
+        const menuChoices = [
+            { name: 'View board in terminal', value: 'view' },
+            { name: 'Open board in Obsidian', value: 'open' },
+            { name: 'Show as markdown', value: 'markdown' },
+            { name: 'Export board', value: 'export' },
+            { name: 'Sync board', value: 'sync' },
+            { name: 'Watch for changes', value: 'watch' },
+            { name: 'Cancel', value: 'cancel' },
+        ];
+        const projectName = await this.getProjectName(projectId);
+        const message = `Board Operations - ${projectName} - What would you like to do?`;
+        // In JSON mode, output menu prompt
+        if (jsonMode) {
+            outputPromptAsJson(buildPromptConfig('list', 'action', message, menuChoices), createMetadata('board', flags));
+            return;
+        }
+        // Show interactive menu (with separator before Cancel)
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message: '📋 ' + message,
+                choices: [
+                    ...menuChoices.slice(0, -1),
+                    new inquirer.Separator(),
+                    menuChoices[menuChoices.length - 1],
+                ],
+            }]);
+        if (action === 'cancel') {
+            return;
+        }
+        switch (action) {
+            case 'view':
+                await this.viewBoard(projectId, { all: false, compact: false });
+                break;
+            case 'open':
+                this.openInObsidian();
+                break;
+            case 'markdown':
+                await this.showMarkdown(projectId);
+                break;
+            case 'export':
+                await this.exportMarkdown(projectId);
+                break;
+            case 'sync':
+                await this.syncFromMarkdown(projectId, { force: false, 'dry-run': false });
+                break;
+            case 'watch':
+                this.log(styles.info('To watch for changes, run: prlt board watch'));
+                break;
+        }
+    }
+    async viewBoard(projectId, flags) {
+        const board = await this.storage.getBoard(projectId);
+        // Header
+        this.log(styles.title(`\n${board.name}`));
+        this.log(styles.muted(`Storage: SQLite`));
+        this.log(styles.muted('═'.repeat(60)));
+        // Display ALL columns (always show empty ones too)
+        for (const column of board.columns) {
+            const headerColor = getColumnStyle(column.name);
+            const emoji = getColumnEmoji(column.name);
+            this.log(headerColor(`\n${emoji} ${column.name} (${column.tickets.length})`));
+            this.log(divider(50));
+            if (column.tickets.length === 0) {
+                this.log(styles.muted('  (empty)'));
+                continue;
+            }
+            // Sort tickets by position
+            const sortedTickets = [...column.tickets].sort((a, b) => (a.position || 0) - (b.position || 0));
+            for (const ticket of sortedTickets) {
+                if (flags.compact) {
+                    this.outputTicketCompact(ticket);
+                }
+                else {
+                    this.outputTicketFull(ticket);
+                }
+            }
+        }
+        // Summary
+        const totalTickets = board.columns.reduce((sum, col) => sum + col.tickets.length, 0);
+        this.log(styles.muted('\n' + '═'.repeat(60)));
+        this.log(styles.emphasis(`Total: ${totalTickets} ticket${totalTickets === 1 ? '' : 's'}`));
+        // Per-column summary (only non-empty)
+        const summary = board.columns
+            .filter(col => col.tickets.length > 0)
+            .map(col => `${col.name}: ${col.tickets.length}`)
+            .join(' | ');
+        if (summary) {
+            this.log(styles.primary(summary));
+        }
+        this.log(styles.muted('\nCommands:'));
+        this.log(styles.primary('  prlt ticket create     ') + styles.muted('Create a new ticket'));
+        this.log(styles.primary('  prlt ticket list       ') + styles.muted('List all tickets'));
+        this.log(styles.primary('  prlt ticket move <id>  ') + styles.muted('Move a ticket'));
+    }
+    outputTicketCompact(ticket) {
+        const priority = formatPriority(ticket.priority);
+        this.log(`  ${styles.code(ticket.id)}: ${ticket.title} ${priority}`);
+    }
+    outputTicketFull(ticket) {
+        const priority = formatPriority(ticket.priority);
+        const category = formatCategory(ticket.category);
+        this.log(`  ${styles.code(ticket.id)} ${ticket.title} ${priority} ${category}`);
+        if (ticket.description) {
+            const shortDesc = ticket.description.split('\n')[0].substring(0, 55);
+            this.log(styles.muted(`     ${shortDesc}${ticket.description.length > 55 ? '...' : ''}`));
+        }
+        if (ticket.subtasks.length > 0) {
+            const done = ticket.subtasks.filter(s => s.done).length;
+            const total = ticket.subtasks.length;
+            const progress = Math.round((done / total) * 100);
+            this.log(styles.muted(`     Subtasks: ${done}/${total} (${progress}%)`));
+        }
+        if (ticket.specId) {
+            this.log(styles.muted(`     Spec: ${ticket.specId}`));
+        }
+    }
+    async showMarkdown(projectId) {
+        const markdown = await this.storage.getBoardMarkdown(projectId);
+        this.log(markdown);
+    }
+    async exportMarkdown(projectId) {
+        const markdown = await this.storage.getBoardMarkdown(projectId);
+        const boardPath = getBoardPath(this.pmoPath, projectId);
+        fs.writeFileSync(boardPath, markdown);
+        this.log(chalk.green(`✅ Exported board to ${boardPath}`));
+    }
+    async syncFromMarkdown(projectId, flags) {
+        const boardPath = getBoardPath(this.pmoPath, projectId);
+        if (!fs.existsSync(boardPath)) {
+            this.error('board.md not found. Run "prlt board export" first to create it.');
+        }
+        // Parse markdown file
+        const markdown = fs.readFileSync(boardPath, 'utf-8');
+        const markdownBoard = parseBoard(markdown);
+        const sqliteBoard = await this.storage.getBoard(projectId);
+        // Find differences
+        const added = findAddedTickets(sqliteBoard, markdownBoard);
+        const removed = findRemovedTickets(sqliteBoard, markdownBoard);
+        const modified = findModifiedTickets(sqliteBoard, markdownBoard);
+        // Check if anything changed
+        if (added.length === 0 && removed.length === 0 && modified.length === 0) {
+            this.log(chalk.green('✅ Database is already in sync with board.md'));
+            return;
+        }
+        // Display changes
+        this.log(chalk.bold.cyan(`\n📊 Changes detected in board.md (to sync to database):\n`));
+        if (added.length > 0) {
+            this.log(chalk.green.bold(`  + ${added.length} ticket(s) to add:`));
+            for (const ticket of added) {
+                this.log(chalk.green(`    + ${ticket.id}: ${ticket.title} (${ticket.statusName})`));
+            }
+        }
+        if (removed.length > 0) {
+            this.log(chalk.red.bold(`  - ${removed.length} ticket(s) to remove:`));
+            for (const ticket of removed) {
+                this.log(chalk.red(`    - ${ticket.id}: ${ticket.title}`));
+            }
+        }
+        if (modified.length > 0) {
+            this.log(chalk.yellow.bold(`  ~ ${modified.length} ticket(s) to update:`));
+            for (const { old: oldTicket, new: newTicket } of modified) {
+                this.log(chalk.yellow(`    ~ ${newTicket.id}: ${newTicket.title}`));
+                if (oldTicket.statusName !== newTicket.statusName) {
+                    this.log(styles.muted(`        status: ${oldTicket.statusName} → ${newTicket.statusName}`));
+                }
+                if (oldTicket.priority !== newTicket.priority) {
+                    this.log(styles.muted(`        priority: ${oldTicket.priority || '(none)'} → ${newTicket.priority || '(none)'}`));
+                }
+                if (oldTicket.title !== newTicket.title) {
+                    this.log(styles.muted(`        title: ${oldTicket.title} → ${newTicket.title}`));
+                }
+            }
+        }
+        this.log('');
+        // Dry run - just show changes
+        if (flags['dry-run']) {
+            this.log(styles.muted('Dry run - no changes applied.'));
+            return;
+        }
+        // Confirm before applying
+        if (!flags.force) {
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: 'Apply these changes to the database?',
+                    choices: [
+                        { name: 'Yes, apply changes', value: true },
+                        { name: 'No, cancel', value: false },
+                    ],
+                    default: 0,
+                }]);
+            if (!confirm) {
+                this.log(chalk.yellow('Sync cancelled.'));
+                return;
+            }
+        }
+        this.log(chalk.blue('\nSyncing from board.md...'));
+        // Rebuild database from markdown (cleaner than incremental updates)
+        this.storage.rebuildFromBoard(markdownBoard);
+        // Update cache metadata with file mtime
+        const stats = fs.statSync(boardPath);
+        this.storage.setCacheMetadata({
+            boardMtime: stats.mtimeMs,
+            cacheBuiltAt: Date.now(),
+        });
+        this.log(chalk.green('\n✅ Database synced from board.md!'));
+    }
+    openInObsidian() {
+        const platform = process.platform;
+        try {
+            if (platform === 'darwin') {
+                execSync(`open "obsidian://open?path=${encodeURIComponent(this.pmoPath)}"`);
+            }
+            else if (platform === 'linux') {
+                execSync(`xdg-open "obsidian://open?path=${encodeURIComponent(this.pmoPath)}"`);
+            }
+            else if (platform === 'win32') {
+                execSync(`start "" "obsidian://open?path=${encodeURIComponent(this.pmoPath)}"`);
+            }
+            this.log(styles.success('✅ Opened PMO in Obsidian'));
+        }
+        catch {
+            this.log(styles.warning('Could not open Obsidian. Make sure it is installed.'));
+            this.log(styles.muted(`PMO location: ${this.pmoPath}`));
+        }
+    }
+}

package/dist/commands/board/watch.d.ts

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

package/dist/commands/board/watch.js

@@ -0,0 +1,52 @@
+import { Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import chalk from 'chalk';
+import { PMOCommand, pmoBaseFlags, runWatcherForeground } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+export default class BoardWatch extends PMOCommand {
+    static description = 'Watch board.md for changes and auto-sync to SQLite';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --debounce 1000',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        debounce: Flags.integer({
+            char: 'd',
+            description: 'Debounce delay in milliseconds',
+            default: 500,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(BoardWatch);
+        // Load PMO config
+        const configPath = path.join(this.pmoPath, 'config.json');
+        if (!fs.existsSync(configPath)) {
+            this.error('PMO config not found. Run "prlt pmo init" first.');
+        }
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        // Header
+        this.log(styles.title('\n🔄 Board Watcher'));
+        this.log(styles.muted(`Storage: ${config.storage} | Debounce: ${flags.debounce}ms`));
+        this.log(styles.muted(`Path: ${this.pmoPath}`));
+        this.log(styles.muted('Press Ctrl+C to stop\n'));
+        // Run watcher (blocks until SIGINT/SIGTERM)
+        await runWatcherForeground(this.pmoPath, config.storage, {
+            debounceMs: flags.debounce,
+            logger: (msg) => {
+                const timestamp = new Date().toLocaleTimeString();
+                this.log(styles.muted(`[${timestamp}]`) + ' ' + msg);
+            },
+            onSync: () => {
+                // Already logged by logger
+            },
+            onError: (error) => {
+                this.log(chalk.red(`Error: ${error.message}`));
+            },
+        });
+    }
+}

package/dist/commands/branch/create.d.ts

@@ -0,0 +1,50 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class BranchCreate extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        ticket: 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>;
+        owner: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'empty-commit': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'no-switch': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'from-origin': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    /**
+     * Get the default owner name.
+     * Priority: workspace config > GitHub username > git user.name
+     */
+    private getDefaultOwnerName;
+    /**
+     * Create branch from ticket ID with defaults (non-interactive).
+     */
+    private createFromTicketId;
+    private runWizard;
+    /**
+     * Quick wizard - just select ticket, auto-generate with defaults.
+     */
+    private runTicketQuickWizard;
+    /**
+     * Wizard flow for creating branch from a ticket.
+     */
+    private runTicketWizard;
+    /**
+     * Wizard flow for creating a custom branch (no ticket).
+     */
+    private runCustomWizard;
+    /**
+     * Prompt user to select a branch from local or remote branches.
+     */
+    private promptForBranch;
+}