kodevu 0.1.27 → 0.1.29

package/README.md

@@ -59,6 +59,12 @@ Run with debug logs:
 npx kodevu /path/to/your/repo --debug
 ```
 
+Specify the output language (e.g., Chinese):
+
+```bash
+npx kodevu /path/to/your/repo --lang zh
+```
+
 Use a custom config path only when needed:
 
 ```bash
@@ -77,7 +83,8 @@ npx kodevu /path/to/your/repo --config ./config.current.json
 
 - `target`: required repository target; can be provided by config or as the CLI positional argument
 - `reviewer`: `codex`, `gemini`, `copilot`, or `auto`; default `auto`
-- `prompt`: saved into the report as review context
+- `prompt`: additional instructions for the reviewer; usually empty by default as the core instructions are built-in
+- `lang`: output language for the review (e.g., `zh`, `en`, `auto`); default `auto`
 - `outputDir`: report output directory; default `~/.kodevu`
 - `outputFormats`: report formats to generate; supports `markdown` and `json`; default `["markdown"]`
 - `stateFilePath`: review state file path; default `~/.kodevu/state.json`
@@ -110,6 +117,7 @@ Internal defaults:
 - If `outputFormats` includes `json`, matching `.json` files are generated alongside Markdown reports.
 - `~/.kodevu/state.json` stores per-project checkpoints keyed by repository identity; only the v2 multi-project structure is supported.
 - If the reviewer command exits non-zero or times out, the report is still written, but the state is not advanced so the change can be retried later.
+- Review instructions are built into the tool in English to ensure consistent logic across reviewers. The `lang` setting (CLI `--lang` or config `lang`) determines the language AI uses for the resulting review. When set to `auto`, Kodevu detects the language from the system environment (`LANG`, `LC_ALL`, or system locale).
 - Each report includes a `Token Usage` section recording token consumption for the review task. When the reviewer CLI outputs token statistics (via stderr), those are used directly (`source: "reviewer"`). Otherwise tokens are estimated at ~4 characters per token (`source: "estimate"`). The JSON report contains a `tokenUsage` object with `inputTokens`, `outputTokens`, `totalTokens`, and `source`.
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodevu",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "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

@@ -6,15 +6,16 @@ import { findCommandOnPath } from "./shell.js";
 const defaultStorageDir = path.join(os.homedir(), ".kodevu");
 const SUPPORTED_REVIEWERS = ["codex", "gemini", "copilot"];
 
+
 const defaultConfig = {
   reviewer: "auto",
   target: "",
+  lang: "auto",
   outputDir: defaultStorageDir,
   stateFilePath: path.join(defaultStorageDir, "state.json"),
   logsDir: path.join(defaultStorageDir, "logs"),
   commandTimeoutMs: 600000,
-  prompt:
-    "请严格审查当前变更，优先指出 bug、回归风险、兼容性问题、安全问题、边界条件缺陷和缺失测试。请使用简体中文输出 Markdown；如果没有明确缺陷，请写“未发现明确缺陷”，并补充剩余风险。",
+  prompt: "",
   maxRevisionsPerRun: 5,
   outputFormats: ["markdown"]
 };
@@ -22,6 +23,7 @@ const defaultConfig = {
 const configTemplate = {
   target: "C:/path/to/your/repository-or-subdirectory",
   reviewer: defaultConfig.reviewer,
+  lang: defaultConfig.lang,
   prompt: defaultConfig.prompt,
   outputDir: "~/.kodevu",
   stateFilePath: "~/.kodevu/state.json",
@@ -74,6 +76,38 @@ function normalizeOutputFormats(outputFormats, loadedConfigPath) {
   return normalized;
 }
 
+function detectLanguage() {
+  const envLang = (process.env.LANG || process.env.LC_ALL || process.env.LC_MESSAGES || "").toLowerCase();
+  const intlLocale = (() => {
+    try {
+      return Intl.DateTimeFormat().resolvedOptions().locale.toLowerCase();
+    } catch {
+      return "";
+    }
+  })();
+
+  // On Windows, the LANG environment variable is often set to 'en_US.UTF-8' by default
+  // in many shells (like Git Bash/MSYS2), regardless of the actual OS display language.
+  // We prefer the system locale (Intl) on Windows if it's Chinese.
+  if (os.platform() === "win32" && intlLocale.startsWith("zh")) {
+    return "zh";
+  }
+
+  if (envLang) {
+    if (envLang.startsWith("zh")) return "zh";
+    if (envLang.startsWith("en")) return "en";
+    return envLang.split(/[._-]/)[0];
+  }
+
+  if (intlLocale) {
+    if (intlLocale.startsWith("zh")) return "zh";
+    if (intlLocale.startsWith("en")) return "en";
+    return intlLocale.split("-")[0];
+  }
+
+  return "en";
+}
+
 async function resolveAutoReviewers(debug, loadedConfigPath) {
   const availableReviewers = [];
 
@@ -109,6 +143,7 @@ export function parseCliArgs(argv) {
     debug: false,
     help: false,
     reviewer: "",
+    lang: "",
     prompt: "",
     commandExplicitlySet: false
   };
@@ -163,6 +198,16 @@ export function parseCliArgs(argv) {
       continue;
     }
 
+    if (value === "--lang" || value === "-l") {
+      const lang = argv[index + 1];
+      if (!lang || lang.startsWith("-")) {
+        throw new Error(`Missing value for ${value}`);
+      }
+      args.lang = lang;
+      index += 1;
+      continue;
+    }
+
     if (!value.startsWith("-") && args.command === "run" && !args.target) {
       args.target = value;
       continue;
@@ -209,12 +254,19 @@ export async function loadConfig(configPath, cliArgs = {}) {
     config.prompt = cliArgs.prompt;
   }
 
+  if (cliArgs.lang) {
+    config.lang = cliArgs.lang;
+  }
+
   if (!config.target) {
     throw new Error('Missing target. Pass `npx kodevu <repo-path>` or set "target" in config.json.');
   }
 
   config.debug = Boolean(cliArgs.debug);
   config.reviewer = String(config.reviewer || "auto").toLowerCase();
+  config.lang = String(config.lang || "auto").toLowerCase();
+
+  config.resolvedLang = config.lang === "auto" ? detectLanguage() : config.lang;
 
   if (config.reviewer === "auto") {
     const availableReviewers = await resolveAutoReviewers(config.debug, loadedConfigPath);
@@ -264,6 +316,7 @@ Options:
   --config, -c   Optional config json path. If omitted, ./config.json is loaded only when present
   --reviewer, -r Override reviewer (codex | gemini | copilot | auto)
   --prompt, -p   Override prompt
+  --lang, -l     Override output language (e.g. zh, en, auto)
   --debug, -d    Print extra debug information to the console
   --help, -h     Show help
 

package/src/diff-processor.js

@@ -0,0 +1,95 @@
+import { countLines } from "./utils.js";
+
+export const DIFF_LIMITS = {
+  review: {
+    maxLines: 4000,
+    maxChars: 120000
+  },
+  report: {
+    maxLines: 1500,
+    maxChars: 40000
+  },
+  tailLines: 200
+};
+
+export function trimBlockToChars(text, maxChars, keepTail = false) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+
+  if (maxChars <= 3) {
+    return ".".repeat(Math.max(maxChars, 0));
+  }
+
+  return keepTail ? `...${text.slice(-(maxChars - 3))}` : `${text.slice(0, maxChars - 3)}...`;
+}
+
+export function truncateDiffText(diffText, maxLines, maxChars, tailLines, purposeLabel) {
+  const normalizedDiff = diffText.replace(/\r\n/g, "\n");
+  const originalLineCount = countLines(normalizedDiff);
+  const originalCharCount = normalizedDiff.length;
+
+  if (originalLineCount <= maxLines && originalCharCount <= maxChars) {
+    return {
+      text: diffText,
+      wasTruncated: false,
+      originalLineCount,
+      originalCharCount,
+      outputLineCount: originalLineCount,
+      outputCharCount: originalCharCount
+    };
+  }
+
+  const lines = normalizedDiff.split("\n");
+  const safeTailLines = Math.min(Math.max(tailLines, 0), Math.max(maxLines - 2, 0));
+  const headLineCount = Math.max(maxLines - safeTailLines - 1, 1);
+  let headBlock = lines.slice(0, headLineCount).join("\n");
+  let tailBlock = safeTailLines > 0 ? lines.slice(-safeTailLines).join("\n") : "";
+  const omittedLineCount = Math.max(originalLineCount - headLineCount - safeTailLines, 0);
+  const markerBlock = [
+    `... diff truncated for ${purposeLabel} ...`,
+    `original lines: ${originalLineCount}, original chars: ${originalCharCount}`,
+    `omitted lines: ${omittedLineCount}`
+  ].join("\n");
+
+  let truncatedText = [headBlock, markerBlock, tailBlock].filter(Boolean).join("\n");
+
+  if (truncatedText.length > maxChars) {
+    const reservedChars = markerBlock.length + (tailBlock ? 2 : 1);
+    const remainingChars = Math.max(maxChars - reservedChars, 0);
+    const headBudget = tailBlock ? Math.floor(remainingChars * 0.7) : remainingChars;
+    const tailBudget = tailBlock ? Math.max(remainingChars - headBudget, 0) : 0;
+    headBlock = trimBlockToChars(headBlock, headBudget, false);
+    tailBlock = trimBlockToChars(tailBlock, tailBudget, true);
+    truncatedText = [headBlock, markerBlock, tailBlock].filter(Boolean).join("\n");
+  }
+
+  return {
+    text: truncatedText,
+    wasTruncated: true,
+    originalLineCount,
+    originalCharCount,
+    outputLineCount: countLines(truncatedText),
+    outputCharCount: truncatedText.length
+  };
+}
+
+export function prepareDiffPayloads(config, diffText) {
+  return {
+    review: truncateDiffText(
+      diffText,
+      DIFF_LIMITS.review.maxLines,
+      DIFF_LIMITS.review.maxChars,
+      DIFF_LIMITS.tailLines,
+      "reviewer input"
+    ),
+    report: truncateDiffText(
+      diffText,
+      DIFF_LIMITS.report.maxLines,
+      DIFF_LIMITS.report.maxChars,
+      Math.min(DIFF_LIMITS.tailLines, DIFF_LIMITS.report.maxLines),
+      "report output"
+    )
+  };
+}
+

package/src/index.js

@@ -49,6 +49,7 @@ try {
         reviewerWasAutoSelected: config.reviewerWasAutoSelected,
         target: config.target,
         outputDir: config.outputDir,
+        lang: config.lang,
         debug: config.debug
       })}`
     );

package/src/report-generator.js

@@ -0,0 +1,185 @@
+export const CORE_REVIEW_INSTRUCTION =
+  "Please strictly review the current changes, prioritizing bugs, regression risks, compatibility issues, security concerns, boundary condition flaws, and missing tests. Please use Markdown for your response. If no clear flaws are found, write \"No clear flaws found\" and supplement with residual risks.";
+
+export function getReviewWorkspaceRoot(config, backend, targetInfo) {
+  if (backend.kind === "git" && targetInfo.repoRootPath) {
+    return targetInfo.repoRootPath;
+  }
+
+  if (backend.kind === "svn" && targetInfo.workingCopyPath) {
+    return targetInfo.workingCopyPath;
+  }
+
+  return config.baseDir;
+}
+
+export function buildPrompt(config, backend, targetInfo, details, reviewDiffPayload) {
+  const fileList = details.changedPaths.map((item) => `${item.action} ${item.relativePath}`).join("\n");
+  const workspaceRoot = getReviewWorkspaceRoot(config, backend, targetInfo);
+  const canReadRelatedFiles = backend.kind === "git" || Boolean(targetInfo.workingCopyPath);
+
+  const langInstruction = config.resolvedLang === "zh"
+    ? "Please use Simplified Chinese for your response."
+    : `Please use ${config.resolvedLang || "English"} for your response.`;
+
+  return [
+    CORE_REVIEW_INSTRUCTION,
+    langInstruction,
+    config.prompt,
+    canReadRelatedFiles
+      ? `You are running inside a read-only workspace rooted at: ${workspaceRoot}`
+      : "No local repository workspace is available for this review run.",
+    canReadRelatedFiles
+      ? "Besides the diff below, you may read other related files in the workspace when needed to understand call sites, shared utilities, configuration, tests, or data flow. Do not modify files or rely on shell commands."
+      : "Review primarily from the diff below. Do not assume access to other local files, shell commands, or repository history.",
+    "Use plain text file references like path/to/file.js:123. Do not emit clickable workspace links.",
+    `Repository Type: ${backend.displayName}`,
+    `Change ID: ${details.displayId}`,
+    `Author: ${details.author}`,
+    `Date: ${details.date || "unknown"}`,
+    `Changed files:\n${fileList || "(none)"}`,
+    `Commit message:\n${details.message || "(empty)"}`,
+    reviewDiffPayload.wasTruncated
+      ? `Diff delivery note: the diff was truncated before being sent to the reviewer to stay within configured size limits. Original diff size was ${reviewDiffPayload.originalLineCount} lines / ${reviewDiffPayload.originalCharCount} chars, and the included excerpt is ${reviewDiffPayload.outputLineCount} lines / ${reviewDiffPayload.outputCharCount} chars. Use the changed file list and inspect related workspace files when needed.`
+      : `Diff delivery note: the full diff is included. Size is ${reviewDiffPayload.originalLineCount} lines / ${reviewDiffPayload.originalCharCount} chars.`
+  ].filter(Boolean).join("\n\n");
+}
+
+export function formatTokenUsage(tokenUsage) {
+  const sourceLabel = tokenUsage.source === "reviewer" ? "reviewer reported" : "estimated (~4 chars/token)";
+  return [
+    `- Input Tokens: \`${tokenUsage.inputTokens}\``,
+    `- Output Tokens: \`${tokenUsage.outputTokens}\``,
+    `- Total Tokens: \`${tokenUsage.totalTokens}\``,
+    `- Token Source: \`${sourceLabel}\``
+  ].join("\n");
+}
+
+export function formatDiffHandling(diffPayload, label) {
+  return [
+    `- ${label} Original Lines: \`${diffPayload.originalLineCount}\``,
+    `- ${label} Original Chars: \`${diffPayload.originalCharCount}\``,
+    `- ${label} Included Lines: \`${diffPayload.outputLineCount}\``,
+    `- ${label} Included Chars: \`${diffPayload.outputCharCount}\``,
+    `- ${label} Truncated: \`${diffPayload.wasTruncated ? "yes" : "no"}\``
+  ].join("\n");
+}
+
+export function formatChangedPaths(changedPaths) {
+  if (changedPaths.length === 0) {
+    return "_No changed files captured._";
+  }
+
+  return changedPaths
+    .map((item) => {
+      const renameSuffix = item.previousPath ? ` (from ${item.previousPath})` : "";
+      return `- \`${item.action}\` ${item.relativePath}${renameSuffix}`;
+    })
+    .join("\n");
+}
+
+export function formatChangeList(backend, changeIds) {
+  return changeIds.map((changeId) => backend.formatChangeId(changeId)).join(", ");
+}
+
+export function shouldWriteFormat(config, format) {
+  return Array.isArray(config.outputFormats) && config.outputFormats.includes(format);
+}
+
+export function buildReport(config, backend, targetInfo, details, diffPayloads, reviewer, reviewerResult, tokenUsage) {
+  const lines = [
+    `# ${backend.displayName} Review Report: ${details.displayId}`,
+    "",
+    `- Repository Type: \`${backend.displayName}\``,
+    `- Target: \`${targetInfo.targetDisplay || config.target}\``,
+    `- Change ID: \`${details.displayId}\``,
+    `- Author: \`${details.author}\``,
+    `- Commit Date: \`${details.date || "unknown"}\``,
+    `- Generated At: \`${new Date().toISOString()}\``,
+    `- Reviewer: \`${reviewer.displayName}\``,
+    `- Reviewer Exit Code: \`${reviewerResult.code}\``,
+    `- Reviewer Timed Out: \`${reviewerResult.timedOut ? "yes" : "no"}\``,
+    "",
+    "## Token Usage",
+    "",
+    formatTokenUsage(tokenUsage),
+    "",
+    "## Changed Files",
+    "",
+    formatChangedPaths(details.changedPaths),
+    "",
+    "## Commit Message",
+    "",
+    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.responseSectionTitle}`,
+    "",
+    reviewerResult.message?.trim() ? reviewerResult.message.trim() : reviewer.emptyResponseText
+  ];
+
+  return `${lines.join("\n")}\n`;
+}
+
+export function buildJsonReport(config, backend, targetInfo, details, diffPayloads, reviewer, reviewerResult, tokenUsage) {
+  return {
+    repositoryType: backend.displayName,
+    target: targetInfo.targetDisplay || config.target,
+    changeId: details.displayId,
+    author: details.author,
+    commitDate: details.date || "unknown",
+    generatedAt: new Date().toISOString(),
+    reviewer: {
+      name: reviewer.displayName,
+      exitCode: reviewerResult.code,
+      timedOut: Boolean(reviewerResult.timedOut)
+    },
+    tokenUsage: {
+      inputTokens: tokenUsage.inputTokens,
+      outputTokens: tokenUsage.outputTokens,
+      totalTokens: tokenUsage.totalTokens,
+      source: tokenUsage.source
+    },
+    changedFiles: details.changedPaths.map((item) => ({
+      action: item.action,
+      path: item.relativePath,
+      previousPath: item.previousPath || null
+    })),
+    commitMessage: details.message || "",
+    reviewContext: buildPrompt(config, backend, targetInfo, details, diffPayloads.review),
+    diffHandling: {
+      reviewerInput: {
+        originalLines: diffPayloads.review.originalLineCount,
+        originalChars: diffPayloads.review.originalCharCount,
+        includedLines: diffPayloads.review.outputLineCount,
+        includedChars: diffPayloads.review.outputCharCount,
+        truncated: diffPayloads.review.wasTruncated
+      },
+      reportDiff: {
+        originalLines: diffPayloads.report.originalLineCount,
+        originalChars: diffPayloads.report.originalCharCount,
+        includedLines: diffPayloads.report.outputLineCount,
+        includedChars: diffPayloads.report.outputCharCount,
+        truncated: diffPayloads.report.wasTruncated
+      }
+    },
+    diff: diffPayloads.report.text.trim(),
+    reviewerResponse: reviewerResult.message?.trim() ? reviewerResult.message.trim() : reviewer.emptyResponseText
+  };
+}