kodevu 0.1.49 → 0.1.51

package/README.md

@@ -29,13 +29,18 @@ npx kodevu [target] [options]
 ### Options
 
 - `target`: Repository path (Git) or SVN URL/Working copy (default: `.`).
-- `--reviewer, -r`: `codex`, `gemini`, `copilot`, or `auto` (default: `auto`).
+- `--reviewer, -r`: `codex`, `gemini`, `copilot`, `openai`, or `auto` (default: `auto`).
 - `--rev, -v`: A specific revision or commit hash to review.
 - `--last, -n`: Number of latest revisions to review (default: 1). Use negative values (e.g., `-3`) to review only the 3rd commit from the top.
 - `--lang, -l`: Output language (e.g., `zh`, `en`, `auto`).
 - `--prompt, -p`: Additional instructions for the reviewer. Use `@file.txt` to read from a file.
 - `--output, -o`: Report output directory (default: `~/.kodevu`).
 - `--format, -f`: Output formats (e.g., `markdown`, `json`, or `markdown,json`).
+- `--openai-api-key`: API key used when `--reviewer openai`.
+- `--openai-base-url`: Base URL used when `--reviewer openai` (default: `https://api.openai.com/v1`).
+- `--openai-model`: Model used when `--reviewer openai` (default: `gpt-5-mini`).
+- `--openai-org`: Optional OpenAI organization ID.
+- `--openai-project`: Optional OpenAI project ID.
 - `--debug, -d`: Print debug information.
 - `--version, -V`: Print the current version and exit.
 
@@ -51,6 +56,11 @@ You can set these in your shell to change default behavior without typing flags
 - `KODEVU_OUTPUT_DIR`: Default output directory.
 - `KODEVU_PROMPT`: Default prompt instructions.
 - `KODEVU_TIMEOUT`: Reviewer execution timeout in milliseconds.
+- `KODEVU_OPENAI_API_KEY`: API key for `openai`.
+- `KODEVU_OPENAI_BASE_URL`: Base URL for `openai`.
+- `KODEVU_OPENAI_MODEL`: Model for `openai`.
+- `KODEVU_OPENAI_ORG`: Optional organization ID for `openai`.
+- `KODEVU_OPENAI_PROJECT`: Optional project ID for `openai`.
 
 ## Examples
 
@@ -91,11 +101,29 @@ export KODEVU_REVIEWER=gemini
 npx kodevu .
 ```
 
+Use the OpenAI API directly with a small set of extra settings:
+```bash
+export KODEVU_REVIEWER=openai
+export KODEVU_OPENAI_API_KEY=sk-...
+export KODEVU_OPENAI_MODEL=gpt-5-mini
+npx kodevu .
+```
+
+Use a custom OpenAI-compatible endpoint:
+```bash
+npx kodevu . \
+  --reviewer openai \
+  --openai-api-key sk-... \
+  --openai-base-url https://your-gateway.example.com/v1 \
+  --openai-model gpt-5-mini
+```
+
 ## How it Works
 
 - **Git Targets**: `target` must be a local repository or subdirectory.
 - **SVN Targets**: `target` can be a working copy path or repository URL.
 - **Reviewer "auto"**: Probes `codex`, `gemini`, and `copilot` in your `PATH` and selects one.
+- **Reviewer "openai"**: Calls the OpenAI Chat Completions API directly. `auto` does not select `openai`, so API-based use stays explicit.
 - **Contextual Review**: For local repositories, the reviewer can inspect related files beyond the diff to provide deeper insights.
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodevu",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "license": "MIT",
   "type": "module",
   "description": "Poll SVN revisions or Git commits, send each change diff to a reviewer CLI, and write configurable review reports.",

package/src/config.js

@@ -8,7 +8,8 @@ const require = createRequire(import.meta.url);
 const { version: packageVersion } = require("../package.json");
 
 const defaultStorageDir = path.join(os.homedir(), ".kodevu");
-const SUPPORTED_REVIEWERS = ["codex", "gemini", "copilot"];
+const SUPPORTED_REVIEWERS = ["codex", "gemini", "copilot", "openai"];
+const AUTO_SUPPORTED_REVIEWERS = ["codex", "gemini", "copilot"];
 
 const defaultConfig = {
   reviewer: "auto",
@@ -21,7 +22,12 @@ const defaultConfig = {
   maxRevisionsPerRun: 5,
   outputFormats: ["markdown"],
   rev: "",
-  last: 0
+  last: 0,
+  openaiApiKey: "",
+  openaiBaseUrl: "https://api.openai.com/v1",
+  openaiModel: "gpt-5-mini",
+  openaiOrganization: "",
+  openaiProject: ""
 };
 
 const ENV_MAP = {
@@ -31,7 +37,12 @@ const ENV_MAP = {
   KODEVU_PROMPT: "prompt",
   KODEVU_TIMEOUT: "commandTimeoutMs",
   KODEVU_MAX_REVISIONS: "maxRevisionsPerRun",
-  KODEVU_FORMATS: "outputFormats"
+  KODEVU_FORMATS: "outputFormats",
+  KODEVU_OPENAI_API_KEY: "openaiApiKey",
+  KODEVU_OPENAI_BASE_URL: "openaiBaseUrl",
+  KODEVU_OPENAI_MODEL: "openaiModel",
+  KODEVU_OPENAI_ORG: "openaiOrganization",
+  KODEVU_OPENAI_PROJECT: "openaiProject"
 };
 
 function resolvePath(value) {
@@ -84,13 +95,13 @@ export function detectLanguage() {
 
 async function resolveAutoReviewers(debug) {
   const availableReviewers = [];
-  for (const reviewerName of SUPPORTED_REVIEWERS) {
+  for (const reviewerName of AUTO_SUPPORTED_REVIEWERS) {
     const commandPath = await findCommandOnPath(reviewerName, { debug });
     if (commandPath) availableReviewers.push({ reviewerName, commandPath });
   }
 
   if (availableReviewers.length === 0) {
-    throw new Error(`No reviewer CLI found in PATH. Install one of: ${SUPPORTED_REVIEWERS.join(", ")}`);
+    throw new Error(`No reviewer CLI found in PATH. Install one of: ${AUTO_SUPPORTED_REVIEWERS.join(", ")}`);
   }
 
   // Shuffle for variety
@@ -114,7 +125,12 @@ export function parseCliArgs(argv) {
     rev: "",
     last: "",
     outputDir: "",
-    outputFormats: ""
+    outputFormats: "",
+    openaiApiKey: "",
+    openaiBaseUrl: "",
+    openaiModel: "",
+    openaiOrganization: "",
+    openaiProject: ""
   };
 
   for (let index = 0; index < argv.length; index += 1) {
@@ -188,6 +204,41 @@ export function parseCliArgs(argv) {
       continue;
     }
 
+    if (value === "--openai-api-key") {
+      if (!hasNextValue) throw new Error(`Missing value for ${value}`);
+      args.openaiApiKey = nextValue;
+      index += 1;
+      continue;
+    }
+
+    if (value === "--openai-base-url") {
+      if (!hasNextValue) throw new Error(`Missing value for ${value}`);
+      args.openaiBaseUrl = nextValue;
+      index += 1;
+      continue;
+    }
+
+    if (value === "--openai-model") {
+      if (!hasNextValue) throw new Error(`Missing value for ${value}`);
+      args.openaiModel = nextValue;
+      index += 1;
+      continue;
+    }
+
+    if (value === "--openai-org") {
+      if (!hasNextValue) throw new Error(`Missing value for ${value}`);
+      args.openaiOrganization = nextValue;
+      index += 1;
+      continue;
+    }
+
+    if (value === "--openai-project") {
+      if (!hasNextValue) throw new Error(`Missing value for ${value}`);
+      args.openaiProject = nextValue;
+      index += 1;
+      continue;
+    }
+
     if (!value.startsWith("-") && !args.target) {
       args.target = value;
       continue;
@@ -210,7 +261,21 @@ export async function resolveConfig(cliArgs = {}) {
   }
 
   // 2. Merge CLI Arguments
-  for (const key of ["target", "reviewer", "prompt", "lang", "rev", "last", "outputDir", "outputFormats"]) {
+  for (const key of [
+    "target",
+    "reviewer",
+    "prompt",
+    "lang",
+    "rev",
+    "last",
+    "outputDir",
+    "outputFormats",
+    "openaiApiKey",
+    "openaiBaseUrl",
+    "openaiModel",
+    "openaiOrganization",
+    "openaiProject"
+  ]) {
     if (cliArgs[key] !== undefined && cliArgs[key] !== "") {
       config[key] = cliArgs[key];
     }
@@ -257,11 +322,20 @@ export async function resolveConfig(cliArgs = {}) {
   config.commandTimeoutMs = Number(config.commandTimeoutMs);
   config.last = Number(config.last);
   config.outputFormats = normalizeOutputFormats(config.outputFormats);
+  config.openaiApiKey = String(config.openaiApiKey || "").trim();
+  config.openaiBaseUrl = String(config.openaiBaseUrl || defaultConfig.openaiBaseUrl).trim().replace(/\/+$/, "");
+  config.openaiModel = String(config.openaiModel || defaultConfig.openaiModel).trim();
+  config.openaiOrganization = String(config.openaiOrganization || "").trim();
+  config.openaiProject = String(config.openaiProject || "").trim();
 
   if (!config.rev && (isNaN(config.last) || config.last === 0)) {
     config.last = 1;
   }
 
+  if (config.reviewer === "openai" && !config.openaiApiKey) {
+    throw new Error('Reviewer "openai" requires an API key. Set KODEVU_OPENAI_API_KEY or pass --openai-api-key.');
+  }
+
   return config;
 }
 
@@ -273,13 +347,18 @@ Usage:
 
 Options:
   --target, <path>  Target repository path (default: current directory)
-  --reviewer, -r    Reviewer (codex | gemini | copilot | auto, default: auto)
+  --reviewer, -r    Reviewer (codex | gemini | copilot | openai | auto, default: auto)
   --prompt, -p      Additional instructions or @file.txt to read from file
   --lang, -l        Output language (e.g. zh, en, auto)
   --rev, -v         Review specific revision(s), hashes, branches or ranges (comma-separated)
   --last, -n        Review the latest N revisions; use negative (-N) to review only the Nth-from-last revision (default: 1)
   --output, -o      Output directory (default: ~/.kodevu)
   --format, -f      Output formats (markdown, json, comma-separated)
+  --openai-api-key  API key used when reviewer=openai
+  --openai-base-url Base URL used when reviewer=openai (default: https://api.openai.com/v1)
+  --openai-model    Model used when reviewer=openai (default: gpt-5-mini)
+  --openai-org      Optional OpenAI organization ID
+  --openai-project  Optional OpenAI project ID
   --debug, -d       Print extra debug information
   --help, -h        Show help
   --version, -V     Show version
@@ -290,6 +369,11 @@ Environment Variables:
   KODEVU_OUTPUT_DIR Default output directory
   KODEVU_PROMPT     Default prompt text
   KODEVU_TIMEOUT    Reviewer timeout in ms
+  KODEVU_OPENAI_API_KEY   API key for reviewer=openai
+  KODEVU_OPENAI_BASE_URL  Base URL for reviewer=openai
+  KODEVU_OPENAI_MODEL     Model for reviewer=openai
+  KODEVU_OPENAI_ORG       Organization ID for reviewer=openai
+  KODEVU_OPENAI_PROJECT   Project ID for reviewer=openai
 `);
 }
 

package/src/index.js

@@ -40,6 +40,10 @@ try {
         reviewer: config.reviewer,
         reviewerCommandPath: config.reviewerCommandPath,
         reviewerWasAutoSelected: config.reviewerWasAutoSelected,
+        openaiBaseUrl: config.openaiBaseUrl,
+        openaiModel: config.openaiModel,
+        openaiOrganization: config.openaiOrganization,
+        openaiProject: config.openaiProject,
         target: config.target,
         outputDir: config.outputDir,
         lang: config.lang,

package/src/report-generator.js

@@ -52,7 +52,6 @@ export function shouldWriteFormat(config, format) {
 }
 
 export function buildReport(config, backend, targetInfo, details, diffPayloads, reviewer, reviewerResult, tokenUsage) {
-  const stderrText = reviewerResult.stderr?.trim();
   const lang = config.resolvedLang || "en";
   const lines = [
     `# ${backend.displayName} Review Report: ${details.displayId}`,
@@ -64,8 +63,6 @@ export function buildReport(config, backend, targetInfo, details, diffPayloads,
     `- ${getPhrase("date", lang)}: \`${formatDate(details.date)}\``,
     `- Generated At: \`${formatDate(new Date())}\``,
     `- Reviewer: \`${reviewer.displayName}\``,
-    `- Reviewer Exit Code: \`${reviewerResult.code}\``,
-    `- Reviewer Timed Out: \`${reviewerResult.timedOut ? "yes" : "no"}\``,
     "",
     "## Token Usage",
     "",
@@ -79,27 +76,12 @@ export function buildReport(config, backend, targetInfo, details, diffPayloads,
     "",
     details.message ? "```text\n" + details.message + "\n```" : "_Empty_",
     "",
-    "## Review Context",
-    "",
-    "```text",
-    buildPrompt(config, backend, targetInfo, details, diffPayloads.review),
-    "```",
-    "",
-    "## Diff Handling",
-    "",
-    formatDiffHandling(diffPayloads.review, "Reviewer Input"),
-    formatDiffHandling(diffPayloads.report, "Report Diff"),
-    "",
     "## Diff",
     "",
     "```diff",
     diffPayloads.report.text.trim() || "(empty diff)",
     "```",
     "",
-    "## Reviewer Diagnostics",
-    "",
-    stderrText ? "```text\n" + stderrText + "\n```" : "_No stderr output._",
-    "",
     `## ${reviewer.responseSectionTitle}`,
     "",
     reviewerResult.message?.trim() ? reviewerResult.message.trim() : reviewer.emptyResponseText

package/src/reviewers.js

@@ -6,6 +6,48 @@ import { prepareDiffPayloads } from "./diff-processor.js";
 import { buildPrompt, getReviewWorkspaceRoot } from "./report-generator.js";
 import { resolveTokenUsage } from "./token-usage.js";
 
+function buildOpenAiRequestHeaders(config) {
+  const headers = {
+    "content-type": "application/json",
+    authorization: `Bearer ${config.openaiApiKey}`
+  };
+
+  if (config.openaiOrganization) {
+    headers["OpenAI-Organization"] = config.openaiOrganization;
+  }
+
+  if (config.openaiProject) {
+    headers["OpenAI-Project"] = config.openaiProject;
+  }
+
+  return headers;
+}
+
+function extractOpenAiMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+
+  if (!Array.isArray(content)) {
+    return "";
+  }
+
+  return content
+    .map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+
+      if (item?.type === "text" && typeof item.text === "string") {
+        return item.text;
+      }
+
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
 export const REVIEWERS = {
   codex: {
     displayName: "Codex",
@@ -122,6 +164,78 @@ export const REVIEWERS = {
         await fs.rm(tempDir, { recursive: true, force: true });
       }
     }
+  },
+  openai: {
+    displayName: "OpenAI API",
+    responseSectionTitle: "OpenAI Response",
+    emptyResponseText: "_No final response returned from the OpenAI API._",
+    async run(config, workingDir, promptText, diffText) {
+      const requestBody = {
+        model: config.openaiModel,
+        messages: [
+          {
+            role: "user",
+            content: [promptText, "Unified diff:", diffText].join("\n\n")
+          }
+        ]
+      };
+
+      try {
+        const response = await fetch(`${config.openaiBaseUrl}/chat/completions`, {
+          method: "POST",
+          headers: buildOpenAiRequestHeaders(config),
+          body: JSON.stringify(requestBody),
+          signal: AbortSignal.timeout(config.commandTimeoutMs)
+        });
+
+        const responseText = await response.text();
+        let payload;
+
+        try {
+          payload = responseText ? JSON.parse(responseText) : {};
+        } catch {
+          payload = null;
+        }
+
+        if (!response.ok) {
+          const errorMessage = payload?.error?.message || responseText || `HTTP ${response.status}`;
+          return {
+            code: response.status,
+            timedOut: false,
+            stdout: "",
+            stderr: errorMessage,
+            message: ""
+          };
+        }
+
+        const message = extractOpenAiMessageContent(payload?.choices?.[0]?.message?.content);
+        const usage = payload?.usage
+          ? {
+              inputTokens: Number(payload.usage.prompt_tokens || 0),
+              outputTokens: Number(payload.usage.completion_tokens || 0),
+              totalTokens: Number(payload.usage.total_tokens || 0)
+            }
+          : null;
+
+        return {
+          code: 0,
+          timedOut: false,
+          stdout: responseText,
+          stderr: "",
+          message,
+          usage
+        };
+      } catch (error) {
+        const timedOut = error?.name === "TimeoutError" || error?.name === "AbortError";
+        return {
+          code: 1,
+          timedOut,
+          stdout: "",
+          stderr: error?.message || String(error),
+          message: ""
+        };
+      }
+    }
   }
 };
 
@@ -133,6 +247,7 @@ export async function runReviewerPrompt(config, backend, targetInfo, details, di
   const result = await reviewer.run(config, reviewWorkspaceRoot, promptText, diffPayloads.review.text);
   const tokenUsage = resolveTokenUsage(
     config.reviewer,
+    result.usage,
     result.stderr,
     promptText,
     diffPayloads.review.text,

package/src/token-usage.js

@@ -32,7 +32,29 @@ export function parseTokenUsage(stderr) {
   return { inputTokens, outputTokens, totalTokens };
 }
 
-export function resolveTokenUsage(reviewerName, stderr, promptText, diffText, responseText) {
+function normalizeUsageObject(usage) {
+  if (!usage || typeof usage !== "object") {
+    return null;
+  }
+
+  const inputTokens = Number(usage.inputTokens || 0);
+  const outputTokens = Number(usage.outputTokens || 0);
+  const totalTokens = Number(usage.totalTokens || (inputTokens + outputTokens));
+
+  if (totalTokens <= 0 && inputTokens <= 0 && outputTokens <= 0) {
+    return null;
+  }
+
+  return { inputTokens, outputTokens, totalTokens };
+}
+
+export function resolveTokenUsage(reviewerName, usage, stderr, promptText, diffText, responseText) {
+  const normalizedUsage = normalizeUsageObject(usage);
+
+  if (normalizedUsage) {
+    return { ...normalizedUsage, source: "reviewer" };
+  }
+
   const parsed = parseTokenUsage(stderr);
 
   if (parsed && parsed.totalTokens > 0) {