@proletariat/cli 0.2.0 → 0.3.0

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

@@ -0,0 +1,17 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class BranchList extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, 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>;
+    private outputTable;
+    private outputCompact;
+}

package/dist/commands/branch/list.js

@@ -0,0 +1,120 @@
+import { Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { BRANCH_TYPES, listBranches, isGitRepo, } from '../../lib/branch/index.js';
+export default class BranchList extends PMOCommand {
+    static description = 'List branches with conventional naming information';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> --type feat',
+        '<%= config.bin %> <%= command.id %> --format compact',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        all: Flags.boolean({
+            char: 'a',
+            description: 'Include remote branches',
+            default: false,
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'Filter by branch type',
+            options: Object.keys(BRANCH_TYPES),
+        }),
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: ['table', 'compact', 'json'],
+            default: 'table',
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(BranchList);
+        // Check if in git repo
+        if (!isGitRepo()) {
+            this.error('Not in a git repository.');
+        }
+        // Get branches
+        let branches = listBranches(undefined, flags.all);
+        // Filter by type
+        if (flags.type) {
+            branches = branches.filter((b) => b.type === flags.type);
+        }
+        if (branches.length === 0) {
+            if (flags.type) {
+                this.log(styles.muted(`\nNo ${flags.type} branches found.\n`));
+            }
+            else {
+                this.log(styles.muted('\nNo branches found.\n'));
+            }
+            return;
+        }
+        // Output based on format
+        switch (flags.format) {
+            case 'json':
+                this.log(JSON.stringify(branches, null, 2));
+                break;
+            case 'compact':
+                this.outputCompact(branches);
+                break;
+            case 'table':
+            default:
+                this.outputTable(branches);
+                break;
+        }
+    }
+    outputTable(branches) {
+        this.log('');
+        this.log(styles.header(`🌿 Branches (${branches.length})`));
+        this.log('');
+        // Header
+        this.log(styles.muted(padEnd('Name', 35) +
+            padEnd('Type', 8) +
+            padEnd('Owner', 12) +
+            padEnd('Description', 25) +
+            'Status'));
+        this.log('─'.repeat(90));
+        // Rows
+        for (const branch of branches) {
+            const marker = branch.current ? '* ' : '  ';
+            const nameStyle = branch.current ? styles.success : (s) => s;
+            const typeDisplay = branch.type || '-';
+            const ownerDisplay = branch.owner || '-';
+            const descDisplay = branch.description || '-';
+            let status = 'local';
+            if (branch.tracking) {
+                status = `tracking ${branch.tracking}`;
+            }
+            if (branch.current) {
+                status = 'current';
+            }
+            this.log(marker +
+                nameStyle(padEnd(branch.name.substring(0, 33), 33)) +
+                padEnd(typeDisplay, 8) +
+                padEnd(ownerDisplay.substring(0, 10), 12) +
+                padEnd(descDisplay.substring(0, 23), 25) +
+                styles.muted(status));
+        }
+        this.log('');
+        this.log(styles.muted('Legend: * = current branch'));
+        this.log('');
+    }
+    outputCompact(branches) {
+        this.log('');
+        for (const branch of branches) {
+            const marker = branch.current ? '* ' : '  ';
+            const icon = branch.type ? '🌿' : '  ';
+            const typeInfo = branch.type ? ` (${branch.type})` : '';
+            const nameStyle = branch.current ? styles.success : (s) => s;
+            this.log(`${icon} ${marker}${nameStyle(branch.name)}${styles.muted(typeInfo)}`);
+        }
+        this.log('');
+    }
+}
+function padEnd(str, length) {
+    return str.padEnd(length);
+}

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

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

package/dist/commands/branch/validate.js

@@ -0,0 +1,73 @@
+import { Args } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { styles } from '../../lib/styles.js';
+import { BRANCH_TYPES, validateBranchName, getCurrentBranch, isGitRepo, } from '../../lib/branch/index.js';
+export default class BranchValidate extends PMOCommand {
+    static description = 'Validate branch name against conventional format';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> feat/chris/add-user-auth',
+        '<%= config.bin %> <%= command.id %> my-random-branch',
+        '<%= config.bin %> <%= command.id %>  # Validates current branch',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Branch name to validate. Defaults to current branch.',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args } = await this.parse(BranchValidate);
+        let branchName = args.name || '';
+        // Use current branch if not provided
+        if (!branchName) {
+            if (!isGitRepo()) {
+                this.error('Not in a git repository.');
+            }
+            const currentBranch = getCurrentBranch();
+            if (!currentBranch) {
+                this.error('Could not determine current branch.');
+            }
+            branchName = currentBranch;
+        }
+        const result = validateBranchName(branchName);
+        this.log('');
+        if (result.valid && result.parts) {
+            if (args.name) {
+                this.log(styles.success('✅ Valid branch name'));
+            }
+            else {
+                this.log(styles.success(`✅ Current branch '${branchName}' is valid`));
+            }
+            if (result.parts.ticketId) {
+                this.log(styles.muted(`   Ticket: ${result.parts.ticketId}`));
+            }
+            this.log(styles.muted(`   Type: ${result.parts.type}`));
+            if (result.parts.owner) {
+                this.log(styles.muted(`   Owner: ${result.parts.owner}`));
+            }
+            if (result.parts.agent) {
+                this.log(styles.muted(`   Agent: ${result.parts.agent}`));
+            }
+            this.log(styles.muted(`   Description: ${result.parts.description}`));
+        }
+        else {
+            this.log(styles.error('❌ Invalid branch name format'));
+            if (result.error) {
+                this.log(styles.muted(`   ${result.error}`));
+            }
+            this.log(styles.muted(`   Expected: {ticketId?}/{type}/{owner?}/{description}`));
+            this.log(styles.muted(`   Types: ${Object.keys(BRANCH_TYPES).join(', ')}`));
+        }
+        this.log('');
+        // Exit with error code if invalid (useful for scripts)
+        if (!result.valid) {
+            this.exit(1);
+        }
+    }
+}

package/dist/commands/commit.d.ts

@@ -0,0 +1,71 @@
+import { Command } from '@oclif/core';
+/**
+ * Format context passed to format functions.
+ */
+interface FormatContext {
+    type: string;
+    ticketId?: string;
+    agent?: string;
+    message: string;
+}
+/**
+ * Commit message format presets.
+ */
+export declare const COMMIT_FORMATS: {
+    readonly conventional: {
+        readonly description: "Conventional commits with ticket as scope";
+        readonly example: "{type}(TKT-ID): {message}";
+        readonly format: (ctx: FormatContext) => string;
+    };
+    readonly 'full-context': {
+        readonly description: "Ticket, type, and agent prefix";
+        readonly example: "TKT-ID/{type}/{agent}: {message}";
+        readonly format: (ctx: FormatContext) => string;
+    };
+    readonly 'ticket-first': {
+        readonly description: "Ticket ID first, then type";
+        readonly example: "TKT-ID: {type}: {message}";
+        readonly format: (ctx: FormatContext) => string;
+    };
+    readonly 'with-agent': {
+        readonly description: "Ticket and agent prefix";
+        readonly example: "TKT-ID/{agent}: {message}";
+        readonly format: (ctx: FormatContext) => string;
+    };
+    readonly 'ticket-suffix': {
+        readonly description: "Type first, ticket at end in brackets";
+        readonly example: "{type}: {message} [TKT-ID]";
+        readonly format: (ctx: FormatContext) => string;
+    };
+    readonly 'ticket-only': {
+        readonly description: "Just ticket ID prefix, no type";
+        readonly example: "TKT-ID: {message}";
+        readonly format: (ctx: FormatContext) => string;
+    };
+    readonly simple: {
+        readonly description: "Type and message only, no ticket";
+        readonly example: "{type}: {message}";
+        readonly format: (ctx: FormatContext) => string;
+    };
+};
+export type CommitFormat = keyof typeof COMMIT_FORMATS;
+export declare const DEFAULT_COMMIT_FORMAT: CommitFormat;
+export default class Commit extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        message: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        formats: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        ticket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        stage: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+export {};