@proletariat/cli 0.3.24 → 0.3.26

package/dist/lib/multiline-input.js

@@ -0,0 +1,360 @@
+/**
+ * Multi-line text input utility for CLI.
+ *
+ * Provides inline TTY text input without opening external editors.
+ * Handles paste safely, supports cursor navigation, and provides
+ * clear visual feedback.
+ *
+ * Usage:
+ * ```typescript
+ * const text = await multiLineInput({
+ *   message: 'Enter description:',
+ *   default: 'Existing content...',
+ * });
+ * ```
+ */
+import * as readline from 'readline';
+import chalk from 'chalk';
+// ANSI escape codes for terminal control
+const ESC = '\x1b';
+const CSI = `${ESC}[`;
+// Control characters
+const CTRL_C = '\x03';
+const CTRL_D = '\x04';
+const BACKSPACE = '\x7f';
+const DELETE = '\x1b[3~';
+const ENTER = '\r';
+const NEWLINE = '\n';
+// Arrow keys (CSI sequences)
+const ARROW_UP = `${CSI}A`;
+const ARROW_DOWN = `${CSI}B`;
+const ARROW_RIGHT = `${CSI}C`;
+const ARROW_LEFT = `${CSI}D`;
+const HOME = `${CSI}H`;
+const END = `${CSI}F`;
+/**
+ * Clear the current line and move cursor to beginning
+ */
+function clearLine() {
+    process.stdout.write(`${CSI}2K${CSI}G`);
+}
+/**
+ * Move cursor up N lines
+ */
+function moveUp(n) {
+    if (n > 0) {
+        process.stdout.write(`${CSI}${n}A`);
+    }
+}
+/**
+ * Move cursor down N lines
+ */
+function moveDown(n) {
+    if (n > 0) {
+        process.stdout.write(`${CSI}${n}B`);
+    }
+}
+/**
+ * Move cursor to specific column
+ */
+function moveToColumn(col) {
+    process.stdout.write(`${CSI}${col + 1}G`);
+}
+/**
+ * Clear from cursor to end of screen
+ */
+function clearToEnd() {
+    process.stdout.write(`${CSI}J`);
+}
+/**
+ * Hide cursor
+ */
+function hideCursor() {
+    process.stdout.write(`${CSI}?25l`);
+}
+/**
+ * Show cursor
+ */
+function showCursor() {
+    process.stdout.write(`${CSI}?25h`);
+}
+/**
+ * Collect multi-line input from the user with an inline TTY editor.
+ *
+ * Features:
+ * - Arrow key navigation
+ * - Backspace/delete
+ * - Copy-paste handling (escapes special characters)
+ * - Ctrl+D to finish, Ctrl+C to cancel
+ * - Pre-populated content support
+ * - Real-time visual feedback
+ *
+ * @param options Input options
+ * @returns The entered text and cancellation status
+ */
+export async function multiLineInput(options) {
+    const { message, default: defaultValue = '', hint = 'Ctrl+D to finish, Ctrl+C to cancel', required = false, validate, } = options;
+    // If not a TTY, return the default value
+    if (!process.stdin.isTTY) {
+        return { value: defaultValue, cancelled: false };
+    }
+    return new Promise((resolve) => {
+        // Initialize state
+        const lines = defaultValue.split('\n');
+        let cursorLine = lines.length - 1;
+        let cursorCol = lines[cursorLine].length;
+        let renderedLineCount = 0;
+        let inputBuffer = ''; // Buffer for multi-byte sequences
+        // Set up raw mode
+        const wasRaw = process.stdin.isRaw;
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        // Render the input area
+        function render() {
+            // Move up to the start of our rendered area
+            if (renderedLineCount > 0) {
+                moveUp(renderedLineCount);
+            }
+            clearLine();
+            // Print message
+            process.stdout.write(chalk.cyan(message) + '\n');
+            // Print hint
+            process.stdout.write(chalk.dim(hint) + '\n');
+            // Print border (guard against very small terminal widths)
+            const termWidth = process.stdout.columns || 80;
+            const borderWidth = Math.max(1, Math.min(termWidth - 4, 76));
+            process.stdout.write(chalk.dim('┌' + '─'.repeat(borderWidth) + '┐') + '\n');
+            // Print lines with line numbers
+            const displayLines = lines.length > 0 ? lines : [''];
+            for (let i = 0; i < displayLines.length; i++) {
+                clearLine();
+                const lineNum = chalk.dim(`${String(i + 1).padStart(2)} │`);
+                const lineContent = displayLines[i];
+                process.stdout.write(`${lineNum} ${lineContent}\n`);
+            }
+            // Print bottom border
+            process.stdout.write(chalk.dim('└' + '─'.repeat(borderWidth) + '┘') + '\n');
+            // Calculate total rendered lines: message + hint + top border + content lines + bottom border
+            renderedLineCount = 1 + 1 + 1 + displayLines.length + 1;
+            // Position cursor
+            // Move up from current position to the correct line
+            const linesFromBottom = displayLines.length - cursorLine;
+            moveUp(linesFromBottom); // Go to the correct content line (accounting for bottom border)
+            // Move to correct column (line number takes 5 chars: "NN │ ")
+            moveToColumn(5 + cursorCol);
+        }
+        // Handle cleanup
+        function cleanup() {
+            process.stdin.setRawMode(wasRaw || false);
+            process.stdin.pause();
+            showCursor();
+            // Move to end of rendered area
+            const displayLines = lines.length > 0 ? lines : [''];
+            const linesFromBottom = displayLines.length - cursorLine;
+            moveDown(linesFromBottom + 1); // +1 for bottom border
+            clearLine();
+        }
+        // Handle input
+        function handleInput(chunk) {
+            const str = chunk.toString('utf8');
+            // Append to buffer for handling multi-byte sequences
+            inputBuffer += str;
+            // Process buffer character by character
+            while (inputBuffer.length > 0) {
+                // Check for escape sequences
+                if (inputBuffer.startsWith(ESC)) {
+                    // Wait for more data if sequence might be incomplete
+                    if (inputBuffer.length < 3 && inputBuffer !== ESC) {
+                        // Could be start of a sequence, wait for more
+                        if (inputBuffer.length === 1) {
+                            // Just ESC by itself, treat as cancel after timeout
+                            setTimeout(() => {
+                                if (inputBuffer === ESC) {
+                                    inputBuffer = '';
+                                    // ESC key pressed - ignore
+                                }
+                            }, 50);
+                            return;
+                        }
+                        return;
+                    }
+                    // Handle arrow keys and other sequences
+                    if (inputBuffer.startsWith(ARROW_UP)) {
+                        inputBuffer = inputBuffer.slice(3);
+                        if (cursorLine > 0) {
+                            cursorLine--;
+                            cursorCol = Math.min(cursorCol, lines[cursorLine].length);
+                        }
+                        render();
+                        continue;
+                    }
+                    if (inputBuffer.startsWith(ARROW_DOWN)) {
+                        inputBuffer = inputBuffer.slice(3);
+                        if (cursorLine < lines.length - 1) {
+                            cursorLine++;
+                            cursorCol = Math.min(cursorCol, lines[cursorLine].length);
+                        }
+                        render();
+                        continue;
+                    }
+                    if (inputBuffer.startsWith(ARROW_LEFT)) {
+                        inputBuffer = inputBuffer.slice(3);
+                        if (cursorCol > 0) {
+                            cursorCol--;
+                        }
+                        else if (cursorLine > 0) {
+                            cursorLine--;
+                            cursorCol = lines[cursorLine].length;
+                        }
+                        render();
+                        continue;
+                    }
+                    if (inputBuffer.startsWith(ARROW_RIGHT)) {
+                        inputBuffer = inputBuffer.slice(3);
+                        if (cursorCol < lines[cursorLine].length) {
+                            cursorCol++;
+                        }
+                        else if (cursorLine < lines.length - 1) {
+                            cursorLine++;
+                            cursorCol = 0;
+                        }
+                        render();
+                        continue;
+                    }
+                    if (inputBuffer.startsWith(HOME)) {
+                        inputBuffer = inputBuffer.slice(3);
+                        cursorCol = 0;
+                        render();
+                        continue;
+                    }
+                    if (inputBuffer.startsWith(END)) {
+                        inputBuffer = inputBuffer.slice(3);
+                        cursorCol = lines[cursorLine].length;
+                        render();
+                        continue;
+                    }
+                    if (inputBuffer.startsWith(DELETE)) {
+                        inputBuffer = inputBuffer.slice(4);
+                        if (cursorCol < lines[cursorLine].length) {
+                            lines[cursorLine] = lines[cursorLine].slice(0, cursorCol) + lines[cursorLine].slice(cursorCol + 1);
+                        }
+                        else if (cursorLine < lines.length - 1) {
+                            // Join with next line
+                            lines[cursorLine] += lines[cursorLine + 1];
+                            lines.splice(cursorLine + 1, 1);
+                        }
+                        render();
+                        continue;
+                    }
+                    // Unknown escape sequence - skip ESC and continue
+                    inputBuffer = inputBuffer.slice(1);
+                    continue;
+                }
+                // Handle control characters
+                const char = inputBuffer[0];
+                inputBuffer = inputBuffer.slice(1);
+                if (char === CTRL_C) {
+                    cleanup();
+                    resolve({ value: '', cancelled: true });
+                    return;
+                }
+                if (char === CTRL_D) {
+                    const text = lines.join('\n').trim();
+                    // Validate if required
+                    if (required && text.length === 0) {
+                        // Show error and continue - must restore raw mode for input to work
+                        process.stdout.write(chalk.red('Input is required. Please enter some text.') + '\n');
+                        renderedLineCount = 0;
+                        render();
+                        return;
+                    }
+                    if (validate) {
+                        const result = validate(text);
+                        if (result !== true) {
+                            // Show error and continue - keep raw mode active
+                            process.stdout.write(chalk.red(typeof result === 'string' ? result : 'Invalid input') + '\n');
+                            renderedLineCount = 0;
+                            render();
+                            return;
+                        }
+                    }
+                    cleanup();
+                    resolve({ value: text, cancelled: false });
+                    return;
+                }
+                if (char === BACKSPACE || char === '\b') {
+                    if (cursorCol > 0) {
+                        lines[cursorLine] = lines[cursorLine].slice(0, cursorCol - 1) + lines[cursorLine].slice(cursorCol);
+                        cursorCol--;
+                    }
+                    else if (cursorLine > 0) {
+                        // Join with previous line
+                        cursorCol = lines[cursorLine - 1].length;
+                        lines[cursorLine - 1] += lines[cursorLine];
+                        lines.splice(cursorLine, 1);
+                        cursorLine--;
+                    }
+                    render();
+                    continue;
+                }
+                if (char === ENTER || char === NEWLINE) {
+                    // Split line at cursor
+                    const before = lines[cursorLine].slice(0, cursorCol);
+                    const after = lines[cursorLine].slice(cursorCol);
+                    lines[cursorLine] = before;
+                    lines.splice(cursorLine + 1, 0, after);
+                    cursorLine++;
+                    cursorCol = 0;
+                    render();
+                    continue;
+                }
+                // Handle regular characters (including paste)
+                // Filter out non-printable characters except tab
+                if (char === '\t' || (char >= ' ' && char <= '~') || char.charCodeAt(0) > 127) {
+                    // Insert character at cursor position
+                    lines[cursorLine] = lines[cursorLine].slice(0, cursorCol) + char + lines[cursorLine].slice(cursorCol);
+                    cursorCol++;
+                    render();
+                }
+            }
+        }
+        // Initial render
+        render();
+        // Listen for input
+        process.stdin.on('data', handleInput);
+        // Cleanup listener on resolve
+        const originalResolve = resolve;
+        resolve = (result) => {
+            process.stdin.removeListener('data', handleInput);
+            originalResolve(result);
+        };
+    });
+}
+/**
+ * Convenience wrapper that returns just the value string.
+ * Throws if cancelled.
+ */
+export async function promptMultiLine(options) {
+    const result = await multiLineInput(options);
+    if (result.cancelled) {
+        throw new Error('Input cancelled');
+    }
+    return result.value;
+}
+/**
+ * Integration with FlagResolver - creates a prompt-compatible function
+ */
+export function createMultiLinePrompt(message, defaultValue, hint) {
+    return async () => {
+        const result = await multiLineInput({
+            message,
+            default: defaultValue,
+            hint,
+        });
+        if (result.cancelled) {
+            throw new Error('Input cancelled');
+        }
+        return result.value;
+    };
+}

package/dist/lib/pr/index.d.ts

@@ -51,6 +51,8 @@ export declare function isGHTokenInEnv(): boolean;
 export declare function getGitHubRepo(cwd?: string): string | null;
 /**
  * Get the default base branch (main or master).
+ * Prefers origin/main over local main to avoid stale local branches
+ * in agent worktrees where local main is never updated.
  */
 export declare function getDefaultBaseBranch(cwd?: string): string;
 /**
@@ -71,6 +73,8 @@ export declare function pushBranch(branch: string, cwd?: string): boolean;
 export declare function hasUnpushedCommits(branch: string, cwd?: string): boolean;
 /**
  * Get the commit log between base and head.
+ * Prefers origin/${base} over local ${base} to avoid stale local branches
+ * in agent worktrees where local main/master is never updated.
  */
 export declare function getCommitLog(base: string, cwd?: string): string[];
 /**

package/dist/lib/pr/index.js

@@ -85,29 +85,31 @@ export function getGitHubRepo(cwd) {
 }
 /**
  * Get the default base branch (main or master).
+ * Prefers origin/main over local main to avoid stale local branches
+ * in agent worktrees where local main is never updated.
  */
 export function getDefaultBaseBranch(cwd) {
-    try {
-        // Check if 'main' exists
-        execSync('git rev-parse --verify main', {
-            cwd,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return 'main';
-    }
-    catch {
-        // Fall back to 'master'
+    // Check origin/main first (most reliable in worktree environments)
+    // then local main, then origin/master, then local master
+    const candidates = [
+        { ref: 'origin/main', name: 'main' },
+        { ref: 'main', name: 'main' },
+        { ref: 'origin/master', name: 'master' },
+        { ref: 'master', name: 'master' },
+    ];
+    for (const { ref, name } of candidates) {
         try {
-            execSync('git rev-parse --verify master', {
+            execSync(`git rev-parse --verify ${ref}`, {
                 cwd,
                 stdio: ['pipe', 'pipe', 'pipe'],
             });
-            return 'master';
+            return name;
         }
         catch {
-            return 'main'; // Default to main even if not found
+            // Try next candidate
         }
     }
+    return 'main'; // Default to main even if not found
 }
 /**
  * Get the current branch name.
@@ -173,10 +175,26 @@ export function hasUnpushedCommits(branch, cwd) {
 }
 /**
  * Get the commit log between base and head.
+ * Prefers origin/${base} over local ${base} to avoid stale local branches
+ * in agent worktrees where local main/master is never updated.
  */
 export function getCommitLog(base, cwd) {
+    // Prefer origin/${base} for accurate comparison (local branch may be stale)
+    let ref = base;
+    if (!base.startsWith('origin/')) {
+        try {
+            execSync(`git rev-parse --verify origin/${base}`, {
+                cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            ref = `origin/${base}`;
+        }
+        catch {
+            // Fall back to local ref
+        }
+    }
     try {
-        const output = execSync(`git log ${base}..HEAD --oneline`, {
+        const output = execSync(`git log ${ref}..HEAD --oneline`, {
             cwd,
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'pipe'],

package/dist/lib/prompt-command.d.ts

@@ -83,6 +83,9 @@ export declare abstract class PromptCommand extends Command {
         default?: unknown;
         validate?: (input: unknown) => boolean | string;
         when?: boolean | ((answers: Record<string, unknown>) => boolean);
+        filter?: (input: unknown) => unknown;
+        pageSize?: number;
+        [key: string]: unknown;
     }>, jsonModeConfig?: {
         flags: JsonFlags & Record<string, unknown>;
         commandName: string;

package/dist/lib/prompt-json.d.ts

@@ -46,8 +46,8 @@ export interface PromptChoice {
  * Form field configuration for multi-field prompts
  */
 export interface FormField {
-    /** Type of field: input, list, checkbox, confirm, editor */
-    type: 'input' | 'list' | 'checkbox' | 'confirm' | 'editor';
+    /** Type of field: input, list, checkbox, confirm, editor, multiline */
+    type: 'input' | 'list' | 'checkbox' | 'confirm' | 'editor' | 'multiline';
     /** Field name */
     name: string;
     /** User-facing message */
@@ -61,8 +61,8 @@ export interface FormField {
  * Prompt configuration for JSON output
  */
 export interface PromptConfig {
-    /** Type of prompt: list (single select), checkbox (multi select), confirm, input, editor, or form (multi-field) */
-    type: 'list' | 'checkbox' | 'confirm' | 'input' | 'editor' | 'form';
+    /** Type of prompt: list (single select), checkbox (multi select), confirm, input, editor, multiline (inline multi-line), or form (multi-field) */
+    type: 'list' | 'checkbox' | 'confirm' | 'input' | 'editor' | 'multiline' | 'form';
     /** Field name for the prompt answer (not used for form type) */
     name?: string;
     /** User-facing prompt message (not used for form type) */
@@ -150,10 +150,49 @@ export interface DryRunJsonOutput {
     /** Command metadata */
     metadata: OutputMetadata;
 }
+/**
+ * JSON output for confirmation needed (two-step execute protocol)
+ * Used when all required flags are provided but --yes is not set.
+ * Agent should review the plan and re-run with --yes to execute.
+ */
+export interface ConfirmationNeededJsonOutput {
+    /** Output type discriminator */
+    type: 'confirmation_needed';
+    /** Plan of what will happen if confirmed */
+    plan: Record<string, unknown>;
+    /** The full command to run to confirm and execute */
+    confirm_command: string;
+    /** Human-readable message */
+    message: string;
+    /** Command metadata */
+    metadata: OutputMetadata;
+}
+/**
+ * JSON output for execution result (after successful spawn/start)
+ */
+export interface ExecutionResultJsonOutput {
+    /** Output type discriminator */
+    type: 'execution_result';
+    /** Execution results */
+    result: {
+        executions: Array<{
+            workId: string;
+            ticketId: string;
+            agent: string;
+            sessionId?: string;
+            containerId?: string;
+            status: string;
+        }>;
+        successCount: number;
+        failCount: number;
+    };
+    /** Command metadata */
+    metadata: OutputMetadata;
+}
 /**
  * Union type for all JSON output types
  */
-export type JsonOutput = PromptJsonOutput | SuccessJsonOutput | ErrorJsonOutput | DryRunJsonOutput;
+export type JsonOutput = PromptJsonOutput | SuccessJsonOutput | ErrorJsonOutput | DryRunJsonOutput | ConfirmationNeededJsonOutput | ExecutionResultJsonOutput;
 /**
  * Flags interface for JSON mode detection
  */
@@ -267,7 +306,7 @@ export declare function normalizeChoices(choices: Array<string | {
  * @param defaultValue - Optional default value
  * @returns PromptConfig object
  */
-export declare function buildPromptConfig(type: 'list' | 'checkbox' | 'confirm' | 'input' | 'editor', name: string, message: string, choices?: Array<string | {
+export declare function buildPromptConfig(type: 'list' | 'checkbox' | 'confirm' | 'input' | 'editor' | 'multiline', name: string, message: string, choices?: Array<string | {
     name: string;
     value: string;
     disabled?: boolean | string;
@@ -304,3 +343,35 @@ export declare function outputDryRunErrorsAsJson(errors: Array<{
     field: string;
     error: string;
 }>, metadata: OutputMetadata): never;
+/**
+ * Output a confirmation needed response as JSON and exit
+ *
+ * Use this in non-TTY mode when all required flags are provided but --yes is not set.
+ * This allows agents to preview what will happen before confirming execution.
+ *
+ * @param plan - Details of what will happen if confirmed
+ * @param confirmCommand - The full command to run with --yes to execute
+ * @param message - Human-readable message explaining the confirmation
+ * @param metadata - Command metadata
+ */
+export declare function outputConfirmationNeededAsJson(plan: Record<string, unknown>, confirmCommand: string, message: string, metadata: OutputMetadata): never;
+/**
+ * Output execution result as JSON (non-exiting version)
+ *
+ * Use this after execution completes in non-TTY mode to provide structured
+ * results. Unlike other output functions, this does NOT exit - caller should
+ * handle cleanup and exit.
+ *
+ * @param executions - Array of execution results
+ * @param successCount - Number of successful executions
+ * @param failCount - Number of failed executions
+ * @param metadata - Command metadata
+ */
+export declare function outputExecutionResultAsJson(executions: Array<{
+    workId: string;
+    ticketId: string;
+    agent: string;
+    sessionId?: string;
+    containerId?: string;
+    status: string;
+}>, successCount: number, failCount: number, metadata: OutputMetadata): void;

package/dist/lib/prompt-json.js

@@ -280,3 +280,49 @@ export function outputDryRunErrorsAsJson(errors, metadata) {
     console.log(JSON.stringify(output, null, 2));
     process.exit(EXIT_ERROR);
 }
+/**
+ * Output a confirmation needed response as JSON and exit
+ *
+ * Use this in non-TTY mode when all required flags are provided but --yes is not set.
+ * This allows agents to preview what will happen before confirming execution.
+ *
+ * @param plan - Details of what will happen if confirmed
+ * @param confirmCommand - The full command to run with --yes to execute
+ * @param message - Human-readable message explaining the confirmation
+ * @param metadata - Command metadata
+ */
+export function outputConfirmationNeededAsJson(plan, confirmCommand, message, metadata) {
+    const output = {
+        type: 'confirmation_needed',
+        plan,
+        confirm_command: confirmCommand,
+        message,
+        metadata,
+    };
+    console.log(JSON.stringify(output, null, 2));
+    process.exit(EXIT_NEEDS_INPUT);
+}
+/**
+ * Output execution result as JSON (non-exiting version)
+ *
+ * Use this after execution completes in non-TTY mode to provide structured
+ * results. Unlike other output functions, this does NOT exit - caller should
+ * handle cleanup and exit.
+ *
+ * @param executions - Array of execution results
+ * @param successCount - Number of successful executions
+ * @param failCount - Number of failed executions
+ * @param metadata - Command metadata
+ */
+export function outputExecutionResultAsJson(executions, successCount, failCount, metadata) {
+    const output = {
+        type: 'execution_result',
+        result: {
+            executions,
+            successCount,
+            failCount,
+        },
+        metadata,
+    };
+    console.log(JSON.stringify(output, null, 2));
+}

package/dist/lib/repos/git.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check if a git repository has a GitHub remote configured.
+ *
+ * @param cwd - Directory to check (defaults to process.cwd())
+ * @returns true if the repository has a GitHub remote
+ */
+export declare function hasGitHubRemote(cwd?: string): boolean;

package/dist/lib/repos/git.js

@@ -0,0 +1,20 @@
+import { execSync } from 'node:child_process';
+/**
+ * Check if a git repository has a GitHub remote configured.
+ *
+ * @param cwd - Directory to check (defaults to process.cwd())
+ * @returns true if the repository has a GitHub remote
+ */
+export function hasGitHubRemote(cwd) {
+    try {
+        const remoteUrl = execSync('git remote get-url origin', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return remoteUrl.includes('github.com');
+    }
+    catch {
+        return false;
+    }
+}