@jojonax/codex-copilot 1.0.3 → 1.2.0

package/src/commands/run.js

@@ -2,15 +2,17 @@
  * codex-copilot run - Main orchestration loop
  * 
  * Executes tasks one by one: Develop → PR → Review → Fix → Merge → Next
+ * Features fine-grained checkpoint/resume at every sub-step.
  */
 
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
-import { execSync } from 'child_process';
 import { log, progressBar } from '../utils/logger.js';
 import { git } from '../utils/git.js';
 import { github } from '../utils/github.js';
-import { ask, confirm, closePrompt } from '../utils/prompt.js';
+import { ask, closePrompt } from '../utils/prompt.js';
+import { createCheckpoint } from '../utils/checkpoint.js';
+import { provider } from '../utils/provider.js';
 
 function readJSON(path) {
   return JSON.parse(readFileSync(path, 'utf-8'));
@@ -22,14 +24,14 @@ function writeJSON(path, data) {
 
 export async function run(projectDir) {
   const tasksPath = resolve(projectDir, '.codex-copilot/tasks.json');
-  const statePath = resolve(projectDir, '.codex-copilot/state.json');
   const configPath = resolve(projectDir, '.codex-copilot/config.json');
+  const checkpoint = createCheckpoint(projectDir);
 
   let tasks;
   let state;
   try {
     tasks = readJSON(tasksPath);
-    state = readJSON(statePath);
+    state = checkpoint.load();
   } catch (err) {
     log.error(`Failed to read task/state files: ${err.message}`);
     log.warn('Files may be corrupted. Run: codex-copilot reset');
@@ -47,25 +49,63 @@ export async function run(projectDir) {
   }
 
   const baseBranch = config.base_branch || 'main';
+  const providerId = config.provider || 'codex-cli';
   const maxReviewRounds = config.max_review_rounds || 2;
   const pollInterval = config.review_poll_interval || 60;
   const waitTimeout = config.review_wait_timeout || 600;
 
+  const providerInfo = provider.getProvider(providerId);
+  log.info(`AI Provider: ${providerInfo ? providerInfo.name : providerId}`);
+
+  // ===== Graceful shutdown handler =====
+  let shuttingDown = false;
+  const gracefulShutdown = () => {
+    if (shuttingDown) {
+      log.warn('Force exit');
+      process.exit(1);
+    }
+    shuttingDown = true;
+    log.blank();
+    log.warn('Interrupt received — saving checkpoint...');
+    // State is already saved at each step, just need to save tasks.json
+    writeJSON(tasksPath, tasks);
+    log.info('✅ Checkpoint saved. Run `codex-copilot run` to resume.');
+    log.blank();
+    closePrompt();
+    process.exit(0);
+  };
+  process.on('SIGINT', gracefulShutdown);
+  process.on('SIGTERM', gracefulShutdown);
+
   log.title('🚀 Starting automated development loop');
   log.blank();
   log.info(`Project: ${tasks.project}`);
   log.info(`Total tasks: ${tasks.total}`);
-  log.info(`Completed: ${state.current_task}`);
   log.info(`Base branch: ${baseBranch}`);
+
+  // ===== Pre-flight: ensure base branch is committed & pushed =====
+  await ensureBaseReady(projectDir, baseBranch);
+
+  // Show resume info if resuming mid-task
+  if (state.phase && state.current_task > 0) {
+    log.blank();
+    log.info(`⏩ Resuming task #${state.current_task} from: ${state.phase} → ${state.phase_step}`);
+  }
+
+  const completedCount = tasks.tasks.filter(t => t.status === 'completed').length;
   log.blank();
-  progressBar(state.current_task, tasks.total, `${state.current_task}/${tasks.total} tasks done`);
+  progressBar(completedCount, tasks.total, `${completedCount}/${tasks.total} tasks done`);
   log.blank();
 
   // Execute tasks one by one
   for (const task of tasks.tasks) {
-    if (task.id <= state.current_task) continue; // Skip completed
+    // Skip fully completed tasks
     if (task.status === 'completed' || task.status === 'skipped') continue;
 
+    // Skip tasks whose ID is below the completed threshold (and not the resuming task)
+    const isResumingTask = state.current_task === task.id && state.phase;
+    if (task.id < state.current_task && !isResumingTask) continue;
+
     log.blank();
     log.title(`━━━ Task ${task.id}/${tasks.total}: ${task.title} ━━━`);
     log.blank();
@@ -82,151 +122,183 @@ export async function run(projectDir) {
       }
     }
 
+    // Mark task as in_progress
+    task.status = 'in_progress';
+    writeJSON(tasksPath, tasks);
+
     // ===== Phase 1: Develop =====
-    await developPhase(projectDir, task, baseBranch);
+    if (!checkpoint.isStepDone(task.id, 'develop', 'codex_complete')) {
+      await developPhase(projectDir, task, baseBranch, checkpoint, providerId);
+    } else {
+      log.dim('⏩ Skipping develop phase (already completed)');
+    }
 
     // ===== Phase 2: Create PR =====
-    const prInfo = await prPhase(projectDir, task, baseBranch);
+    let prInfo;
+    if (!checkpoint.isStepDone(task.id, 'pr', 'pr_created')) {
+      prInfo = await prPhase(projectDir, task, baseBranch, checkpoint);
+    } else {
+      // PR already created, load from state
+      state = checkpoint.load();
+      prInfo = { number: state.current_pr, url: '' };
+      log.dim(`⏩ Skipping PR phase (PR #${prInfo.number} already created)`);
+    }
 
     // ===== Phase 3: Review loop =====
-    await reviewLoop(projectDir, task, prInfo, {
-      maxRounds: maxReviewRounds,
-      pollInterval,
-      waitTimeout,
-    });
+    if (!checkpoint.isStepDone(task.id, 'merge', 'merged')) {
+      await reviewLoop(projectDir, task, prInfo, {
+        maxRounds: maxReviewRounds,
+        pollInterval,
+        waitTimeout,
+      }, checkpoint, providerId);
+    } else {
+      log.dim('⏩ Skipping review phase (already completed)');
+    }
 
     // ===== Phase 4: Merge =====
-    await mergePhase(projectDir, task, prInfo, baseBranch);
+    if (!checkpoint.isStepDone(task.id, 'merge', 'merged')) {
+      await mergePhase(projectDir, task, prInfo, baseBranch, checkpoint);
+    } else {
+      log.dim('⏩ Skipping merge phase (already merged)');
+    }
 
-    // Update task state
+    // Mark task complete
     task.status = 'completed';
-    state.current_task = task.id;
-    state.current_pr = null;
-    state.review_round = 0;
     writeJSON(tasksPath, tasks);
-    writeJSON(statePath, state);
+    checkpoint.completeTask(task.id);
 
     log.blank();
-    progressBar(task.id, tasks.total, `${task.id}/${tasks.total} tasks done`);
+    const done = tasks.tasks.filter(t => t.status === 'completed').length;
+    progressBar(done, tasks.total, `${done}/${tasks.total} tasks done`);
     log.info(`✅ Task #${task.id} complete!`);
   }
 
   log.blank();
   log.title('🎉 All tasks complete!');
   log.blank();
+  process.removeListener('SIGINT', gracefulShutdown);
+  process.removeListener('SIGTERM', gracefulShutdown);
   closePrompt();
 }
 
 // ──────────────────────────────────────────────
 // Phase 1: Develop
 // ──────────────────────────────────────────────
-async function developPhase(projectDir, task, baseBranch) {
+async function developPhase(projectDir, task, baseBranch, checkpoint, providerId) {
   log.step('Phase 1/4: Develop');
 
-  // Switch to feature branch
-  git.checkoutBranch(projectDir, task.branch, baseBranch);
-  log.info(`Switched to branch: ${task.branch}`);
-
-  // Build development prompt
-  const devPrompt = buildDevPrompt(task);
-
-  // Check if CodeX CLI is available
-  const codexAvailable = isCodexAvailable();
-
-  if (codexAvailable) {
-    log.info('CodeX CLI detected, ready for auto-execution...');
-    const autoRun = await confirm('Auto-invoke CodeX for development?');
-    if (autoRun) {
-      try {
-        const promptPath = resolve(projectDir, '.codex-copilot/_current_prompt.md');
-        writeFileSync(promptPath, devPrompt);
-        execSync(`cat .codex-copilot/_current_prompt.md | codex exec --full-auto -`, {
-          cwd: projectDir,
-          stdio: 'inherit',
-        });
-        log.info('CodeX development complete');
-        return;
-      } catch (err) {
-        log.warn(`CodeX CLI invocation failed: ${err.message}`);
-        log.warn('Falling back to manual mode');
-      }
+  // Step 1: Switch to feature branch
+  if (!checkpoint.isStepDone(task.id, 'develop', 'branch_created')) {
+    git.checkoutBranch(projectDir, task.branch, baseBranch);
+    log.info(`Switched to branch: ${task.branch}`);
+    checkpoint.saveStep(task.id, 'develop', 'branch_created', { branch: task.branch });
+  } else {
+    // Ensure we're on the right branch
+    const current = git.currentBranch(projectDir);
+    if (current !== task.branch) {
+      git.checkoutBranch(projectDir, task.branch, baseBranch);
     }
+    log.dim('⏩ Branch already created');
   }
 
-  // Manual mode: display prompt, wait for user confirmation
-  log.blank();
-  console.log('  ┌─── Paste the following into CodeX Desktop to execute ───┐');
-  log.blank();
-  console.log(devPrompt.split('\n').map(l => `  │ ${l}`).join('\n'));
-  log.blank();
-  console.log('  └─────────────────────────────────────────────────────────┘');
-  log.blank();
-
-  // Also save prompt to file for easy copying
-  const promptPath = resolve(projectDir, '.codex-copilot/_current_prompt.md');
-  writeFileSync(promptPath, devPrompt);
-  log.dim('Prompt saved to .codex-copilot/_current_prompt.md (you can copy the file directly)');
-  log.blank();
-
-  // Try to copy to clipboard (via stdin to avoid shell injection)
-  copyToClipboard(devPrompt);
+  // Step 2: Build development prompt
+  if (!checkpoint.isStepDone(task.id, 'develop', 'prompt_ready')) {
+    const devPrompt = buildDevPrompt(task);
+    const promptPath = resolve(projectDir, '.codex-copilot/_current_prompt.md');
+    writeFileSync(promptPath, devPrompt);
+    checkpoint.saveStep(task.id, 'develop', 'prompt_ready', { branch: task.branch });
+    log.info('Development prompt generated');
+  } else {
+    log.dim('⏩ Prompt already generated');
+  }
 
-  await ask('Press Enter after CodeX development is complete...');
+  // Step 3: Execute via AI Provider
+  if (!checkpoint.isStepDone(task.id, 'develop', 'codex_complete')) {
+    const promptPath = resolve(projectDir, '.codex-copilot/_current_prompt.md');
+    const ok = await provider.executePrompt(providerId, promptPath, projectDir);
+    if (ok) {
+      log.info('Development complete');
+      checkpoint.saveStep(task.id, 'develop', 'codex_complete', { branch: task.branch });
+    }
+  }
 }
 
 // ──────────────────────────────────────────────
 // Phase 2: Create PR
 // ──────────────────────────────────────────────
-async function prPhase(projectDir, task, baseBranch) {
+async function prPhase(projectDir, task, baseBranch, checkpoint) {
   log.step('Phase 2/4: Submit PR');
 
-  // Ensure changes are committed
-  if (!git.isClean(projectDir)) {
-    log.info('Uncommitted changes detected, auto-committing...');
-    git.commitAll(projectDir, `feat(task-${task.id}): ${task.title}`);
+  // Step 1: Commit changes
+  if (!checkpoint.isStepDone(task.id, 'pr', 'committed')) {
+    if (!git.isClean(projectDir)) {
+      log.info('Uncommitted changes detected, auto-committing...');
+      git.commitAll(projectDir, `feat(task-${task.id}): ${task.title}`);
+    }
+    checkpoint.saveStep(task.id, 'pr', 'committed', { branch: task.branch });
+    log.info('Changes committed');
+  } else {
+    log.dim('⏩ Changes already committed');
   }
 
-  // Push
-  git.pushBranch(projectDir, task.branch);
-  log.info('Code pushed');
+  // Step 2: Push
+  if (!checkpoint.isStepDone(task.id, 'pr', 'pushed')) {
+    git.pushBranch(projectDir, task.branch);
+    checkpoint.saveStep(task.id, 'pr', 'pushed', { branch: task.branch });
+    log.info('Code pushed');
+  } else {
+    log.dim('⏩ Code already pushed');
+  }
 
-  // Create PR
-  const acceptanceList = Array.isArray(task.acceptance) && task.acceptance.length > 0
-    ? task.acceptance.map(a => `- [ ] ${a}`).join('\n')
-    : '- [ ] Feature works correctly';
-  const prBody = `## Task #${task.id}: ${task.title}\n\n${task.description}\n\n### Acceptance Criteria\n${acceptanceList}\n\n---\n*Auto-created by Codex-Copilot*`;
+  // Step 3: Create PR
+  if (!checkpoint.isStepDone(task.id, 'pr', 'pr_created')) {
+    const acceptanceList = Array.isArray(task.acceptance) && task.acceptance.length > 0
+      ? task.acceptance.map(a => `- [ ] ${a}`).join('\n')
+      : '- [ ] Feature works correctly';
+    const prBody = `## Task #${task.id}: ${task.title}\n\n${task.description}\n\n### Acceptance Criteria\n${acceptanceList}\n\n---\n*Auto-created by Codex-Copilot*`;
 
-  try {
-    const prInfo = github.createPR(projectDir, {
+    // Use auto-recovery: create → find existing → fix remote → retry
+    const prInfo = github.createPRWithRecovery(projectDir, {
       title: `feat(task-${task.id}): ${task.title}`,
       body: prBody,
       base: baseBranch,
       head: task.branch,
     });
-    log.info(`PR created: ${prInfo.url}`);
+    log.info(`PR ready: #${prInfo.number} ${prInfo.url}`);
+
+    checkpoint.saveStep(task.id, 'pr', 'pr_created', {
+      branch: task.branch,
+      current_pr: prInfo.number,
+    });
     return prInfo;
-  } catch (err) {
-    // PR may already exist
-    log.warn(`PR creation error: ${err.message}`);
-    const prNumber = await ask('Enter existing PR number:');
-    const parsed = parseInt(prNumber, 10);
-    if (isNaN(parsed) || parsed <= 0) {
-      log.error('Invalid PR number');
-      throw new Error('Invalid PR number');
-    }
-    return { number: parsed, url: '' };
   }
+
+  // If we get here, PR was already created — load from state
+  const state = checkpoint.load();
+  return { number: state.current_pr, url: '' };
 }
 
 // ──────────────────────────────────────────────
 // Phase 3: Review loop
 // ──────────────────────────────────────────────
-async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pollInterval, waitTimeout }) {
+async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pollInterval, waitTimeout }, checkpoint, providerId) {
   let maxRounds = _maxRounds;
   log.step('Phase 3/4: Waiting for review');
 
-  for (let round = 1; round <= maxRounds; round++) {
-    // Wait for review
+  // Resume from saved review round
+  const state = checkpoint.load();
+  const startRound = (state.current_task === task.id && state.review_round > 0)
+    ? state.review_round
+    : 1;
+
+  for (let round = startRound; round <= maxRounds; round++) {
+    // Step: Waiting for review
+    checkpoint.saveStep(task.id, 'review', 'waiting_review', {
+      branch: task.branch,
+      current_pr: prInfo.number,
+      review_round: round,
+    });
+
     log.info(`Waiting for review feedback... (timeout: ${waitTimeout}s)`);
     const gotReview = await waitForReview(projectDir, prInfo.number, pollInterval, waitTimeout);
 
@@ -240,22 +312,63 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
       break;
     }
 
+    // Step: Feedback received
+    checkpoint.saveStep(task.id, 'review', 'feedback_received', {
+      branch: task.branch,
+      current_pr: prInfo.number,
+      review_round: round,
+    });
+
     // Check review status
-    const state = github.getLatestReviewState(projectDir, prInfo.number);
-    log.info(`Review status: ${state}`);
+    const reviewState = github.getLatestReviewState(projectDir, prInfo.number);
+    log.info(`Review status: ${reviewState}`);
 
-    if (state === 'APPROVED') {
+    if (reviewState === 'APPROVED') {
       log.info('✅ Review approved!');
       return;
     }
 
-    // Collect review feedback
+    // Collect review feedback (raw — classification done by AI)
     const feedback = github.collectReviewFeedback(projectDir, prInfo.number);
     if (!feedback) {
-      log.info('No specific change requests found, proceeding');
+      log.info('No review feedback found — proceeding ✅');
+      return;
+    }
+
+    // Use AI to classify the review feedback
+    log.info('Classifying review feedback via AI...');
+    const classification = await provider.classifyReview(providerId, feedback, projectDir);
+
+    if (classification === 'pass') {
+      log.info('AI determined no actionable issues — proceeding ✅');
       return;
     }
 
+    if (classification === null) {
+      // AI classification failed — fall back to structural GitHub API signals
+      log.dim('AI classification unavailable, using structural fallback');
+      const inlineComments = github.getReviewComments(projectDir, prInfo.number);
+      const hasInlineComments = inlineComments && inlineComments.length > 0;
+
+      if (reviewState === 'CHANGES_REQUESTED') {
+        // Explicit change request — always treat as needing fixes
+        log.info('Review state: CHANGES_REQUESTED — entering fix phase');
+      } else if (reviewState === 'COMMENTED' && !hasInlineComments) {
+        // General comment with no code-level feedback — treat as passing
+        log.info('COMMENTED with no inline code comments — treating as passed ✅');
+        return;
+      } else if (!hasInlineComments) {
+        // Any other state (PENDING, null, etc.) with no inline comments — treat as passing
+        log.info('No inline code comments found — treating as passed ✅');
+        return;
+      } else {
+        // Has inline comments — treat as needing fixes
+        log.info(`Found ${inlineComments.length} inline code comment(s) — entering fix phase`);
+      }
+    }
+
+    // AI says FIX, or structural fallback indicates issues
+
     log.blank();
     log.warn(`Received review feedback (round ${round}/${maxRounds})`);
 
@@ -271,18 +384,28 @@ async function reviewLoop(projectDir, task, prInfo, { maxRounds: _maxRounds, pol
       }
     }
 
-    // Let CodeX fix
-    await fixPhase(projectDir, task, feedback, round);
+    // Let AI fix
+    await fixPhase(projectDir, task, feedback, round, providerId);
 
-    // Push fix
+    // Step: Fix applied
+    checkpoint.saveStep(task.id, 'review', 'fix_applied', {
+      branch: task.branch,
+      current_pr: prInfo.number,
+      review_round: round,
+    });
+
+    // Push fix — only if there are actual changes
     if (!git.isClean(projectDir)) {
       git.commitAll(projectDir, `fix(task-${task.id}): address review comments (round ${round})`);
+      git.pushBranch(projectDir, task.branch);
+      log.info('Fix pushed, waiting for next review round...');
+      // Brief wait for review bot to react
+      await sleep(10000);
+    } else {
+      // No actual changes were made by the fix — the AI determined nothing needed fixing
+      log.info('No changes needed after review — proceeding to merge ✅');
+      return;
     }
-    git.pushBranch(projectDir, task.branch);
-    log.info('Fix pushed, waiting for next review round...');
-
-    // Brief wait for review bot to react
-    await sleep(10000);
   }
 }
 
@@ -317,12 +440,12 @@ async function waitForReview(projectDir, prNumber, pollInterval, timeout) {
 // ──────────────────────────────────────────────
 // Fix phase
 // ──────────────────────────────────────────────
-async function fixPhase(projectDir, task, feedback, round) {
+async function fixPhase(projectDir, task, feedback, round, providerId) {
   log.step(`Fixing review comments (round ${round})`);
 
-  const fixPrompt = `The following are PR review comments. Please fix each one:
+  const fixPrompt = `Please fix the following review comments on Task #${task.id}: ${task.title}
 
-## Review Comments
+## Review Feedback
 ${feedback}
 
 ## Requirements
@@ -332,50 +455,21 @@ ${feedback}
 4. When done, run: git add -A && git commit -m "fix(task-${task.id}): address review round ${round}"
 `;
 
-  // Save to file and prompt user
+  // Save to file and execute via provider
   const promptPath = resolve(projectDir, '.codex-copilot/_current_prompt.md');
   writeFileSync(promptPath, fixPrompt);
 
-  // Try CodeX CLI
-  const codexAvailable = isCodexAvailable();
-
-  if (codexAvailable) {
-    const autoFix = await confirm('Auto-invoke CodeX to fix?');
-    if (autoFix) {
-      try {
-        execSync(`cat .codex-copilot/_current_prompt.md | codex exec --full-auto -`, {
-          cwd: projectDir,
-          stdio: 'inherit',
-        });
-        log.info('CodeX fix complete');
-        return;
-      } catch {
-        log.warn('CodeX CLI invocation failed, falling back to manual mode');
-      }
-    }
-  }
-
-  // Manual mode
-  log.blank();
-  log.dim('Review fix prompt saved to .codex-copilot/_current_prompt.md');
-  log.dim('Paste the file content into CodeX to execute');
-
-  copyToClipboard(fixPrompt);
-
-  await ask('Press Enter after CodeX fix is complete...');
+  await provider.executePrompt(providerId, promptPath, projectDir);
+  log.info('Fix complete');
 }
 
 // ──────────────────────────────────────────────
 // Phase 4: Merge
 // ──────────────────────────────────────────────
-async function mergePhase(projectDir, task, prInfo, baseBranch) {
+async function mergePhase(projectDir, task, prInfo, baseBranch, checkpoint) {
   log.step('Phase 4/4: Merge PR');
 
-  const doMerge = await confirm(`Merge PR #${prInfo.number}?`);
-  if (!doMerge) {
-    log.warn('User skipped merge');
-    return;
-  }
+  log.info(`Auto-merging PR #${prInfo.number}...`);
 
   try {
     github.mergePR(projectDir, prInfo.number);
@@ -386,10 +480,58 @@ async function mergePhase(projectDir, task, prInfo, baseBranch) {
     await ask('Continue...');
   }
 
+  checkpoint.saveStep(task.id, 'merge', 'merged', {
+    branch: task.branch,
+    current_pr: prInfo.number,
+  });
+
   // Switch back to main branch
   git.checkoutMain(projectDir, baseBranch);
 }
 
+// ──────────────────────────────────────────────
+// Pre-flight: ensure base branch has commits & is pushed
+// ──────────────────────────────────────────────
+async function ensureBaseReady(projectDir, baseBranch) {
+  // Check if the repo has any commits at all
+  const hasCommits = git.execSafe('git rev-parse HEAD', projectDir);
+  if (!hasCommits.ok) {
+    // No commits yet — brand new repo
+    log.warn('No commits found in repository');
+    if (!git.isClean(projectDir)) {
+      log.info('Creating initial commit from existing code...');
+      git.commitAll(projectDir, 'chore: initial commit');
+      log.info('✅ Initial commit created');
+    } else {
+      log.warn('Repository is empty — no files to commit');
+      return;
+    }
+  } else {
+    // Has commits, but base branch might have uncommitted changes
+    const currentBranch = git.currentBranch(projectDir);
+    if (currentBranch === baseBranch && !git.isClean(projectDir)) {
+      log.info('Uncommitted changes on base branch, committing first...');
+      git.commitAll(projectDir, 'chore: save current progress before automation');
+      log.info('✅ Base branch changes committed');
+    }
+  }
+
+  // Ensure we're on the base branch
+  const currentBranch = git.currentBranch(projectDir);
+  if (currentBranch !== baseBranch) {
+    // If base branch doesn't exist locally, create it from current
+    const branchExists = git.execSafe(`git rev-parse --verify ${baseBranch}`, projectDir);
+    if (!branchExists.ok) {
+      log.info(`Creating base branch '${baseBranch}' from current branch...`);
+      git.execSafe(`git branch ${baseBranch}`, projectDir);
+    }
+  }
+
+  // Ensure base branch is pushed to remote
+  github.ensureRemoteBranch(projectDir, baseBranch);
+  log.info(`Base branch '${baseBranch}' ready ✓`);
+}
+
 function buildDevPrompt(task) {
   const acceptanceList = Array.isArray(task.acceptance) && task.acceptance.length > 0
     ? task.acceptance.map(a => `- ${a}`).join('\n')
@@ -416,19 +558,5 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-function isCodexAvailable() {
-  try {
-    const cmd = process.platform === 'win32' ? 'where codex' : 'which codex';
-    execSync(cmd, { stdio: 'pipe' });
-    return true;
-  } catch {
-    return false;
-  }
-}
 
-function copyToClipboard(text) {
-  try {
-    execSync('pbcopy', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
-    log.info('📋 Copied to clipboard');
-  } catch {}
-}
+