commandmate 0.2.3 → 0.2.4

package/.next/types/app/api/app/update-check/route.ts

@@ -0,0 +1,343 @@
+// File: /home/runner/work/CommandMate/CommandMate/src/app/api/app/update-check/route.ts
+import * as entry from '../../../../../../src/app/api/app/update-check/route.js'
+import type { NextRequest } from 'next/server.js'
+
+type TEntry = typeof import('../../../../../../src/app/api/app/update-check/route.js')
+
+// Check that the entry is a valid entry
+checkFields<Diff<{
+  GET?: Function
+  HEAD?: Function
+  OPTIONS?: Function
+  POST?: Function
+  PUT?: Function
+  DELETE?: Function
+  PATCH?: Function
+  config?: {}
+  generateStaticParams?: Function
+  revalidate?: RevalidateRange<TEntry> | false
+  dynamic?: 'auto' | 'force-dynamic' | 'error' | 'force-static'
+  dynamicParams?: boolean
+  fetchCache?: 'auto' | 'force-no-store' | 'only-no-store' | 'default-no-store' | 'default-cache' | 'only-cache' | 'force-cache'
+  preferredRegion?: 'auto' | 'global' | 'home' | string | string[]
+  runtime?: 'nodejs' | 'experimental-edge' | 'edge'
+  maxDuration?: number
+  
+}, TEntry, ''>>()
+
+// Check the prop type of the entry function
+if ('GET' in entry) {
+  checkFields<
+    Diff<
+      ParamCheck<Request | NextRequest>,
+      {
+        __tag__: 'GET'
+        __param_position__: 'first'
+        __param_type__: FirstArg<MaybeField<TEntry, 'GET'>>
+      },
+      'GET'
+    >
+  >()
+  checkFields<
+    Diff<
+      ParamCheck<PageParams>,
+      {
+        __tag__: 'GET'
+        __param_position__: 'second'
+        __param_type__: SecondArg<MaybeField<TEntry, 'GET'>>
+      },
+      'GET'
+    >
+  >()
+  
+  checkFields<
+    Diff<
+      {
+        __tag__: 'GET',
+        __return_type__: Response | void | never | Promise<Response | void | never>
+      },
+      {
+        __tag__: 'GET',
+        __return_type__: ReturnType<MaybeField<TEntry, 'GET'>>
+      },
+      'GET'
+    >
+  >()
+}
+// Check the prop type of the entry function
+if ('HEAD' in entry) {
+  checkFields<
+    Diff<
+      ParamCheck<Request | NextRequest>,
+      {
+        __tag__: 'HEAD'
+        __param_position__: 'first'
+        __param_type__: FirstArg<MaybeField<TEntry, 'HEAD'>>
+      },
+      'HEAD'
+    >
+  >()
+  checkFields<
+    Diff<
+      ParamCheck<PageParams>,
+      {
+        __tag__: 'HEAD'
+        __param_position__: 'second'
+        __param_type__: SecondArg<MaybeField<TEntry, 'HEAD'>>
+      },
+      'HEAD'
+    >
+  >()
+  
+  checkFields<
+    Diff<
+      {
+        __tag__: 'HEAD',
+        __return_type__: Response | void | never | Promise<Response | void | never>
+      },
+      {
+        __tag__: 'HEAD',
+        __return_type__: ReturnType<MaybeField<TEntry, 'HEAD'>>
+      },
+      'HEAD'
+    >
+  >()
+}
+// Check the prop type of the entry function
+if ('OPTIONS' in entry) {
+  checkFields<
+    Diff<
+      ParamCheck<Request | NextRequest>,
+      {
+        __tag__: 'OPTIONS'
+        __param_position__: 'first'
+        __param_type__: FirstArg<MaybeField<TEntry, 'OPTIONS'>>
+      },
+      'OPTIONS'
+    >
+  >()
+  checkFields<
+    Diff<
+      ParamCheck<PageParams>,
+      {
+        __tag__: 'OPTIONS'
+        __param_position__: 'second'
+        __param_type__: SecondArg<MaybeField<TEntry, 'OPTIONS'>>
+      },
+      'OPTIONS'
+    >
+  >()
+  
+  checkFields<
+    Diff<
+      {
+        __tag__: 'OPTIONS',
+        __return_type__: Response | void | never | Promise<Response | void | never>
+      },
+      {
+        __tag__: 'OPTIONS',
+        __return_type__: ReturnType<MaybeField<TEntry, 'OPTIONS'>>
+      },
+      'OPTIONS'
+    >
+  >()
+}
+// Check the prop type of the entry function
+if ('POST' in entry) {
+  checkFields<
+    Diff<
+      ParamCheck<Request | NextRequest>,
+      {
+        __tag__: 'POST'
+        __param_position__: 'first'
+        __param_type__: FirstArg<MaybeField<TEntry, 'POST'>>
+      },
+      'POST'
+    >
+  >()
+  checkFields<
+    Diff<
+      ParamCheck<PageParams>,
+      {
+        __tag__: 'POST'
+        __param_position__: 'second'
+        __param_type__: SecondArg<MaybeField<TEntry, 'POST'>>
+      },
+      'POST'
+    >
+  >()
+  
+  checkFields<
+    Diff<
+      {
+        __tag__: 'POST',
+        __return_type__: Response | void | never | Promise<Response | void | never>
+      },
+      {
+        __tag__: 'POST',
+        __return_type__: ReturnType<MaybeField<TEntry, 'POST'>>
+      },
+      'POST'
+    >
+  >()
+}
+// Check the prop type of the entry function
+if ('PUT' in entry) {
+  checkFields<
+    Diff<
+      ParamCheck<Request | NextRequest>,
+      {
+        __tag__: 'PUT'
+        __param_position__: 'first'
+        __param_type__: FirstArg<MaybeField<TEntry, 'PUT'>>
+      },
+      'PUT'
+    >
+  >()
+  checkFields<
+    Diff<
+      ParamCheck<PageParams>,
+      {
+        __tag__: 'PUT'
+        __param_position__: 'second'
+        __param_type__: SecondArg<MaybeField<TEntry, 'PUT'>>
+      },
+      'PUT'
+    >
+  >()
+  
+  checkFields<
+    Diff<
+      {
+        __tag__: 'PUT',
+        __return_type__: Response | void | never | Promise<Response | void | never>
+      },
+      {
+        __tag__: 'PUT',
+        __return_type__: ReturnType<MaybeField<TEntry, 'PUT'>>
+      },
+      'PUT'
+    >
+  >()
+}
+// Check the prop type of the entry function
+if ('DELETE' in entry) {
+  checkFields<
+    Diff<
+      ParamCheck<Request | NextRequest>,
+      {
+        __tag__: 'DELETE'
+        __param_position__: 'first'
+        __param_type__: FirstArg<MaybeField<TEntry, 'DELETE'>>
+      },
+      'DELETE'
+    >
+  >()
+  checkFields<
+    Diff<
+      ParamCheck<PageParams>,
+      {
+        __tag__: 'DELETE'
+        __param_position__: 'second'
+        __param_type__: SecondArg<MaybeField<TEntry, 'DELETE'>>
+      },
+      'DELETE'
+    >
+  >()
+  
+  checkFields<
+    Diff<
+      {
+        __tag__: 'DELETE',
+        __return_type__: Response | void | never | Promise<Response | void | never>
+      },
+      {
+        __tag__: 'DELETE',
+        __return_type__: ReturnType<MaybeField<TEntry, 'DELETE'>>
+      },
+      'DELETE'
+    >
+  >()
+}
+// Check the prop type of the entry function
+if ('PATCH' in entry) {
+  checkFields<
+    Diff<
+      ParamCheck<Request | NextRequest>,
+      {
+        __tag__: 'PATCH'
+        __param_position__: 'first'
+        __param_type__: FirstArg<MaybeField<TEntry, 'PATCH'>>
+      },
+      'PATCH'
+    >
+  >()
+  checkFields<
+    Diff<
+      ParamCheck<PageParams>,
+      {
+        __tag__: 'PATCH'
+        __param_position__: 'second'
+        __param_type__: SecondArg<MaybeField<TEntry, 'PATCH'>>
+      },
+      'PATCH'
+    >
+  >()
+  
+  checkFields<
+    Diff<
+      {
+        __tag__: 'PATCH',
+        __return_type__: Response | void | never | Promise<Response | void | never>
+      },
+      {
+        __tag__: 'PATCH',
+        __return_type__: ReturnType<MaybeField<TEntry, 'PATCH'>>
+      },
+      'PATCH'
+    >
+  >()
+}
+
+// Check the arguments and return type of the generateStaticParams function
+if ('generateStaticParams' in entry) {
+  checkFields<Diff<{ params: PageParams }, FirstArg<MaybeField<TEntry, 'generateStaticParams'>>, 'generateStaticParams'>>()
+  checkFields<Diff<{ __tag__: 'generateStaticParams', __return_type__: any[] | Promise<any[]> }, { __tag__: 'generateStaticParams', __return_type__: ReturnType<MaybeField<TEntry, 'generateStaticParams'>> }>>()
+}
+
+type PageParams = any
+export interface PageProps {
+  params?: any
+  searchParams?: any
+}
+export interface LayoutProps {
+  children?: React.ReactNode
+
+  params?: any
+}
+
+// =============
+// Utility types
+type RevalidateRange<T> = T extends { revalidate: any } ? NonNegative<T['revalidate']> : never
+
+// If T is unknown or any, it will be an empty {} type. Otherwise, it will be the same as Omit<T, keyof Base>.
+type OmitWithTag<T, K extends keyof any, _M> = Omit<T, K>
+type Diff<Base, T extends Base, Message extends string = ''> = 0 extends (1 & T) ? {} : OmitWithTag<T, keyof Base, Message>
+
+type FirstArg<T extends Function> = T extends (...args: [infer T, any]) => any ? unknown extends T ? any : T : never
+type SecondArg<T extends Function> = T extends (...args: [any, infer T]) => any ? unknown extends T ? any : T : never
+type MaybeField<T, K extends string> = T extends { [k in K]: infer G } ? G extends Function ? G : never : never
+
+type ParamCheck<T> = {
+  __tag__: string
+  __param_position__: string
+  __param_type__: T
+}
+
+function checkFields<_ extends { [k in keyof any]: never }>() {}
+
+// https://github.com/sindresorhus/type-fest
+type Numeric = number | bigint
+type Zero = 0 | 0n
+type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never
+type NonNegative<T extends Numeric> = T extends Zero ? T : Negative<T> extends never ? T : '__invalid_negative_number__'

package/dist/server/src/lib/prompt-detector.js

@@ -184,6 +184,28 @@ const NORMAL_OPTION_PATTERN = /^\s*(\d+)\.\s*(.+)$/;
  * Anchored at both ends -- ReDoS safe (S4-001).
  */
 const SEPARATOR_LINE_PATTERN = /^[-─]+$/;
+/**
+ * Maximum number of lines to scan upward from questionEndIndex
+ * when the questionEndIndex line itself is not a question-like line.
+ *
+ * Design rationale (IC-256-001):
+ * - model selection prompts have 1-2 lines between "Select model" and first option
+ * - multi-line question wrapping typically produces 2-3 continuation lines
+ * - value of 3 covers these cases while minimizing False Positive surface
+ *
+ * [SF-002] Change guidelines:
+ * - Increase this value ONLY if real-world prompts are discovered where
+ *   the question line is more than 3 lines above questionEndIndex
+ * - Before increasing, verify that the new value does not cause
+ *   T11h-T11m False Positive tests to fail
+ * - Consider that larger values increase the False Positive surface area
+ * - If increasing beyond 5, consider whether the detection approach
+ *   itself needs to be redesigned (e.g., pattern-based instead of scan-based)
+ * - Document the specific prompt pattern that necessitated the change
+ *
+ * @see Issue #256: multiple_choice prompt detection improvement
+ */
+const QUESTION_SCAN_RANGE = 3;
 /**
  * Creates a "no prompt detected" result.
  * Centralizes the repeated pattern of returning isPrompt: false with trimmed content.
@@ -244,17 +266,75 @@ function isQuestionLikeLine(line) {
     // Empty lines are not questions
     if (line.length === 0)
         return false;
-    // Pattern 1: Lines ending with question mark (English or full-width Japanese)
+    // Pattern 1: Lines containing question mark anywhere (English '?' or full-width U+FF1F).
+    // This covers both:
+    //   - Lines ending with '?' (standard question format)
+    //   - Lines with '?' mid-line (Issue #256: multi-line question wrapping where '?'
+    //     appears mid-line due to terminal width causing the question text to wrap)
+    //
     // Full-width question mark (U+FF1F) support is a defensive measure: Claude Code/CLI
     // displays questions in English, but this covers future multi-language support
     // and third-party tool integration.
-    if (line.endsWith('?') || line.endsWith('\uff1f'))
+    //
+    // [SF-001] Scope constraints:
+    // - The mid-line '?' detection is effective without False Positive risk only within
+    //   SEC-001b guard context (questionEndIndex vicinity and upward scan range).
+    // - isQuestionLikeLine() is currently module-private (no export).
+    // - If this function is exported for external use in the future, consider:
+    //   (a) Providing a stricter variant (e.g., isStrictQuestionLikeLine()) without mid-line match
+    //   (b) Separating mid-line match into a SEC-001b-specific helper function
+    //   (c) Adding URL exclusion logic (/[?&]\w+=/.test(line) to exclude)
+    if (line.includes('?') || line.includes('\uff1f'))
+        return true;
+    // Pattern 2: Lines containing a selection/input keyword.
+    // Detects both colon-terminated (e.g., "Select an option:", "Choose a mode:") and
+    // non-colon forms (e.g., "Select model") used by CLI prompts (Issue #256).
+    //
+    // [SF-001] Scope constraints apply:
+    // - Effective without False Positive risk only within SEC-001b guard context.
+    // - T11h-T11m False Positive lines do not contain QUESTION_KEYWORD_PATTERN keywords.
+    // - If this function is exported, consider restricting this pattern to SEC-001b context.
+    if (QUESTION_KEYWORD_PATTERN.test(line))
         return true;
-    // Pattern 2: Lines ending with colon that contain a selection/input keyword
-    // Examples: "Select an option:", "Choose a mode:", "Pick one:"
-    if (line.endsWith(':')) {
-        if (QUESTION_KEYWORD_PATTERN.test(line))
+    return false;
+}
+/**
+ * Search upward from a given line index to find a question-like line.
+ * Skips empty lines and separator lines (horizontal rules).
+ *
+ * This function is used by SEC-001b guard to find a question line above
+ * questionEndIndex when the questionEndIndex line itself is not a question-like line.
+ * This handles cases where the question text wraps across multiple lines or
+ * where description lines appear between the question and the numbered options.
+ *
+ * @param lines - Array of output lines
+ * @param startIndex - Starting line index (exclusive, searches startIndex-1 and above)
+ * @param scanRange - Maximum number of lines to scan upward (must be >= 0, clamped to MAX_SCAN_RANGE=10)
+ * @param lowerBound - Minimum line index (inclusive, scan will not go below this)
+ * @returns true if a question-like line is found within the scan range
+ *
+ * @see IC-256-002: SEC-001b upward scan implementation
+ * @see SF-003: Function extraction for readability
+ * @see SF-S4-001: scanRange input validation (defensive clamping)
+ *
+ * ReDoS safe: Uses SEPARATOR_LINE_PATTERN (existing ReDoS safe pattern) and
+ * isQuestionLikeLine() (literal character checks + simple alternation pattern).
+ * No new regex patterns introduced. (C-S4-001)
+ */
+function findQuestionLineInRange(lines, startIndex, scanRange, lowerBound) {
+    // [SF-S4-001] Defensive input validation: clamp scanRange to safe bounds.
+    // Currently only called with QUESTION_SCAN_RANGE=3, but guards against
+    // future misuse if the function is refactored or exported.
+    const safeScanRange = Math.min(Math.max(scanRange, 0), 10);
+    const scanLimit = Math.max(lowerBound, startIndex - safeScanRange);
+    for (let i = startIndex - 1; i >= scanLimit; i--) {
+        const candidateLine = lines[i]?.trim() ?? '';
+        // Skip empty lines and separator lines (horizontal rules)
+        if (!candidateLine || SEPARATOR_LINE_PATTERN.test(candidateLine))
+            continue;
+        if (isQuestionLikeLine(candidateLine)) {
             return true;
+        }
     }
     return false;
 }
@@ -308,19 +388,103 @@ function isConsecutiveFromOne(numbers) {
  * @returns true if the line should be treated as a continuation of a previous option
  */
 function isContinuationLine(rawLine, line) {
-    // Indented non-option line.
-    // Excludes lines ending with '?' or '？' (U+FF1F) because those are typically question lines
+    // Lines ending with '?' or full-width '？' (U+FF1F) are typically question lines
     // (e.g., "  Do you want to proceed?", "  コピーしたい対象はどれですか？") from CLI tool output
-    // where both the question and options are 2-space indented. Without this exclusion,
-    // the question line would be misclassified as a continuation line, causing
-    // questionEndIndex to remain -1 and Layer 5 SEC-001 to block detection.
+    // where both the question and options are 2-space indented. These must NOT be
+    // treated as continuation lines, otherwise questionEndIndex remains -1 and
+    // Layer 5 SEC-001 blocks detection.
     const endsWithQuestion = line.endsWith('?') || line.endsWith('\uff1f');
-    const hasLeadingSpaces = /^\s{2,}[^\d]/.test(rawLine) && !/^\s*\d+\./.test(rawLine) && !endsWithQuestion;
-    // Short fragment (< 5 chars, excluding question-ending lines)
-    const isShortFragment = line.length < 5 && !endsWithQuestion;
-    // Path string continuation: lines starting with / or ~, or alphanumeric-only fragments (2+ chars)
-    const isPathContinuation = /^[\/~]/.test(line) || (line.length >= 2 && /^[a-zA-Z0-9_-]+$/.test(line));
-    return !!hasLeadingSpaces || isShortFragment || isPathContinuation;
+    // Check 1: Indented non-option line (label text wrapping with indentation).
+    // Must have 2+ leading spaces, not start with a number (option line), and not end with '?'.
+    if (!endsWithQuestion && /^\s{2,}[^\d]/.test(rawLine) && !/^\s*\d+\./.test(rawLine)) {
+        return true;
+    }
+    // Check 2: Short fragment (< 5 chars, e.g., filename tail).
+    // Excludes question-ending lines to prevent misclassifying short questions.
+    if (line.length < 5 && !endsWithQuestion) {
+        return true;
+    }
+    // Check 3: Path string continuation (Issue #181).
+    // Lines starting with / or ~, or alphanumeric-only fragments (2+ chars).
+    if (/^[\/~]/.test(line) || (line.length >= 2 && /^[a-zA-Z0-9_-]+$/.test(line))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Extract question text from the lines around questionEndIndex.
+ * Collects non-empty, non-separator lines from up to 5 lines before questionEndIndex
+ * through questionEndIndex itself, joining them with spaces.
+ *
+ * @param lines - Array of output lines
+ * @param questionEndIndex - Index of the last line before options, or -1 if not found
+ * @returns Extracted question text, or generic fallback if questionEndIndex is -1
+ */
+function extractQuestionText(lines, questionEndIndex) {
+    if (questionEndIndex < 0) {
+        return 'Please select an option:';
+    }
+    const questionLines = [];
+    for (let i = Math.max(0, questionEndIndex - 5); i <= questionEndIndex; i++) {
+        const line = lines[i].trim();
+        if (line && !SEPARATOR_LINE_PATTERN.test(line)) {
+            questionLines.push(line);
+        }
+    }
+    return questionLines.join(' ');
+}
+/**
+ * Extract instruction text for the prompt block.
+ * Captures the complete AskUserQuestion block including context before the question,
+ * option descriptions, and navigation hints.
+ *
+ * @param lines - Array of output lines
+ * @param questionEndIndex - Index of the last line before options, or -1 if not found
+ * @param effectiveEnd - End index of non-trailing-empty lines
+ * @returns Instruction text string, or undefined if no question line found
+ */
+function extractInstructionText(lines, questionEndIndex, effectiveEnd) {
+    if (questionEndIndex < 0) {
+        return undefined;
+    }
+    const contextStart = Math.max(0, questionEndIndex - 19);
+    const blockLines = lines.slice(contextStart, effectiveEnd)
+        .map(l => l.trimEnd());
+    const joined = blockLines.join('\n').trim();
+    return joined.length > 0 ? joined : undefined;
+}
+/**
+ * Build the final PromptDetectionResult for a multiple choice prompt.
+ * Maps collected options to the output format, checking each option for
+ * text input requirements using TEXT_INPUT_PATTERNS.
+ *
+ * @param question - Extracted question text
+ * @param collectedOptions - Options collected during Pass 2 scanning
+ * @param instructionText - Instruction text for the prompt block
+ * @param output - Original output text (used for rawContent truncation)
+ * @returns PromptDetectionResult with isPrompt: true and multiple_choice data
+ */
+function buildMultipleChoiceResult(question, collectedOptions, instructionText, output) {
+    return {
+        isPrompt: true,
+        promptData: {
+            type: 'multiple_choice',
+            question: question.trim(),
+            options: collectedOptions.map(opt => {
+                const requiresTextInput = TEXT_INPUT_PATTERNS.some(pattern => pattern.test(opt.label));
+                return {
+                    number: opt.number,
+                    label: opt.label,
+                    isDefault: opt.isDefault,
+                    requiresTextInput,
+                };
+            }),
+            status: 'pending',
+            instructionText,
+        },
+        cleanContent: question.trim(),
+        rawContent: truncateRawContent(output.trim()), // Issue #235: complete prompt output (truncated) [MF-001]
+    };
 }
 /**
  * Detect multiple choice prompts (numbered list with ❯ indicator)
@@ -399,6 +563,20 @@ function detectMultipleChoicePrompt(output, options) {
         }
         // Non-option line handling
         if (collectedOptions.length > 0 && line && !SEPARATOR_LINE_PATTERN.test(line)) {
+            // [MF-001 / Issue #256] Check if line is a question-like line BEFORE
+            // continuation check. This preserves isContinuationLine()'s SRP by not
+            // mixing question detection into it. Without this pre-check, indented
+            // question lines (e.g., "  Select model") could be misclassified as
+            // continuation lines by isContinuationLine()'s hasLeadingSpaces check.
+            //
+            // [SF-S4-003] Both this pre-check and SEC-001b upward scan use the same
+            // isQuestionLikeLine() function intentionally (DRY). If a question line is
+            // caught here, SEC-001b upward scan is not needed (questionEndIndex line
+            // itself passes isQuestionLikeLine()).
+            if (isQuestionLikeLine(line)) {
+                questionEndIndex = i;
+                break;
+            }
             // Check if this is a continuation line (indented line between options,
             // or path/filename fragments from terminal width wrapping - Issue #181)
             const rawLine = lines[i]; // Original line with indentation preserved
@@ -435,61 +613,23 @@ function detectMultipleChoicePrompt(output, options) {
         // SEC-001b: Question line exists but is not actually a question/selection request.
         // Validates that the question line contains a question mark or a selection keyword
         // with colon, distinguishing "Select an option:" from "Recommendations:".
+        //
+        // [Issue #256] Enhanced with upward scan via findQuestionLineInRange() (SF-003).
+        // When questionEndIndex line itself is not a question-like line, scan upward
+        // within QUESTION_SCAN_RANGE to find a question line above it. This handles:
+        // - Multi-line question wrapping where ? is on a line above questionEndIndex
+        // - Model selection prompts where "Select model" is above description lines
         const questionLine = lines[questionEndIndex]?.trim() ?? '';
         if (!isQuestionLikeLine(questionLine)) {
-            return noPromptResult(output);
-        }
-    }
-    // Extract question text
-    let question = '';
-    if (questionEndIndex >= 0) {
-        // Get all non-empty lines from questionEndIndex up to (but not including) first option
-        const questionLines = [];
-        for (let i = Math.max(0, questionEndIndex - 5); i <= questionEndIndex; i++) {
-            const line = lines[i].trim();
-            if (line && !SEPARATOR_LINE_PATTERN.test(line)) {
-                questionLines.push(line);
+            // Upward scan: look for a question-like line above questionEndIndex
+            if (!findQuestionLineInRange(lines, questionEndIndex, QUESTION_SCAN_RANGE, scanStart)) {
+                return noPromptResult(output);
             }
         }
-        question = questionLines.join(' ');
-    }
-    else {
-        // No clear question found - use a generic one
-        question = 'Please select an option:';
-    }
-    // Extract instruction text: full prompt block (context before question through all options/descriptions)
-    // Captures the complete AskUserQuestion block including option descriptions and navigation hints.
-    let instructionText;
-    if (questionEndIndex >= 0) {
-        const contextStart = Math.max(0, questionEndIndex - 19);
-        const blockLines = lines.slice(contextStart, effectiveEnd)
-            .map(l => l.trimEnd());
-        const joined = blockLines.join('\n').trim();
-        if (joined.length > 0) {
-            instructionText = joined;
-        }
     }
-    return {
-        isPrompt: true,
-        promptData: {
-            type: 'multiple_choice',
-            question: question.trim(),
-            options: collectedOptions.map(opt => {
-                // Check if this option requires text input using module-level patterns
-                const requiresTextInput = TEXT_INPUT_PATTERNS.some(pattern => pattern.test(opt.label));
-                return {
-                    number: opt.number,
-                    label: opt.label,
-                    isDefault: opt.isDefault,
-                    requiresTextInput,
-                };
-            }),
-            status: 'pending',
-            instructionText,
-        },
-        cleanContent: question.trim(),
-        rawContent: truncateRawContent(output.trim()), // Issue #235: complete prompt output (truncated) [MF-001]
-    };
+    const question = extractQuestionText(lines, questionEndIndex);
+    const instructionText = extractInstructionText(lines, questionEndIndex, effectiveEnd);
+    return buildMultipleChoiceResult(question, collectedOptions, instructionText, output);
 }
 /**
  * Get tmux input string for an answer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commandmate",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Git worktree management with Claude CLI and tmux sessions",
   "repository": {
     "type": "git",