@proletariat/cli 0.3.25 → 0.3.26

package/dist/hooks/init.js

@@ -13,6 +13,10 @@ const hook = async function ({ id, config }) {
     if (id === 'init') {
         return;
     }
+    // Skip when --help flag is present - help should always be available
+    if (process.argv.includes('--help') || process.argv.includes('-h')) {
+        return;
+    }
     // Skip for help-related commands/flags
     // When user runs just `prlt` with no args, id is undefined
     if (!id || id === 'help') {

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

@@ -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
  */
@@ -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));
+}