@rotorsoft/gent 1.7.1 → 1.9.0

package/dist/index.js

@@ -19,6 +19,7 @@ import {
   getCurrentUser,
   getIssue,
   getPrForBranch,
+  getPrReviewData,
   getWorkflowLabels,
   isValidIssueNumber,
   listIssues,
@@ -30,7 +31,7 @@ import {
   sortByPriority,
   updateIssueLabels,
   withSpinner
-} from "./chunk-2LGYNV6S.js";
+} from "./chunk-CMDTYS6L.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -154,8 +155,17 @@ async function initCommand(options) {
       return;
     }
   }
+  const { provider } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "provider",
+      message: "Which AI provider would you like to use by default?",
+      choices: ["claude", "gemini", "codex"],
+      default: "claude"
+    }
+  ]);
   const configPath = getConfigPath(cwd);
-  writeFileSync2(configPath, generateDefaultConfig(), "utf-8");
+  writeFileSync2(configPath, generateDefaultConfig(provider), "utf-8");
   logger.success(`Created ${colors.file(".gent.yml")}`);
   const agentPath = join2(cwd, "AGENT.md");
   if (!existsSync2(agentPath) || options.force) {
@@ -182,7 +192,7 @@ async function initCommand(options) {
     }
   ]);
   if (setupLabels) {
-    const { setupLabelsCommand: setupLabelsCommand2 } = await import("./setup-labels-3IMSEEKN.js");
+    const { setupLabelsCommand: setupLabelsCommand2 } = await import("./setup-labels-IQOZF4U7.js");
     await setupLabelsCommand2();
   }
 }
@@ -194,17 +204,27 @@ import chalk from "chalk";
 // src/lib/ai-provider.ts
 import { spawn } from "child_process";
 import { execa } from "execa";
+async function invokeInternal(provider, options) {
+  switch (provider) {
+    case "claude":
+      return invokeClaudeInternal(options);
+    case "gemini":
+      return invokeGeminiInternal(options);
+    case "codex":
+      return invokeCodexInternal(options);
+  }
+}
 async function invokeAI(options, config, providerOverride) {
   const provider = providerOverride ?? config.ai.provider;
   try {
-    const output = provider === "claude" ? await invokeClaudeInternal(options) : await invokeGeminiInternal(options);
+    const output = await invokeInternal(provider, options);
     return { output, provider };
   } catch (error) {
     if (isRateLimitError(error, provider)) {
       if (config.ai.auto_fallback && config.ai.fallback_provider && !providerOverride) {
         const fallback = config.ai.fallback_provider;
         logger.warning(`Rate limit reached on ${getProviderDisplayName(provider)}, switching to ${getProviderDisplayName(fallback)}...`);
-        const output = fallback === "claude" ? await invokeClaudeInternal(options) : await invokeGeminiInternal(options);
+        const output = await invokeInternal(fallback, options);
         return { output, provider: fallback };
       }
       const err = error;
@@ -217,28 +237,52 @@ async function invokeAI(options, config, providerOverride) {
 }
 async function invokeAIInteractive(prompt, config, providerOverride) {
   const provider = providerOverride ?? config.ai.provider;
-  if (provider === "claude") {
-    const args = ["--permission-mode", config.claude.permission_mode, prompt];
-    return {
-      result: execa("claude", args, { stdio: "inherit" }),
-      provider
-    };
-  } else {
-    return {
-      result: execa("gemini", ["-i", prompt], { stdio: "inherit" }),
-      provider
-    };
+  switch (provider) {
+    case "claude": {
+      const args = ["--permission-mode", config.claude.permission_mode, prompt];
+      return {
+        result: execa("claude", args, { stdio: "inherit" }),
+        provider
+      };
+    }
+    case "gemini": {
+      return {
+        result: execa("gemini", ["-i", prompt], { stdio: "inherit" }),
+        provider
+      };
+    }
+    case "codex": {
+      const args = prompt ? [prompt] : [];
+      return {
+        result: execa("codex", args, { stdio: "inherit" }),
+        provider
+      };
+    }
   }
 }
 function getProviderDisplayName(provider) {
-  return provider === "claude" ? "Claude" : "Gemini";
+  switch (provider) {
+    case "claude":
+      return "Claude";
+    case "gemini":
+      return "Gemini";
+    case "codex":
+      return "Codex";
+  }
 }
 function getProviderEmail(provider) {
-  return provider === "claude" ? "noreply@anthropic.com" : "noreply@google.com";
+  switch (provider) {
+    case "claude":
+      return "noreply@anthropic.com";
+    case "gemini":
+      return "noreply@google.com";
+    case "codex":
+      return "noreply@openai.com";
+  }
 }
 function isRateLimitError(error, provider) {
   if (!error || typeof error !== "object") return false;
-  if (provider === "claude" && "exitCode" in error && error.exitCode === 2) {
+  if ((provider === "claude" || provider === "codex") && "exitCode" in error && error.exitCode === 2) {
     return true;
   }
   if ("message" in error && typeof error.message === "string") {
@@ -330,6 +374,44 @@ async function invokeGeminiInternal(options) {
     return stdout;
   }
 }
+async function invokeCodexInternal(options) {
+  const args = ["exec", options.prompt];
+  if (options.printOutput) {
+    const subprocess = execa("codex", args, {
+      stdio: "inherit"
+    });
+    await subprocess;
+    return "";
+  } else if (options.streamOutput) {
+    return new Promise((resolve, reject) => {
+      const child = spawn("codex", args, {
+        stdio: ["inherit", "pipe", "pipe"]
+      });
+      let output = "";
+      child.stdout.on("data", (chunk) => {
+        const text = chunk.toString();
+        output += text;
+        process.stdout.write(text);
+      });
+      child.stderr.on("data", (chunk) => {
+        process.stderr.write(chunk);
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve(output);
+        } else {
+          const error = new Error(`Codex exited with code ${code}`);
+          error.exitCode = code ?? 1;
+          reject(error);
+        }
+      });
+      child.on("error", reject);
+    });
+  } else {
+    const { stdout } = await execa("codex", args);
+    return stdout;
+  }
+}
 
 // src/lib/prompts.ts
 function buildTicketPrompt(description, agentInstructions, additionalHints = null) {
@@ -386,7 +468,7 @@ META:type=<type>,priority=<priority>,risk=<risk>,area=<area>
 Example: META:type=feature,priority=high,risk=low,area=ui`;
   return basePrompt;
 }
-function buildImplementationPrompt(issue, agentInstructions, progressContent, config) {
+function buildImplementationPrompt(issue, agentInstructions, progressContent, config, reviewFeedback = null) {
   const providerName = getProviderDisplayName(config.ai.provider);
   const providerEmail = getProviderEmail(config.ai.provider);
   return `GitHub Issue #${issue.number}: ${issue.title}
@@ -400,6 +482,10 @@ ${agentInstructions}
 ${progressContent ? `## Previous Progress
 ${progressContent}
 
+` : ""}
+${reviewFeedback ? `## Review Feedback
+${reviewFeedback}
+
 ` : ""}
 
 ## Your Task
@@ -1353,6 +1439,247 @@ function generateFallbackBody(issue, commits) {
   return body;
 }
 
+// src/commands/fix.ts
+import inquirer5 from "inquirer";
+
+// src/lib/review-feedback.ts
+var ACTIONABLE_KEYWORDS = [
+  "todo",
+  "fix",
+  "should",
+  "must",
+  "needs",
+  "please",
+  "consider",
+  "can you",
+  "change",
+  "update",
+  "remove",
+  "add"
+];
+var TRIVIAL_COMMENTS = ["lgtm", "looks good", "approved"];
+function summarizeReviewFeedback(data) {
+  const items = extractReviewFeedbackItems(data);
+  return {
+    items,
+    summary: items.length > 0 ? formatReviewFeedbackSummary(items) : ""
+  };
+}
+function extractReviewFeedbackItems(data) {
+  const items = [];
+  for (const review of data.reviews) {
+    const body = review.body?.trim() ?? "";
+    if (!body || isTrivialComment(body)) {
+      continue;
+    }
+    const isChangesRequested = review.state === "CHANGES_REQUESTED";
+    const actionable = isChangesRequested || isActionableText(body);
+    if (!actionable) {
+      continue;
+    }
+    items.push({
+      source: "review",
+      author: review.author,
+      body,
+      state: review.state
+    });
+  }
+  for (const thread of data.reviewThreads) {
+    if (!isActionableThread(thread)) {
+      continue;
+    }
+    const comments = thread.comments ?? [];
+    const latestComment = findLatestMeaningfulComment(comments);
+    if (!latestComment) {
+      continue;
+    }
+    items.push({
+      source: "thread",
+      author: latestComment.author,
+      body: latestComment.body,
+      path: thread.path ?? latestComment.path,
+      line: thread.line ?? latestComment.line ?? null
+    });
+  }
+  return items;
+}
+function formatReviewFeedbackSummary(items) {
+  return items.map((item) => {
+    const location = formatLocation(item);
+    const stateLabel = item.state ? formatState(item.state) : null;
+    const author = item.author ? `@${item.author}` : "Reviewer";
+    const body = truncateComment(item.body);
+    const header = item.source === "review" ? stateLabel ? `Review (${stateLabel})` : "Review" : location;
+    return `- [${header}] ${author}: ${body}`;
+  }).join("\n");
+}
+function isActionableThread(thread) {
+  if (thread.isResolved === false || thread.isResolved === void 0 || thread.isResolved === null) {
+    return true;
+  }
+  return (thread.comments ?? []).some((comment) => isActionableText(comment.body));
+}
+function isActionableText(text) {
+  const normalized = text.toLowerCase();
+  return ACTIONABLE_KEYWORDS.some((keyword) => normalized.includes(keyword));
+}
+function isTrivialComment(text) {
+  const normalized = text.trim().toLowerCase();
+  return TRIVIAL_COMMENTS.some((entry) => normalized === entry);
+}
+function findLatestMeaningfulComment(comments) {
+  for (let i = comments.length - 1; i >= 0; i -= 1) {
+    const body = comments[i].body?.trim() ?? "";
+    if (body && !isTrivialComment(body)) {
+      return comments[i];
+    }
+  }
+  return null;
+}
+function formatLocation(item) {
+  if (item.path && item.line) {
+    return `${item.path}:${item.line}`;
+  }
+  if (item.path) {
+    return item.path;
+  }
+  return "Thread";
+}
+function formatState(state) {
+  return state.replace(/_/g, " ").toLowerCase();
+}
+function truncateComment(body, maxLength = 200) {
+  const normalized = body.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength - 3)}...`;
+}
+
+// src/commands/fix.ts
+async function fixCommand(options) {
+  logger.bold("Applying PR review feedback with AI...");
+  logger.newline();
+  const config = loadConfig();
+  const provider = options.provider ?? config.ai.provider;
+  const providerName = getProviderDisplayName(provider);
+  const [ghAuth, aiOk] = await Promise.all([
+    checkGhAuth(),
+    checkAIProvider(provider)
+  ]);
+  if (!ghAuth) {
+    logger.error("Not authenticated with GitHub. Run 'gh auth login' first.");
+    process.exit(1);
+  }
+  if (!aiOk) {
+    logger.error(`${providerName} CLI not found. Please install ${provider} CLI first.`);
+    process.exit(1);
+  }
+  if (await isOnMainBranch()) {
+    logger.error("Cannot apply fixes from main/master branch. Switch to the PR branch first.");
+    process.exit(1);
+  }
+  const hasChanges = await hasUncommittedChanges();
+  if (hasChanges) {
+    logger.warning("You have uncommitted changes.");
+    const { proceed } = await inquirer5.prompt([
+      {
+        type: "confirm",
+        name: "proceed",
+        message: "Continue anyway?",
+        default: false
+      }
+    ]);
+    if (!proceed) {
+      logger.info("Aborting. Please commit or stash your changes first.");
+      process.exit(0);
+    }
+  }
+  const pr = await withSpinner("Resolving pull request...", async () => {
+    return getPrForBranch();
+  });
+  if (!pr) {
+    logger.error("No pull request found for the current branch. Create one with 'gent pr' first.");
+    process.exit(1);
+  }
+  const reviewData = await withSpinner("Fetching review feedback...", async () => {
+    return getPrReviewData(pr.number);
+  });
+  const totalComments = countReviewComments(reviewData);
+  if (totalComments === 0) {
+    logger.error(`No review comments found for PR #${pr.number}.`);
+    process.exit(1);
+  }
+  const { items, summary } = summarizeReviewFeedback(reviewData);
+  if (items.length === 0 || !summary) {
+    logger.error("No actionable review feedback found.");
+    process.exit(1);
+  }
+  logger.newline();
+  logger.box("Review Feedback Summary", summary);
+  logger.newline();
+  const currentBranch = await getCurrentBranch();
+  const issueNumber = extractIssueNumber(currentBranch);
+  if (!issueNumber) {
+    logger.error("Could not determine issue number from branch name.");
+    process.exit(1);
+  }
+  const issue = await withSpinner("Fetching linked issue...", async () => {
+    return getIssue(issueNumber);
+  });
+  const agentInstructions = loadAgentInstructions();
+  const progressContent = readProgress(config);
+  const prompt = buildImplementationPrompt(issue, agentInstructions, progressContent, config, summary);
+  logger.newline();
+  logger.info(`Starting ${colors.provider(providerName)} fix session...`);
+  logger.dim("Review feedback will be appended to the implementation prompt.");
+  logger.newline();
+  const beforeSha = await getCurrentCommitSha();
+  let wasCancelled = false;
+  const handleSignal = () => {
+    wasCancelled = true;
+  };
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+  let aiExitCode;
+  try {
+    const { result } = await invokeAIInteractive(prompt, config, options.provider);
+    aiExitCode = result.exitCode ?? void 0;
+  } catch (error) {
+    if (error && typeof error === "object" && "exitCode" in error) {
+      aiExitCode = error.exitCode;
+    }
+    logger.error(`${providerName} session failed: ${error}`);
+  } finally {
+    process.off("SIGINT", handleSignal);
+    process.off("SIGTERM", handleSignal);
+  }
+  logger.newline();
+  if (wasCancelled) {
+    logger.warning("Operation was cancelled. No changes were recorded.");
+    return;
+  }
+  const commitsCreated = await hasNewCommits(beforeSha);
+  if (commitsCreated) {
+    logger.success(`${providerName} session completed with new commits.`);
+    return;
+  }
+  const isRateLimited = aiExitCode === 2;
+  if (isRateLimited) {
+    logger.warning(`${providerName} session ended due to rate limits. No commits were created.`);
+    return;
+  }
+  logger.warning(`${providerName} session completed but no commits were created.`);
+}
+function countReviewComments(data) {
+  const reviewBodies = data.reviews.filter((review) => review.body?.trim()).length;
+  const threadBodies = data.reviewThreads.reduce((count, thread) => {
+    const threadCount = (thread.comments ?? []).filter((comment) => comment.body?.trim()).length;
+    return count + threadCount;
+  }, 0);
+  return reviewBodies + threadBodies;
+}
+
 // src/lib/version.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
 import { join as join3 } from "path";
@@ -1361,8 +1688,8 @@ import { homedir } from "os";
 // package.json
 var package_default = {
   name: "@rotorsoft/gent",
-  version: "1.7.1",
-  description: "AI-powered GitHub workflow CLI - leverage AI (Claude or Gemini) to create tickets, implement features, and manage PRs",
+  version: "1.9.0",
+  description: "AI-powered GitHub workflow CLI - leverage AI (Claude, Gemini, or Codex) to create tickets, implement features, and manage PRs",
   keywords: [
     "cli",
     "ai",
@@ -1703,7 +2030,7 @@ function startVersionCheck() {
   });
 }
 var program = new Command();
-program.name("gent").description("AI-powered GitHub workflow CLI - leverage AI (Claude or Gemini) to create tickets, implement features, and manage PRs").version(version).option("--skip-update-check", "Skip checking for CLI updates").hook("preAction", (thisCommand) => {
+program.name("gent").description("AI-powered GitHub workflow CLI - leverage AI (Claude, Gemini, or Codex) to create tickets, implement features, and manage PRs").version(version).option("--skip-update-check", "Skip checking for CLI updates").hook("preAction", (thisCommand) => {
   if (!thisCommand.opts().skipUpdateCheck) {
     startVersionCheck();
   }
@@ -1714,7 +2041,7 @@ program.command("init").description("Initialize gent workflow in current reposit
 program.command("setup-labels").description("Setup GitHub labels for AI workflow").action(async () => {
   await setupLabelsCommand();
 });
-program.command("create <description>").description("Create an AI-enhanced GitHub issue").option("-y, --yes", "Skip confirmation and create issue immediately").option("-p, --provider <provider>", "AI provider to use (claude or gemini)").option("-t, --title <title>", "Override the generated issue title").action(async (description, options) => {
+program.command("create <description>").description("Create an AI-enhanced GitHub issue").option("-y, --yes", "Skip confirmation and create issue immediately").option("-p, --provider <provider>", "AI provider to use (claude, gemini, or codex)").option("-t, --title <title>", "Override the generated issue title").action(async (description, options) => {
   await createCommand(description, { yes: options.yes, provider: options.provider, title: options.title });
 });
 program.command("list").description("List GitHub issues by label/status").option("-l, --label <label>", "Filter by label").option("-s, --status <status>", "Filter by workflow status (ready, in-progress, completed, blocked, all)").option("-n, --limit <number>", "Maximum number of issues to show", "20").action(async (options) => {
@@ -1724,12 +2051,15 @@ program.command("list").description("List GitHub issues by label/status").option
     limit: parseInt(options.limit, 10)
   });
 });
-program.command("run [issue-number]").description("Run AI to implement a GitHub issue").option("-a, --auto", "Auto-select highest priority ai-ready issue").option("-p, --provider <provider>", "AI provider to use (claude or gemini)").action(async (issueNumber, options) => {
+program.command("run [issue-number]").description("Run AI to implement a GitHub issue").option("-a, --auto", "Auto-select highest priority ai-ready issue").option("-p, --provider <provider>", "AI provider to use (claude, gemini, or codex)").action(async (issueNumber, options) => {
   await runCommand(issueNumber, { auto: options.auto, provider: options.provider });
 });
-program.command("pr").description("Create an AI-enhanced pull request").option("-d, --draft", "Create as draft PR").option("-p, --provider <provider>", "AI provider to use (claude or gemini)").action(async (options) => {
+program.command("pr").description("Create an AI-enhanced pull request").option("-d, --draft", "Create as draft PR").option("-p, --provider <provider>", "AI provider to use (claude, gemini, or codex)").action(async (options) => {
   await prCommand({ draft: options.draft, provider: options.provider });
 });
+program.command("fix").description("Apply PR review feedback using AI").option("-p, --provider <provider>", "AI provider to use (claude, gemini, or codex)").action(async (options) => {
+  await fixCommand({ provider: options.provider });
+});
 program.command("status").description("Show current workflow status").action(async () => {
   await statusCommand();
 });