@jojonax/codex-copilot 1.0.3 → 1.2.0

package/src/commands/status.js

@@ -2,18 +2,19 @@
  * codex-copilot status - Show current progress
  */
 
-import { readFileSync } from 'fs';
+import { readFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
 import { log, progressBar } from '../utils/logger.js';
+import { createCheckpoint } from '../utils/checkpoint.js';
 
 export async function status(projectDir) {
   const tasksPath = resolve(projectDir, '.codex-copilot/tasks.json');
-  const statePath = resolve(projectDir, '.codex-copilot/state.json');
+  const checkpoint = createCheckpoint(projectDir);
 
   let tasks, state;
   try {
     tasks = JSON.parse(readFileSync(tasksPath, 'utf-8'));
-    state = JSON.parse(readFileSync(statePath, 'utf-8'));
+    state = checkpoint.load();
   } catch (err) {
     log.error(`Failed to read files: ${err.message}`);
     log.warn('Files may be corrupted. Run: codex-copilot reset');
@@ -39,9 +40,22 @@ export async function status(projectDir) {
   if (skipped > 0) log.warn(`⏭  Skipped: ${skipped}`);
   log.blank();
 
-  // Current state
-  if (state.current_pr) {
-    log.info(`Current PR: #${state.current_pr} (review round ${state.review_round})`);
+  // Current checkpoint state
+  if (state.phase) {
+    const phaseLabels = {
+      develop: '🔨 Develop',
+      pr: '📦 PR',
+      review: '👀 Review',
+      merge: '🔀 Merge',
+    };
+    const phaseLabel = phaseLabels[state.phase] || state.phase;
+    log.info(`📍 Checkpoint: Task #${state.current_task} — ${phaseLabel} → ${state.phase_step}`);
+    if (state.branch) log.dim(`   Branch: ${state.branch}`);
+    if (state.current_pr) log.dim(`   PR: #${state.current_pr}`);
+    if (state.review_round > 0) log.dim(`   Review round: ${state.review_round}`);
+    if (state.last_updated) log.dim(`   Last saved: ${state.last_updated}`);
+  } else if (state.current_task > 0) {
+    log.info(`Last completed task: #${state.current_task}`);
   }
   log.blank();
 
@@ -49,11 +63,14 @@ export async function status(projectDir) {
   log.title('Task list:');
   log.blank();
   for (const task of tasks.tasks) {
+    const isCurrentTask = state.current_task === task.id && state.phase;
     const icon = task.status === 'completed' ? '✅' :
+                 isCurrentTask ? '🔄' :
                  task.status === 'in_progress' ? '🔄' :
                  task.status === 'developed' ? '📦' :
                  task.status === 'skipped' ? '⏭ ' : '⬜';
-    console.log(`  ${icon}  #${task.id} ${task.title}  [${task.branch}]`);
+    const suffix = isCurrentTask ? `  ← ${state.phase}:${state.phase_step}` : '';
+    console.log(`  ${icon}  #${task.id} ${task.title}  [${task.branch}]${suffix}`);
   }
   log.blank();
 }

package/src/utils/automator.js

@@ -0,0 +1,279 @@
+/**
+ * Desktop IDE Automator — platform-aware process detection + auto-paste
+ * 
+ * Supports macOS (AppleScript/osascript) and Windows (PowerShell/SendKeys).
+ * Each IDE has its own keystroke recipe.
+ * Falls back gracefully if automation fails.
+ */
+
+import { execSync } from 'child_process';
+import { log } from './logger.js';
+
+const IS_MAC = process.platform === 'darwin';
+const IS_WIN = process.platform === 'win32';
+
+// ──────────────────────────────────────────────
+// Per-IDE Automation Recipes
+// ──────────────────────────────────────────────
+
+/**
+ * Each recipe defines:
+ *   processName: { mac, win } — binary/process name to detect
+ *   appName:     { mac, win } — display name for activation
+ *   preKeys:     keystroke sequence BEFORE paste (e.g., open Composer in Cursor)
+ *   preDelay:    ms to wait after preKeys
+ *   postKeys:    keystroke sequence AFTER paste (usually Enter to send)
+ *   pasteDelay:  ms to wait between paste and postKeys
+ */
+const IDE_RECIPES = {
+  'codex-desktop': {
+    processName: { mac: 'Codex', win: 'Codex' },
+    appName: { mac: 'Codex', win: 'Codex' },
+    // Codex Desktop: input is focused on activate → paste → Enter
+    preKeys: null,
+    preDelay: 0,
+    postKeys: 'return',
+    pasteDelay: 300,
+  },
+
+  'cursor': {
+    processName: { mac: 'Cursor', win: 'Cursor' },
+    appName: { mac: 'Cursor', win: 'Cursor' },
+    // Cursor: Cmd/Ctrl+I opens Composer, then paste, then Enter
+    preKeys: IS_MAC
+      ? 'keystroke "i" using {command down}'
+      : '^i',
+    preDelay: 800,
+    postKeys: 'return',
+    pasteDelay: 300,
+  },
+
+  'antigravity': {
+    processName: { mac: 'Antigravity', win: 'Antigravity' },
+    appName: { mac: 'Antigravity', win: 'Antigravity' },
+    // Antigravity: chat input auto-focused → paste → Enter
+    preKeys: null,
+    preDelay: 0,
+    postKeys: 'return',
+    pasteDelay: 300,
+  },
+};
+
+// ──────────────────────────────────────────────
+// Process Detection
+// ──────────────────────────────────────────────
+
+/**
+ * Check if a process is running
+ * @param {string} processName - Name of the process
+ * @returns {boolean}
+ */
+export function isProcessRunning(processName) {
+  try {
+    if (IS_MAC) {
+      const result = execSync(
+        `pgrep -x "${processName}" || pgrep -fi "${processName}"`,
+        { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+      ).trim();
+      return result.length > 0;
+    } else if (IS_WIN) {
+      const result = execSync(
+        `tasklist /FI "IMAGENAME eq ${processName}.exe" /NH`,
+        { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+      ).trim();
+      return !result.includes('No tasks');
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// ──────────────────────────────────────────────
+// macOS Automation (AppleScript)
+// ──────────────────────────────────────────────
+
+function buildAppleScript(recipe) {
+  const appName = recipe.appName.mac;
+  const lines = [];
+
+  // Activate the application
+  lines.push(`tell application "${appName}" to activate`);
+  lines.push('delay 0.5');
+
+  // System Events block for keystrokes
+  lines.push('tell application "System Events"');
+
+  // Pre-keys (e.g., Cmd+I for Cursor Composer)
+  if (recipe.preKeys) {
+    lines.push(`  ${recipe.preKeys}`);
+    lines.push(`  delay ${recipe.preDelay / 1000}`);
+  }
+
+  // Paste: Cmd+V
+  lines.push('  keystroke "v" using {command down}');
+  lines.push(`  delay ${recipe.pasteDelay / 1000}`);
+
+  // Post-keys: usually Enter to send
+  if (recipe.postKeys === 'return') {
+    lines.push('  keystroke return');
+  }
+
+  lines.push('end tell');
+
+  return lines.join('\n');
+}
+
+function runAppleScript(script) {
+  try {
+    execSync(`osascript -e '${script.replace(/'/g, "'\"'\"'")}'`, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10000,
+    });
+    return true;
+  } catch (err) {
+    log.warn(`AppleScript failed: ${err.message}`);
+    if (err.message.includes('not allowed assistive access')) {
+      log.error('⚠ Accessibility permission required:');
+      log.error('  System Settings → Privacy & Security → Accessibility');
+      log.error('  Add your terminal app (Terminal / iTerm2 / Warp)');
+    }
+    return false;
+  }
+}
+
+// ──────────────────────────────────────────────
+// Windows Automation (PowerShell)
+// ──────────────────────────────────────────────
+
+function buildPowerShell(recipe) {
+  const appName = recipe.appName.win;
+  const lines = [];
+
+  lines.push('Add-Type -AssemblyName System.Windows.Forms');
+  lines.push('Add-Type -AssemblyName Microsoft.VisualBasic');
+
+  // Activate window
+  lines.push(`[Microsoft.VisualBasic.Interaction]::AppActivate("${appName}")`);
+  lines.push('Start-Sleep -Milliseconds 500');
+
+  // Pre-keys
+  if (recipe.preKeys) {
+    lines.push(`[System.Windows.Forms.SendKeys]::SendWait("${recipe.preKeys}")`);
+    lines.push(`Start-Sleep -Milliseconds ${recipe.preDelay}`);
+  }
+
+  // Paste: Ctrl+V
+  lines.push('[System.Windows.Forms.SendKeys]::SendWait("^v")');
+  lines.push(`Start-Sleep -Milliseconds ${recipe.pasteDelay}`);
+
+  // Post-keys: Enter
+  if (recipe.postKeys === 'return') {
+    lines.push('[System.Windows.Forms.SendKeys]::SendWait("{ENTER}")');
+  }
+
+  return lines.join('; ');
+}
+
+function runPowerShell(script) {
+  try {
+    execSync(`powershell -NoProfile -Command "${script.replace(/"/g, '\\"')}"`, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10000,
+    });
+    return true;
+  } catch (err) {
+    log.warn(`PowerShell automation failed: ${err.message}`);
+    return false;
+  }
+}
+
+// ──────────────────────────────────────────────
+// Public API
+// ──────────────────────────────────────────────
+
+/**
+ * Check if a specific IDE has a known automation recipe
+ */
+export function hasRecipe(providerId) {
+  return providerId in IDE_RECIPES;
+}
+
+/**
+ * Check if the IDE is currently running
+ */
+export function isIDERunning(providerId) {
+  const recipe = IDE_RECIPES[providerId];
+  if (!recipe) return false;
+
+  const processName = IS_MAC ? recipe.processName.mac : recipe.processName.win;
+  return isProcessRunning(processName);
+}
+
+/**
+ * Attempt to auto-paste prompt into the IDE and trigger send
+ * 
+ * Flow: copy to clipboard → activate window → pre-keys → paste → post-keys
+ * 
+ * @param {string} providerId - IDE provider ID
+ * @param {string} text - Prompt text to paste
+ * @returns {boolean} true if automation succeeded
+ */
+export function activateAndPaste(providerId, text) {
+  const recipe = IDE_RECIPES[providerId];
+  if (!recipe) {
+    log.warn(`No automation recipe for '${providerId}'`);
+    return false;
+  }
+
+  // Step 1: Check process is running
+  const processName = IS_MAC ? recipe.processName.mac : recipe.processName.win;
+  if (!isProcessRunning(processName)) {
+    log.warn(`${recipe.appName[IS_MAC ? 'mac' : 'win']} is not running`);
+    return false;
+  }
+
+  // Step 2: Copy to clipboard (handled by caller, but ensure it's done)
+  copyToSystemClipboard(text);
+
+  // Step 3: Run platform-specific automation
+  log.info(`Auto-pasting into ${recipe.appName[IS_MAC ? 'mac' : 'win']}...`);
+
+  if (IS_MAC) {
+    const script = buildAppleScript(recipe);
+    return runAppleScript(script);
+  } else if (IS_WIN) {
+    const script = buildPowerShell(recipe);
+    return runPowerShell(script);
+  } else {
+    log.warn('Desktop automation not supported on this platform');
+    return false;
+  }
+}
+
+/**
+ * Copy text to system clipboard (cross-platform)
+ */
+function copyToSystemClipboard(text) {
+  try {
+    if (IS_MAC) {
+      execSync('pbcopy', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+    } else if (IS_WIN) {
+      execSync('clip', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+    } else {
+      try {
+        execSync('xclip -selection clipboard', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+      } catch {
+        execSync('xsel --clipboard --input', { input: text, stdio: ['pipe', 'pipe', 'pipe'] });
+      }
+    }
+  } catch {
+    // Clipboard failure is non-fatal — user can copy file manually
+  }
+}
+
+export const automator = {
+  isProcessRunning, hasRecipe, isIDERunning, activateAndPaste,
+};

package/src/utils/checkpoint.js

@@ -0,0 +1,129 @@
+/**
+ * Checkpoint state manager - Fine-grained state persistence
+ * 
+ * Provides atomic save/load for checkpoint state, enabling
+ * resume from any sub-step within a task after interruption.
+ */
+
+import { readFileSync, writeFileSync, renameSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+/**
+ * Create a checkpoint manager for a project
+ * @param {string} projectDir - Project root directory
+ */
+export function createCheckpoint(projectDir) {
+  const statePath = resolve(projectDir, '.codex-copilot/state.json');
+  const tempPath = resolve(projectDir, '.codex-copilot/state.json.tmp');
+
+  /**
+   * Load current state from disk
+   */
+  function load() {
+    try {
+      return JSON.parse(readFileSync(statePath, 'utf-8'));
+    } catch {
+      return getDefaultState();
+    }
+  }
+
+  /**
+   * Save state atomically (write to temp file, then rename)
+   * @param {object} update - Partial state to merge
+   */
+  function save(update) {
+    const current = load();
+    const merged = {
+      ...current,
+      ...update,
+      last_updated: new Date().toISOString(),
+    };
+    // Atomic write: temp file + rename prevents corruption on crash
+    writeFileSync(tempPath, JSON.stringify(merged, null, 2));
+    renameSync(tempPath, statePath);
+    return merged;
+  }
+
+  /**
+   * Mark a specific phase & step as reached
+   */
+  function saveStep(taskId, phase, phaseStep, extra = {}) {
+    return save({
+      current_task: taskId,
+      phase,
+      phase_step: phaseStep,
+      ...extra,
+    });
+  }
+
+  /**
+   * Mark current task as fully completed, clear phase info
+   */
+  function completeTask(taskId) {
+    return save({
+      current_task: taskId,
+      phase: null,
+      phase_step: null,
+      current_pr: null,
+      review_round: 0,
+      branch: null,
+    });
+  }
+
+  /**
+   * Check if a specific phase+step has been reached for a task
+   * Returns true if the saved state is at or past the given step
+   */
+  function isStepDone(taskId, phase, phaseStep) {
+    const state = load();
+    if (state.current_task !== taskId) return false;
+    if (!state.phase) return false;
+
+    const phaseOrder = ['develop', 'pr', 'review', 'merge'];
+    const savedPhaseIdx = phaseOrder.indexOf(state.phase);
+    const targetPhaseIdx = phaseOrder.indexOf(phase);
+
+    // If saved phase is ahead, this step is done
+    if (savedPhaseIdx > targetPhaseIdx) return true;
+    // If saved phase is behind, this step is not done
+    if (savedPhaseIdx < targetPhaseIdx) return false;
+
+    // Same phase: compare steps within phase
+    const stepOrders = {
+      develop: ['branch_created', 'prompt_ready', 'codex_complete'],
+      pr: ['committed', 'pushed', 'pr_created'],
+      review: ['waiting_review', 'feedback_received', 'fix_applied'],
+      merge: ['merged'],
+    };
+
+    const steps = stepOrders[phase] || [];
+    const savedStepIdx = steps.indexOf(state.phase_step);
+    const targetStepIdx = steps.indexOf(phaseStep);
+
+    return savedStepIdx >= targetStepIdx;
+  }
+
+  /**
+   * Full reset to initial state
+   */
+  function reset() {
+    const state = getDefaultState();
+    writeFileSync(statePath, JSON.stringify(state, null, 2));
+    return state;
+  }
+
+  return { load, save, saveStep, completeTask, isStepDone, reset };
+}
+
+function getDefaultState() {
+  return {
+    current_task: 0,
+    phase: null,
+    phase_step: null,
+    current_pr: null,
+    review_round: 0,
+    branch: null,
+    status: 'initialized',
+    last_updated: new Date().toISOString(),
+  };
+}

package/src/utils/git.js

@@ -91,11 +91,15 @@ function shellEscape(str) {
 }
 
 /**
- * Push branch to remote
+ * Push branch to remote (handles new branches without upstream)
  */
 export function pushBranch(cwd, branch) {
   validateBranch(branch);
-  exec(`git push origin ${branch} --force-with-lease`, cwd);
+  const result = execSafe(`git push origin ${branch} --force-with-lease`, cwd);
+  if (!result.ok) {
+    // Force-with-lease fails on new branches — fall back to regular push with upstream
+    exec(`git push -u origin ${branch}`, cwd);
+  }
 }
 
 /**

package/src/utils/github.js

@@ -9,6 +9,14 @@ function gh(cmd, cwd) {
   return execSync(`gh ${cmd}`, { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
 }
 
+function ghSafe(cmd, cwd) {
+  try {
+    return { ok: true, output: gh(cmd, cwd) };
+  } catch (err) {
+    return { ok: false, output: err.stderr || err.message };
+  }
+}
+
 function ghJSON(cmd, cwd) {
   const output = gh(cmd, cwd);
   if (!output) return null;
@@ -19,6 +27,14 @@ function ghJSON(cmd, cwd) {
   }
 }
 
+function ghJSONSafe(cmd, cwd) {
+  try {
+    return ghJSON(cmd, cwd);
+  } catch {
+    return null;
+  }
+}
+
 function shellEscape(str) {
   return `'${str.replace(/'/g, "'\\''")}'`
 }
@@ -36,9 +52,74 @@ export function checkGhAuth() {
 }
 
 /**
- * Create a pull request
+ * Ensure the base branch exists on remote.
+ * If not, push it first.
+ */
+export function ensureRemoteBranch(cwd, branch) {
+  try {
+    const result = execSync(
+      `git ls-remote --heads origin ${branch}`,
+      { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+    if (!result) {
+      // Branch doesn't exist on remote, push it
+      log.info(`Base branch '${branch}' not found on remote, pushing...`);
+      execSync(`git push origin ${branch}`, {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      log.info(`Base branch '${branch}' pushed to remote`);
+    }
+    return true;
+  } catch (err) {
+    log.warn(`Failed to verify remote branch '${branch}': ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Check if there are commits between base and head branches
+ */
+export function hasCommitsBetween(cwd, base, head) {
+  try {
+    const result = execSync(
+      `git log ${base}..${head} --oneline`,
+      { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+    return result.length > 0;
+  } catch {
+    // If comparison fails (e.g., branches diverged), assume there are commits
+    return true;
+  }
+}
+
+/**
+ * Find an existing PR for a given head branch
+ * @returns {{ number: number, url: string } | null}
+ */
+export function findExistingPR(cwd, head) {
+  try {
+    const prs = ghJSON(
+      `pr list --head ${shellEscape(head)} --json number,url --limit 1`,
+      cwd
+    );
+    if (prs && prs.length > 0) {
+      return { number: prs[0].number, url: prs[0].url || '' };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create a pull request with pre-checks and auto-recovery
  */
 export function createPR(cwd, { title, body, base = 'main', head }) {
+  // Pre-check: ensure base branch exists on remote
+  ensureRemoteBranch(cwd, base);
+
   const output = gh(
     `pr create --title ${shellEscape(title)} --body ${shellEscape(body)} --base ${shellEscape(base)} --head ${shellEscape(head)}`,
     cwd
@@ -56,6 +137,59 @@ export function createPR(cwd, { title, body, base = 'main', head }) {
   throw new Error(`Failed to create PR: ${output}`);
 }
 
+/**
+ * Create PR with full auto-recovery: pre-checks → create → fallback to find existing
+ * @returns {{ number: number, url: string }}
+ */
+export function createPRWithRecovery(cwd, { title, body, base = 'main', head }) {
+  // Step 1: Try to create the PR
+  try {
+    return createPR(cwd, { title, body, base, head });
+  } catch (err) {
+    log.warn(`PR creation failed: ${err.message}`);
+  }
+
+  // Step 2: Auto-find existing PR for this branch
+  log.info('Searching for existing PR...');
+  const existing = findExistingPR(cwd, head);
+  if (existing) {
+    log.info(`Found existing PR #${existing.number}`);
+    return existing;
+  }
+
+  // Step 3: Check if there are actually commits to create a PR for
+  if (!hasCommitsBetween(cwd, base, head)) {
+    log.warn('No commits between base and head branch');
+    log.info('This may be a new repo or empty branch. Attempting to push base branch and retry...');
+
+    // Ensure both branches are pushed
+    ensureRemoteBranch(cwd, base);
+    ensureRemoteBranch(cwd, head);
+
+    // Retry PR creation
+    try {
+      return createPR(cwd, { title, body, base, head });
+    } catch (retryErr) {
+      log.warn(`PR retry also failed: ${retryErr.message}`);
+    }
+
+    // Last resort: try to find PR again
+    const retryExisting = findExistingPR(cwd, head);
+    if (retryExisting) {
+      log.info(`Found existing PR #${retryExisting.number}`);
+      return retryExisting;
+    }
+  }
+
+  // Step 4: If all else fails, throw with actionable message
+  throw new Error(
+    `Cannot create or find PR for branch '${head}'. ` +
+    `Possible causes: base branch '${base}' may not exist on remote, ` +
+    `or there are no commits between '${base}' and '${head}'. ` +
+    `Try: git push origin ${base} && git push origin ${head}`
+  );
+}
+
 /**
  * Get PR review list
  */
@@ -126,7 +260,8 @@ function validatePRNumber(prNumber) {
 }
 
 /**
- * Collect all review feedback as structured text
+ * Collect all review feedback as structured text.
+ * Returns raw feedback — classification is done by AI provider.
  */
 export function collectReviewFeedback(cwd, prNumber) {
   const reviews = getReviews(cwd, prNumber);
@@ -135,19 +270,19 @@ export function collectReviewFeedback(cwd, prNumber) {
 
   let feedback = '';
 
-  // Review summary
+  // Review body text (skip APPROVED — already handled by state check)
   for (const r of reviews) {
-    if (r.body && r.body.trim()) {
+    if (r.body && r.body.trim() && r.state !== 'APPROVED') {
       feedback += `### Review (${r.state})\n${r.body}\n\n`;
     }
   }
 
-  // Inline comments
+  // Inline code comments (comments on specific diff lines)
   for (const c of comments) {
     feedback += `### ${c.path}:L${c.line || c.original_line}\n${c.body}\n\n`;
   }
 
-  // Bot comments (Gemini Code Assist, etc.)
+  // Bot comments
   for (const c of issueComments) {
     if (c.user?.type === 'Bot' || c.user?.login?.includes('bot')) {
       feedback += `### Bot Review (${c.user.login})\n${c.body}\n\n`;
@@ -158,6 +293,8 @@ export function collectReviewFeedback(cwd, prNumber) {
 }
 
 export const github = {
-  checkGhAuth, createPR, getReviews, getReviewComments,
-  getIssueComments, getLatestReviewState, mergePR, collectReviewFeedback,
+  checkGhAuth, createPR, createPRWithRecovery, findExistingPR,
+  ensureRemoteBranch, hasCommitsBetween,
+  getReviews, getReviewComments, getIssueComments,
+  getLatestReviewState, mergePR, collectReviewFeedback,
 };