@automagik/genie 0.260202.1607 → 0.260202.1833

package/src/lib/orchestrator/patterns.ts

@@ -0,0 +1,277 @@
+/**
+ * Claude Code output patterns for state detection
+ *
+ * These patterns are used to identify different interactive states
+ * when Claude Code is running in a terminal session.
+ */
+
+export interface PatternMatch {
+  type: string;
+  pattern: RegExp;
+  extract?: (match: RegExpMatchArray) => Record<string, string>;
+}
+
+// Permission request patterns
+export const permissionPatterns: PatternMatch[] = [
+  {
+    type: 'bash_permission',
+    pattern: /Allow (?:Bash|bash|command|shell).*\?\s*(?:\[([YyNn])\/([YyNn])\])?/i,
+    extract: (match) => ({ default: match[1] || 'y' }),
+  },
+  {
+    type: 'file_permission',
+    pattern: /Allow (?:Edit|Write|Read|file|reading|writing|editing).*\?\s*(?:\[([YyNn])\/([YyNn])\])?/i,
+    extract: (match) => ({ default: match[1] || 'y' }),
+  },
+  {
+    type: 'mcp_permission',
+    pattern: /Allow (?:MCP|mcp|tool).*\?\s*(?:\[([YyNn])\/([YyNn])\])?/i,
+    extract: (match) => ({ default: match[1] || 'y' }),
+  },
+  {
+    type: 'generic_permission',
+    // Only match actual permission prompts, not questions with "proceed"
+    // Must start with "Allow" and typically have a tool/action context
+    pattern: /^(?:Allow|Confirm|Approve)\s+(?:this|the|once|always)?\s*(?:\w+)?\s*\?\s*(?:\[([YyNn])\/([YyNn])\])?/im,
+    extract: (match) => ({ default: match[1] || 'y' }),
+  },
+  {
+    type: 'claude_code_yes_no',
+    // Claude Code uses Yes/No prompts
+    pattern: /(?:Yes|No)\s*$/m,
+  },
+  {
+    type: 'claude_code_permission_block',
+    // Claude Code permission blocks often show the tool name
+    pattern: /(?:Allow|Run|Execute)\s+(?:once|always)/i,
+  },
+];
+
+// Question with options patterns
+export const questionPatterns: PatternMatch[] = [
+  {
+    type: 'numbered_options',
+    pattern: /\[(\d+)\]\s+(.+?)(?=\[(\d+)\]|$)/g,
+    extract: (match) => ({ number: match[1], option: match[2].trim() }),
+  },
+  {
+    type: 'lettered_options',
+    pattern: /\(([a-z])\)\s+(.+?)(?=\([a-z]\)|$)/gi,
+    extract: (match) => ({ letter: match[1], option: match[2].trim() }),
+  },
+  {
+    type: 'yes_no_question',
+    pattern: /\?\s*\[([YyNn])\/([YyNn])\]\s*$/,
+    extract: (match) => ({ default: match[1] }),
+  },
+  {
+    type: 'claude_code_numbered_options',
+    // Claude Code uses "❯ 1." or "  2." format for menu selection
+    pattern: /(?:❯|>)?\s*(\d+)\.\s+(.+?)(?:\n|$)/g,
+    extract: (match) => ({ number: match[1], option: match[2].trim() }),
+  },
+  {
+    type: 'claude_code_plan_approval',
+    // Claude Code plan approval prompt
+    pattern: /Would you like to proceed\?/i,
+  },
+];
+
+// Error patterns
+export const errorPatterns: PatternMatch[] = [
+  {
+    type: 'error',
+    pattern: /(?:^|\n)\s*(?:Error|ERROR|error):\s*(.+)/,
+    extract: (match) => ({ message: match[1] }),
+  },
+  {
+    type: 'failed',
+    pattern: /(?:^|\n)\s*(?:Failed|FAILED|failed):\s*(.+)/,
+    extract: (match) => ({ message: match[1] }),
+  },
+  {
+    type: 'exception',
+    pattern: /(?:^|\n)\s*(?:Exception|EXCEPTION|Uncaught|Unhandled):\s*(.+)/,
+    extract: (match) => ({ message: match[1] }),
+  },
+  {
+    type: 'api_error',
+    pattern: /(?:API|api)\s+(?:error|Error|ERROR):\s*(.+)/,
+    extract: (match) => ({ message: match[1] }),
+  },
+];
+
+// Completion/success patterns
+export const completionPatterns: PatternMatch[] = [
+  {
+    type: 'checkmark',
+    pattern: /[✓✔☑︎]/,
+  },
+  {
+    type: 'success_message',
+    pattern: /(?:Successfully|Completed|Done|Finished|Created|Updated|Saved)/i,
+  },
+  {
+    type: 'task_complete',
+    pattern: /(?:task|operation|process)\s+(?:complete|completed|finished|done)/i,
+  },
+];
+
+// Working/thinking patterns
+export const workingPatterns: PatternMatch[] = [
+  {
+    type: 'thinking',
+    pattern: /(?:Thinking|thinking|Processing|processing)\.\.\./,
+  },
+  {
+    type: 'spinner',
+    pattern: /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⣾⣽⣻⢿⡿⣟⣯⣷]/,
+  },
+  {
+    type: 'loading',
+    pattern: /(?:Loading|loading|Working|working)\.\.\./,
+  },
+  {
+    type: 'claude_code_working',
+    // Claude Code shows tool icons when working
+    pattern: /[🛠️🔧⚙️]\s*(?:Read|Edit|Write|Bash|Glob|Grep|Task)/,
+  },
+  {
+    type: 'claude_code_streaming',
+    // Partial response streaming
+    pattern: /▌$/,
+  },
+  {
+    type: 'claude_code_propagating',
+    // Claude shows "Propagating..." when applying changes
+    pattern: /Propagating…/,
+  },
+];
+
+// Idle/prompt patterns - Claude Code is waiting for input
+export const idlePatterns: PatternMatch[] = [
+  {
+    type: 'claude_prompt',
+    // Look for the Claude Code prompt character (typically > or similar)
+    // But NOT when followed by a number (that's a menu)
+    pattern: /(?:^|\n)\s*>\s*$/,
+  },
+  {
+    type: 'claude_code_prompt',
+    // Claude Code prompt with ❯ alone (NOT followed by number - that's a menu)
+    // Match ❯ at end of line, or ❯ followed by text (user input)
+    pattern: /❯\s*(?!\d\.)/,
+  },
+  {
+    type: 'claude_code_input_line',
+    // Claude Code shows ❯ followed by user's typed input, then a line of dashes
+    // This indicates the input prompt is active
+    pattern: /❯\s*.+\n─+\n/,
+  },
+  {
+    type: 'idle_indicator',
+    // Claude Code status bar showing idle
+    pattern: /\|\s*idle\s*$/i,
+  },
+  {
+    type: 'input_prompt',
+    // Generic input prompt
+    pattern: /(?:^|\n)(?:Enter|Input|Type|Provide).*:\s*$/i,
+  },
+];
+
+// Tool use patterns
+export const toolUsePatterns: PatternMatch[] = [
+  {
+    type: 'run_command',
+    pattern: /(?:Run|Running|Executing)\s+(?:command|bash):\s*(.+)/i,
+    extract: (match) => ({ command: match[1] }),
+  },
+  {
+    type: 'read_file',
+    pattern: /(?:Read|Reading)\s+(?:file):\s*(.+)/i,
+    extract: (match) => ({ file: match[1] }),
+  },
+  {
+    type: 'write_file',
+    pattern: /(?:Write|Writing|Edit|Editing)\s+(?:file|to):\s*(.+)/i,
+    extract: (match) => ({ file: match[1] }),
+  },
+  {
+    type: 'search',
+    pattern: /(?:Search|Searching|Grep|Glob)(?:ing)?:\s*(.+)/i,
+    extract: (match) => ({ query: match[1] }),
+  },
+];
+
+// Plan file patterns - extract plan file paths from Claude Code output
+export const planFilePatterns: PatternMatch[] = [
+  {
+    type: 'claude_plan_file',
+    // Matches: ~/.claude/plans/something.md or full paths
+    pattern: /(~\/\.claude\/plans\/[\w-]+\.md|\/[^\s]+\/\.claude\/plans\/[\w-]+\.md)/,
+    extract: (match) => ({ path: match[1] }),
+  },
+];
+
+// ANSI escape code stripper
+export function stripAnsi(str: string): string {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+}
+
+// Extract plan file path from output
+export function extractPlanFile(content: string): string | null {
+  const cleanContent = stripAnsi(content);
+  const match = getFirstMatch(cleanContent, planFilePatterns);
+  if (match?.extracted?.path) {
+    // Expand ~ to home directory
+    let path = match.extracted.path;
+    if (path.startsWith('~')) {
+      path = path.replace('~', process.env.HOME || '');
+    }
+    return path;
+  }
+  return null;
+}
+
+// Match all patterns of a type against content
+export function matchPatterns(
+  content: string,
+  patterns: PatternMatch[]
+): { type: string; match: RegExpMatchArray; extracted?: Record<string, string> }[] {
+  const cleanContent = stripAnsi(content);
+  const matches: { type: string; match: RegExpMatchArray; extracted?: Record<string, string> }[] = [];
+
+  for (const pattern of patterns) {
+    const regex = new RegExp(pattern.pattern.source, pattern.pattern.flags || 'g');
+    let match: RegExpMatchArray | null;
+
+    while ((match = regex.exec(cleanContent)) !== null) {
+      matches.push({
+        type: pattern.type,
+        match,
+        extracted: pattern.extract ? pattern.extract(match) : undefined,
+      });
+
+      // If not global, only match once
+      if (!pattern.pattern.flags?.includes('g')) break;
+    }
+  }
+
+  return matches;
+}
+
+// Check if content matches any pattern in a set
+export function hasMatch(content: string, patterns: PatternMatch[]): boolean {
+  return matchPatterns(content, patterns).length > 0;
+}
+
+// Get the first match from a pattern set
+export function getFirstMatch(
+  content: string,
+  patterns: PatternMatch[]
+): { type: string; match: RegExpMatchArray; extracted?: Record<string, string> } | null {
+  const matches = matchPatterns(content, patterns);
+  return matches.length > 0 ? matches[0] : null;
+}

package/src/lib/orchestrator/state-detector.ts

@@ -0,0 +1,339 @@
+/**
+ * State detector for Claude Code sessions
+ *
+ * Analyzes terminal output to determine the current interactive state
+ * of a Claude Code session.
+ */
+
+import {
+  permissionPatterns,
+  questionPatterns,
+  errorPatterns,
+  completionPatterns,
+  workingPatterns,
+  idlePatterns,
+  toolUsePatterns,
+  stripAnsi,
+  hasMatch,
+  getFirstMatch,
+  matchPatterns,
+} from './patterns.js';
+
+export type ClaudeStateType =
+  | 'idle'
+  | 'working'
+  | 'permission'
+  | 'question'
+  | 'error'
+  | 'complete'
+  | 'tool_use'
+  | 'unknown';
+
+export interface ClaudeState {
+  type: ClaudeStateType;
+  detail?: string;
+  options?: string[];
+  timestamp: number;
+  rawOutput: string;
+  confidence: number; // 0-1, how confident we are in this detection
+}
+
+export interface StateDetectorOptions {
+  /** Number of lines from end to analyze (default: 50) */
+  linesToAnalyze?: number;
+  /** Minimum confidence threshold (default: 0.5) */
+  minConfidence?: number;
+}
+
+/**
+ * Detect the current state of a Claude Code session from terminal output
+ */
+export function detectState(
+  output: string,
+  options: StateDetectorOptions = {}
+): ClaudeState {
+  const { linesToAnalyze = 50, minConfidence = 0.3 } = options;
+
+  // Get the last N lines for analysis
+  const lines = output.split('\n');
+  const recentLines = lines.slice(-linesToAnalyze).join('\n');
+  const cleanOutput = stripAnsi(recentLines);
+
+  const timestamp = Date.now();
+  const baseState = {
+    timestamp,
+    rawOutput: recentLines,
+  };
+
+  // Check for permission requests (highest priority - needs user action)
+  const permissionMatch = getFirstMatch(cleanOutput, permissionPatterns);
+  if (permissionMatch) {
+    return {
+      ...baseState,
+      type: 'permission',
+      detail: permissionMatch.type.replace('_permission', ''),
+      confidence: 0.9,
+    };
+  }
+
+  // Check for plan approval or question prompts
+  const hasPlanApproval = hasMatch(cleanOutput, questionPatterns.filter(p => p.type === 'claude_code_plan_approval'));
+
+  // Check for questions with options - only look at last 15 lines for actual menu options
+  const lastMenuLines = lines.slice(-15).join('\n');
+  const cleanMenuLines = stripAnsi(lastMenuLines);
+  const questionMatches = matchPatterns(cleanMenuLines, questionPatterns);
+
+  if (questionMatches.length > 0 || hasPlanApproval) {
+    // Extract options only from the numbered list at the end
+    const menuOptions = questionMatches
+      .filter((m) => m.type === 'claude_code_numbered_options' && m.extracted?.option)
+      .map((m) => m.extracted!.option);
+
+    if (menuOptions.length >= 2 || hasPlanApproval) {
+      return {
+        ...baseState,
+        type: 'question',
+        options: menuOptions.length > 0 ? menuOptions : undefined,
+        detail: hasPlanApproval ? 'plan_approval' : undefined,
+        confidence: 0.85,
+      };
+    }
+
+    // Fall back to other option types
+    const otherOptions = questionMatches
+      .filter((m) => m.extracted?.option && m.type !== 'claude_code_numbered_options')
+      .map((m) => m.extracted!.option);
+
+    if (otherOptions.length >= 2) {
+      return {
+        ...baseState,
+        type: 'question',
+        options: otherOptions,
+        confidence: 0.85,
+      };
+    }
+  }
+
+  // Check for yes/no questions
+  const ynMatch = questionMatches.find((m) => m.type === 'yes_no_question');
+  if (ynMatch) {
+    return {
+      ...baseState,
+      type: 'question',
+      options: ['Yes', 'No'],
+      detail: `default: ${ynMatch.extracted?.default || 'y'}`,
+      confidence: 0.85,
+    };
+  }
+
+  // Check for errors
+  const errorMatch = getFirstMatch(cleanOutput, errorPatterns);
+  if (errorMatch) {
+    return {
+      ...baseState,
+      type: 'error',
+      detail: errorMatch.extracted?.message || errorMatch.match[0],
+      confidence: 0.8,
+    };
+  }
+
+  // Check for tool use
+  const toolMatch = getFirstMatch(cleanOutput, toolUsePatterns);
+  if (toolMatch) {
+    return {
+      ...baseState,
+      type: 'tool_use',
+      detail: `${toolMatch.type}: ${toolMatch.extracted?.command || toolMatch.extracted?.file || toolMatch.extracted?.query || ''}`,
+      confidence: 0.75,
+    };
+  }
+
+  // Check for working/thinking indicators
+  if (hasMatch(cleanOutput, workingPatterns)) {
+    return {
+      ...baseState,
+      type: 'working',
+      confidence: 0.7,
+    };
+  }
+
+  // Check for completion indicators
+  if (hasMatch(cleanOutput, completionPatterns)) {
+    return {
+      ...baseState,
+      type: 'complete',
+      confidence: 0.6,
+    };
+  }
+
+  // Check for idle/prompt state
+  // Look at just the last few lines for prompt detection
+  const lastFewLines = lines.slice(-5).join('\n');
+  const cleanLastLines = stripAnsi(lastFewLines);
+
+  if (hasMatch(cleanLastLines, idlePatterns)) {
+    return {
+      ...baseState,
+      type: 'idle',
+      confidence: 0.7,
+    };
+  }
+
+  // Check for common Claude Code prompt patterns more specifically
+  // Claude Code often shows a ">" prompt when waiting for input
+  const trimmedLast = cleanLastLines.trim();
+  if (trimmedLast.endsWith('>') || trimmedLast.match(/>\s*$/)) {
+    return {
+      ...baseState,
+      type: 'idle',
+      detail: 'prompt detected',
+      confidence: 0.65,
+    };
+  }
+
+  // Default: unknown state
+  return {
+    ...baseState,
+    type: 'unknown',
+    confidence: minConfidence,
+  };
+}
+
+/**
+ * Detect if output appears to be complete based on multiple signals
+ */
+export function detectCompletion(
+  output: string,
+  previousOutput: string
+): { complete: boolean; reason: string; confidence: number } {
+  const currentState = detectState(output);
+  const prevState = detectState(previousOutput);
+
+  // Permission or question = definitely not complete (needs user input)
+  if (currentState.type === 'permission' || currentState.type === 'question') {
+    return {
+      complete: false,
+      reason: `awaiting ${currentState.type}`,
+      confidence: 0.95,
+    };
+  }
+
+  // Error state = complete (but with error)
+  if (currentState.type === 'error') {
+    return {
+      complete: true,
+      reason: 'error detected',
+      confidence: 0.8,
+    };
+  }
+
+  // Idle state = likely complete
+  if (currentState.type === 'idle') {
+    return {
+      complete: true,
+      reason: 'idle prompt detected',
+      confidence: currentState.confidence,
+    };
+  }
+
+  // Explicit completion markers
+  if (currentState.type === 'complete') {
+    return {
+      complete: true,
+      reason: 'completion marker detected',
+      confidence: currentState.confidence,
+    };
+  }
+
+  // Transition from working to not working
+  if (prevState.type === 'working' && currentState.type !== 'working') {
+    return {
+      complete: true,
+      reason: 'work finished',
+      confidence: 0.6,
+    };
+  }
+
+  // Still working
+  if (currentState.type === 'working' || currentState.type === 'tool_use') {
+    return {
+      complete: false,
+      reason: 'still working',
+      confidence: 0.7,
+    };
+  }
+
+  // Unknown - inconclusive
+  return {
+    complete: false,
+    reason: 'unknown state',
+    confidence: 0.3,
+  };
+}
+
+/**
+ * Extract permission details from output
+ */
+export function extractPermissionDetails(output: string): {
+  type: string;
+  command?: string;
+  file?: string;
+} | null {
+  const cleanOutput = stripAnsi(output);
+  const match = getFirstMatch(cleanOutput, permissionPatterns);
+
+  if (!match) return null;
+
+  // Try to extract command or file from surrounding context
+  const lines = cleanOutput.split('\n');
+  const matchLine = lines.findIndex((line) =>
+    line.match(permissionPatterns[0].pattern) ||
+    line.match(permissionPatterns[1].pattern) ||
+    line.match(permissionPatterns[2].pattern)
+  );
+
+  let command: string | undefined;
+  let file: string | undefined;
+
+  // Look at lines before the permission prompt for context
+  if (matchLine > 0) {
+    const contextLines = lines.slice(Math.max(0, matchLine - 5), matchLine).join('\n');
+
+    // Extract command
+    const cmdMatch = contextLines.match(/(?:Command|command|Bash|bash):\s*(.+)/);
+    if (cmdMatch) {
+      command = cmdMatch[1].trim();
+    }
+
+    // Extract file
+    const fileMatch = contextLines.match(/(?:File|file|Path|path):\s*(.+)/);
+    if (fileMatch) {
+      file = fileMatch[1].trim();
+    }
+  }
+
+  return {
+    type: match.type.replace('_permission', ''),
+    command,
+    file,
+  };
+}
+
+/**
+ * Extract question options from output
+ */
+export function extractQuestionOptions(output: string): string[] {
+  const cleanOutput = stripAnsi(output);
+  const matches = matchPatterns(cleanOutput, questionPatterns);
+
+  const options: string[] = [];
+
+  for (const match of matches) {
+    if (match.extracted?.option) {
+      options.push(match.extracted.option);
+    }
+  }
+
+  return options;
+}

package/src/lib/version.ts

@@ -1,5 +1,5 @@
 // Runtime version (baked in at build time)
-export const VERSION = '0.260202.1607';
+export const VERSION = '0.260202.1833';
 
 // Generate version string from current datetime
 // Format: 0.YYMMDD.HHMM (e.g., 0.260201.1430 = Feb 1, 2026 at 14:30)