@jojonax/codex-copilot 1.0.3 → 1.2.0

package/src/utils/provider.js

@@ -0,0 +1,415 @@
+/**
+ * AI Provider Registry — supports multiple AI coding tools
+ * 
+ * Each provider has its own invocation pattern:
+ *   - Codex CLI:    piped stdin → codex exec --full-auto
+ *   - Claude Code:  -p flag + --allowedTools for safe auto-execution
+ *   - Cursor Agent: cursor-agent CLI with -p headless mode
+ *   - Gemini CLI:   gemini -p for non-interactive prompt
+ *   - Codex Desktop / Cursor IDE / Antigravity IDE: clipboard + manual
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { log } from './logger.js';
+import { ask } from './prompt.js';
+import { automator } from './automator.js';
+
+// ──────────────────────────────────────────────
+// Provider Registry — each provider is unique
+// ──────────────────────────────────────────────
+
+const PROVIDERS = {
+  // ─── CLI Providers (auto-execute) ───
+
+  'codex-cli': {
+    name: 'Codex CLI',
+    type: 'cli',
+    detect: 'codex',
+    // Codex uses piped stdin: cat file | codex exec --full-auto -
+    buildCommand: (promptPath, cwd) =>
+      `cat ${shellEscape(promptPath)} | codex exec --full-auto -`,
+    description: 'OpenAI Codex CLI — pipes prompt via stdin',
+  },
+
+  'claude-code': {
+    name: 'Claude Code',
+    type: 'cli',
+    detect: 'claude',
+    // Claude Code uses -p (print/non-interactive) + --allowedTools for permissions
+    // Reads the file content and passes as argument (not piped)
+    buildCommand: (promptPath, cwd) => {
+      const escaped = shellEscape(promptPath);
+      // Use subshell to read file content into -p argument
+      return `claude -p "$(cat ${escaped})" --allowedTools "Bash(git*),Read,Write,Edit"`;
+    },
+    description: 'Anthropic Claude Code CLI — -p mode with tool permissions',
+  },
+
+  'cursor-agent': {
+    name: 'Cursor Agent',
+    type: 'cli',
+    detect: 'cursor-agent',
+    // Cursor Agent uses -p flag for headless/non-interactive mode
+    buildCommand: (promptPath, cwd) => {
+      const escaped = shellEscape(promptPath);
+      return `cursor-agent -p "$(cat ${escaped})"`;
+    },
+    description: 'Cursor Agent CLI — headless -p mode',
+  },
+
+  'gemini-cli': {
+    name: 'Gemini CLI',
+    type: 'cli',
+    detect: 'gemini',
+    // Gemini CLI uses -p for non-interactive prompt execution
+    buildCommand: (promptPath, cwd) => {
+      const escaped = shellEscape(promptPath);
+      return `gemini -p "$(cat ${escaped})"`;
+    },
+    description: 'Google Gemini CLI — non-interactive -p mode',
+  },
+
+  // ─── IDE Providers (clipboard + manual) ───
+
+  'codex-desktop': {
+    name: 'Codex Desktop',
+    type: 'ide',
+    instructions: 'Open Codex Desktop → paste the prompt → execute',
+    displayPrompt: true, // Show the prompt content in terminal box
+  },
+
+  'cursor': {
+    name: 'Cursor IDE',
+    type: 'ide',
+    instructions: 'Open Cursor → Ctrl/Cmd+I (Composer) → paste the prompt → run as Agent',
+    displayPrompt: false, // Too long to display, just copy to clipboard
+  },
+
+  'antigravity': {
+    name: 'Antigravity (Gemini)',
+    type: 'ide',
+    instructions: 'Open Antigravity → paste the prompt into chat → execute',
+    displayPrompt: false,
+  },
+};
+
+/**
+ * Get a provider by ID
+ */
+export function getProvider(id) {
+  return PROVIDERS[id] || null;
+}
+
+/**
+ * Get all provider IDs
+ */
+export function getAllProviderIds() {
+  return Object.keys(PROVIDERS);
+}
+
+/**
+ * Detect which CLI providers are installed on the system
+ * @returns {string[]} list of available provider IDs
+ */
+export function detectAvailable() {
+  const available = [];
+  for (const [id, prov] of Object.entries(PROVIDERS)) {
+    if (prov.type === 'cli' && prov.detect) {
+      try {
+        const cmd = process.platform === 'win32'
+          ? `where ${prov.detect}`
+          : `which ${prov.detect}`;
+        execSync(cmd, { stdio: 'pipe' });
+        available.push(id);
+      } catch {
+        // Not installed
+      }
+    }
+  }
+  return available;
+}
+
+/**
+ * Build the selection menu for init
+ * Groups CLIs first (with detection status), then IDEs
+ * @returns {{ label: string, value: string }[]}
+ */
+export function buildProviderChoices() {
+  const detected = detectAvailable();
+  const choices = [];
+
+  // CLI providers first with detection indicator
+  for (const [id, prov] of Object.entries(PROVIDERS)) {
+    if (prov.type === 'cli') {
+      const installed = detected.includes(id);
+      const tag = installed ? ' ✓ detected' : '';
+      choices.push({
+        label: `${prov.name}${tag} — ${prov.description}`,
+        value: id,
+        available: installed,
+      });
+    }
+  }
+
+  // IDE providers — show auto-paste capability if recipe exists
+  for (const [id, prov] of Object.entries(PROVIDERS)) {
+    if (prov.type === 'ide') {
+      const hasAutoPaste = automator.hasRecipe(id);
+      const tag = hasAutoPaste ? 'auto-paste' : 'clipboard + manual';
+      choices.push({
+        label: `${prov.name} — ${tag}`,
+        value: id,
+        available: true,
+      });
+    }
+  }
+
+  return choices;
+}
+
+/**
+ * Execute a prompt using the configured provider
+ * 
+ * CLI providers: auto-execute via their specific command
+ * IDE providers: copy to clipboard + display instructions + wait
+ * 
+ * @param {string} providerId - Provider ID from config
+ * @param {string} promptPath - Absolute path to prompt file
+ * @param {string} cwd - Working directory
+ * @returns {Promise<boolean>} true if execution succeeded
+ */
+export async function executePrompt(providerId, promptPath, cwd) {
+  const prov = PROVIDERS[providerId];
+
+  if (!prov) {
+    log.warn(`Unknown provider '${providerId}', falling back to clipboard mode`);
+    return await clipboardFallback(promptPath);
+  }
+
+  if (prov.type === 'cli') {
+    return await executeCLI(prov, providerId, promptPath, cwd);
+  } else {
+    return await executeIDE(prov, providerId, promptPath);
+  }
+}
+
+/**
+ * Execute via CLI provider — each tool has its own command pattern
+ */
+async function executeCLI(prov, providerId, promptPath, cwd) {
+  // Verify the CLI is still available
+  if (prov.detect) {
+    try {
+      const cmd = process.platform === 'win32'
+        ? `where ${prov.detect}`
+        : `which ${prov.detect}`;
+      execSync(cmd, { stdio: 'pipe' });
+    } catch {
+      log.warn(`${prov.name} not found in PATH, falling back to clipboard mode`);
+      return await clipboardFallback(promptPath);
+    }
+  }
+
+  const command = prov.buildCommand(promptPath, cwd);
+  log.info(`Executing via ${prov.name}...`);
+  log.dim(`  → ${command.substring(0, 80)}${command.length > 80 ? '...' : ''}`);
+
+  try {
+    execSync(command, { cwd, stdio: 'inherit', timeout: 0 });
+    log.info(`${prov.name} execution complete`);
+    return true;
+  } catch (err) {
+    log.warn(`${prov.name} execution failed: ${err.message}`);
+
+    // For quota exhaustion / auth errors, give a clear message
+    if (err.message.includes('rate_limit') || err.message.includes('quota') ||
+        err.message.includes('429') || err.message.includes('insufficient')) {
+      log.error('⚠ Possible quota exhaustion — checkpoint saved, you can resume later');
+    }
+
+    log.warn('Falling back to clipboard mode');
+    return await clipboardFallback(promptPath);
+  }
+}
+
+/**
+ * Execute via IDE provider
+ * 
+ * Priority: auto-paste (if IDE running) → manual clipboard fallback
+ */
+async function executeIDE(prov, providerId, promptPath) {
+  const prompt = readFileSync(promptPath, 'utf-8');
+
+  // ── Try auto-paste first ──
+  if (automator.hasRecipe(providerId)) {
+    if (automator.isIDERunning(providerId)) {
+      log.info(`${prov.name} detected — attempting auto-paste...`);
+      const ok = automator.activateAndPaste(providerId, prompt);
+      if (ok) {
+        log.info(`✅ Prompt auto-pasted into ${prov.name}`);
+        log.blank();
+        await ask(`Press Enter after ${prov.name} development is complete...`);
+        return true;
+      }
+      log.warn('Auto-paste failed, falling back to manual mode');
+    } else {
+      log.warn(`${prov.name} is not running — using clipboard mode`);
+    }
+  }
+
+  // ── Manual fallback ──
+  log.blank();
+  log.info(`📋 ${prov.instructions}`);
+  log.dim(`   Prompt file: ${promptPath}`);
+  log.blank();
+
+  // Some providers benefit from seeing the prompt in terminal
+  if (prov.displayPrompt) {
+    const lines = prompt.split('\n');
+    const maxLines = 30;
+    const show = lines.slice(0, maxLines);
+    console.log('  ┌─── Prompt Preview ─────────────────────────────────────┐');
+    for (const line of show) {
+      console.log(`  │ ${line}`);
+    }
+    if (lines.length > maxLines) {
+      console.log(`  │ ... (${lines.length - maxLines} more lines — see full file)`);
+    }
+    console.log('  └────────────────────────────────────────────────────────┘');
+    log.blank();
+  }
+
+  copyToClipboard(prompt);
+
+  await ask(`Press Enter after ${prov.name} development is complete...`);
+  return true;
+}
+
+/**
+ * Fallback: copy to clipboard and wait for any provider
+ */
+async function clipboardFallback(promptPath) {
+  const prompt = readFileSync(promptPath, 'utf-8');
+
+  log.blank();
+  log.info('📋 Paste the prompt into your AI coding tool and execute');
+  log.dim(`   Prompt file: ${promptPath}`);
+  log.blank();
+
+  copyToClipboard(prompt);
+
+  await ask('Press Enter after development is complete...');
+  return true;
+}
+
+function copyToClipboard(text) {
+  try {
+    if (process.platform === 'darwin') {
+      execSync('pbcopy', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+    } else if (process.platform === 'linux') {
+      // Try xclip first, then xsel
+      try {
+        execSync('xclip -selection clipboard', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+      } catch {
+        execSync('xsel --clipboard --input', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+      }
+    }
+    // Windows: skip — no good CLI clipboard tool
+    log.info('📋 Copied to clipboard');
+  } catch {
+    log.dim('(Could not copy to clipboard — copy the file manually)');
+  }
+}
+
+function shellEscape(str) {
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+
+/**
+ * Lightweight AI query — capture output rather than inherit stdio.
+ * Only works for CLI providers. Returns null for IDE providers.
+ * 
+ * @param {string} providerId - Provider ID
+ * @param {string} question - The question/prompt text
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string|null>} AI response text, or null if unsupported/failed
+ */
+export async function queryAI(providerId, question, cwd) {
+  const prov = PROVIDERS[providerId];
+  if (!prov || prov.type !== 'cli') return null;
+
+  // Verify CLI is available
+  if (prov.detect) {
+    try {
+      const cmd = process.platform === 'win32'
+        ? `where ${prov.detect}`
+        : `which ${prov.detect}`;
+      execSync(cmd, { stdio: 'pipe' });
+    } catch {
+      return null;
+    }
+  }
+
+  // Write question to temp file
+  const tmpPath = resolve(cwd, '.codex-copilot/_query_prompt.md');
+  writeFileSync(tmpPath, question);
+
+  const command = prov.buildCommand(tmpPath, cwd);
+
+  try {
+    const output = execSync(command, {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 60000, // 60s timeout for classification
+    });
+    return output.trim();
+  } catch (err) {
+    log.dim(`AI query failed: ${(err.message || '').substring(0, 80)}`);
+    return null;
+  }
+}
+
+/**
+ * Use AI to classify code review feedback.
+ * 
+ * Returns 'pass' if AI determines no actionable issues,
+ * 'fix' if there are issues to address, or null if classification failed.
+ * 
+ * @param {string} providerId - Provider ID
+ * @param {string} feedbackText - The collected review feedback
+ * @param {string} cwd - Working directory
+ * @returns {Promise<'pass'|'fix'|null>}
+ */
+export async function classifyReview(providerId, feedbackText, cwd) {
+  const classificationPrompt = `You are a code review classifier. Your ONLY job is to determine if the following code review feedback contains actionable issues that require code changes.
+
+## Code Review Feedback
+${feedbackText}
+
+## Instructions
+- If the review says the code looks good, has no issues, is purely informational, or explicitly states no changes are needed: output exactly PASS
+- If the review requests specific code changes, points out bugs, security issues, or improvements that need action: output exactly FIX
+
+IMPORTANT: Output ONLY a single word on the first line: either PASS or FIX. No other text.`;
+
+  const response = await queryAI(providerId, classificationPrompt, cwd);
+  if (!response) return null;
+
+  // Parse the first meaningful line
+  const firstLine = response.split('\n').map(l => l.trim()).find(l => l.length > 0);
+  if (!firstLine) return null;
+
+  const upper = firstLine.toUpperCase();
+  if (upper.includes('PASS')) return 'pass';
+  if (upper.includes('FIX')) return 'fix';
+
+  return null; // Ambiguous — caller decides fallback
+}
+
+export const provider = {
+  getProvider, getAllProviderIds, detectAvailable,
+  buildProviderChoices, executePrompt, queryAI, classifyReview,
+};