android2harmony 0.1.0

package/agents/scripts/hmos-precheck/codelinter.mjs

@@ -0,0 +1,362 @@
+import { spawn } from "node:child_process";
+import { constants as fsConstants } from "node:fs";
+import { access } from "node:fs/promises";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+async function exists(pathname) {
+  try {
+    await access(pathname, fsConstants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runCommand(command, args, cwd, timeoutSeconds) {
+  return await new Promise((resolve) => {
+    const proc = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const timer = timeoutSeconds && timeoutSeconds > 0 ? setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGKILL");
+    }, timeoutSeconds * 1e3) : null;
+    proc.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    proc.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve({ code: code ?? 1, stdout, stderr, timedOut });
+    });
+    proc.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      stderr += error instanceof Error ? error.message : String(error);
+      resolve({ code: 1, stdout, stderr, timedOut });
+    });
+  });
+}
+async function clearArtifacts(...paths) {
+  await Promise.all(paths.map(async (pathname) => {
+    await rm(pathname, { force: true });
+  }));
+}
+function candidateRoots(commandlineTools) {
+  const resolved = path.resolve(commandlineTools);
+  return [.../* @__PURE__ */ new Set([resolved, path.dirname(resolved)])];
+}
+async function findCodelinterTool(commandlineTools) {
+  if (!commandlineTools) return null;
+  const suffixes = process.platform.startsWith("win") ? ["codelinter.bat", "codelinter.cmd"] : ["codelinter"];
+  const candidates = [];
+  for (const root of candidateRoots(commandlineTools)) {
+    for (const suffix of suffixes) {
+      candidates.push(
+        path.join(root, "bin", suffix),
+        path.join(root, "codelinter", "bin", suffix)
+      );
+    }
+  }
+  for (const candidate of candidates) {
+    if (await exists(candidate)) return path.resolve(candidate);
+  }
+  return null;
+}
+async function runGit(projectRoot, args) {
+  return await runCommand("git", args, projectRoot);
+}
+async function changedEtsFiles(projectRoot, baseRef, headRef) {
+  const args = ["diff", "--name-only", baseRef];
+  if (headRef) {
+    args.push(headRef);
+  }
+  args.push("--", "*.ets");
+  const result = await runGit(projectRoot, args);
+  if (result.code !== 0) {
+    throw new Error(`git diff failed: ${(result.stderr || result.stdout || `exit_code=${result.code}`).trim()}`);
+  }
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of result.stdout.split(/\r?\n/)) {
+    if (!line || !line.endsWith(".ets")) continue;
+    const absolutePath = path.resolve(projectRoot, line);
+    if (!await exists(absolutePath) || seen.has(absolutePath)) continue;
+    seen.add(absolutePath);
+    files.push(absolutePath);
+  }
+  if (headRef === null) {
+    const untracked = await runGit(projectRoot, ["ls-files", "--others", "--exclude-standard", "--", "*.ets"]);
+    if (untracked.code !== 0) {
+      throw new Error(`git ls-files failed: ${(untracked.stderr || untracked.stdout || `exit_code=${untracked.code}`).trim()}`);
+    }
+    for (const line of untracked.stdout.split(/\r?\n/)) {
+      if (!line || !line.endsWith(".ets")) continue;
+      const absolutePath = path.resolve(projectRoot, line);
+      if (!await exists(absolutePath) || seen.has(absolutePath)) continue;
+      seen.add(absolutePath);
+      files.push(absolutePath);
+    }
+  }
+  return files;
+}
+function parseUnifiedZeroHunks(diffText) {
+  const changedRanges = {};
+  let currentFile = null;
+  for (const line of diffText.split(/\r?\n/)) {
+    if (line.startsWith("+++ b/")) {
+      currentFile = line.replace("+++ b/", "");
+      if (!changedRanges[currentFile]) changedRanges[currentFile] = [];
+      continue;
+    }
+    if (!currentFile || !line.startsWith("@@")) continue;
+    const match = /@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (!match) continue;
+    const start = Number.parseInt(match[1], 10);
+    const count = match[2] !== undefined ? Number.parseInt(match[2], 10) : 1;
+    if (count > 0) changedRanges[currentFile].push([start, start + count - 1]);
+  }
+  return changedRanges;
+}
+async function changedEtsLineRanges(projectRoot, baseRef, headRef) {
+  const args = ["diff", "--unified=0", baseRef];
+  if (headRef) args.push(headRef);
+  args.push("--", "*.ets");
+  const result = await runGit(projectRoot, args);
+  if (result.code !== 0) {
+    throw new Error(`git diff failed: ${(result.stderr || result.stdout || `exit_code=${result.code}`).trim()}`);
+  }
+  const parsed = parseUnifiedZeroHunks(result.stdout);
+  return parsed;
+}
+function lineInRanges(line, ranges) {
+  if (line === null) return false;
+  return ranges.some(([start, end]) => start <= line && line <= end);
+}
+function normalizeSeverity(value) {
+  const severity = String(value ?? "").toLowerCase();
+  return severity === "warn" ? "warning" : severity;
+}
+function relativeFile(projectRoot, rawPath) {
+  const absolute = path.isAbsolute(rawPath) ? rawPath : path.resolve(projectRoot, rawPath);
+  if (!absolute.startsWith(path.resolve(projectRoot) + path.sep)) {
+    return rawPath.replace(/\\/g, "/");
+  }
+  return path.relative(projectRoot, absolute).replace(/\\/g, "/");
+}
+async function parseReport(reportPath) {
+  if (!await exists(reportPath)) return [];
+  try {
+    const payload = JSON.parse(await readFile(reportPath, "utf8"));
+    if (Array.isArray(payload)) return payload.filter((item) => item && typeof item === "object");
+    if (payload && typeof payload === "object") return [payload];
+    return [];
+  } catch {
+    return null;
+  }
+}
+async function writeSummary(payload, pathname, maxFindings = 30) {
+  const diagnostics = Array.isArray(payload.diagnostics) ? payload.diagnostics : [];
+  const errors = diagnostics.filter((item) => item.severity === "error");
+  const warnings = diagnostics.filter((item) => item.severity === "warning");
+  const suggestions = diagnostics.filter((item) => item.severity === "suggestion");
+  const lines = [
+    "# CodeLinter Diff Summary",
+    "",
+    `- status: ${String(payload.tool_status ?? "")}`,
+    `- checked_files: ${Array.isArray(payload.checked_files) ? payload.checked_files.length : 0}`,
+    `- errors: ${errors.length}`,
+    `- warnings_hidden_from_fixer: ${warnings.length}`,
+    `- suggestions_hidden_from_fixer: ${suggestions.length}`,
+    "",
+    "## Blocking Errors"
+  ];
+  if (!errors.length) lines.push("- none");
+  for (const item of errors.slice(0, maxFindings)) {
+    lines.push(`- ${String(item.file ?? "<unknown>")}:${String(item.line ?? "?")}:${String(item.column ?? "?")} [${String(item.rule || "no-rule")}] ${String(item.message ?? "")}`);
+  }
+  await writeFile(pathname, `${lines.join("\n")}
+`, "utf8");
+}
+function unavailable(reason, checkedFiles, changedLineRanges, elapsedMs, failureRule) {
+  const payload = {
+    tool: "codelinter",
+    tool_status: "unavailable",
+    evidence_status: "partial",
+    success: true,
+    checked_files: checkedFiles,
+    diagnostics: [],
+    summary: { errorCount: 0, warnCount: 0, suggestionCount: 0 },
+    reason,
+    scope: "diff",
+    changed_files_only: true,
+    changed_line_ranges: Object.fromEntries(Object.entries(changedLineRanges).map(([file, ranges]) => [file, ranges.map(([start, end]) => [start, end])]))
+  };
+  if (failureRule) payload.failure_rule = failureRule;
+  if (elapsedMs !== void 0) payload.elapsed_ms = elapsedMs;
+  return payload;
+}
+function buildArtifactPaths(derivedPath, rawPath, summaryPath, stdoutPath, stderrPath) {
+  return {
+    json: derivedPath,
+    raw_json: rawPath,
+    summary: summaryPath,
+    stdout: stdoutPath,
+    stderr: stderrPath
+  };
+}
+function diagnosticsFromReport(parsedReport, projectRoot, checkedFileList, changedLineRanges) {
+  const diagnostics = [];
+  const checkedFiles = new Set(checkedFileList);
+  let malformed = false;
+  for (const entry of parsedReport) {
+    const relative = relativeFile(projectRoot, String(entry.filePath ?? entry.file ?? ""));
+    if (!checkedFiles.has(relative)) continue;
+    const ranges = changedLineRanges[relative];
+    if (entry.messages !== void 0 && !Array.isArray(entry.messages)) {
+      malformed = true;
+      continue;
+    }
+    for (const rawMessage of Array.isArray(entry.messages) ? entry.messages : []) {
+      if (!rawMessage || typeof rawMessage !== "object" || Array.isArray(rawMessage)) {
+        malformed = true;
+        continue;
+      }
+      const message = rawMessage;
+      const line = message.line == null ? null : Number(message.line);
+      if (Array.isArray(ranges) && ranges.length === 0) continue;
+      if (Array.isArray(ranges) && line !== null && !lineInRanges(line, ranges)) continue;
+      diagnostics.push({
+        file: relative,
+        line,
+        column: message.column == null ? null : Number(message.column),
+        severity: normalizeSeverity(message.severity),
+        message: String(message.message ?? ""),
+        rule: String(message.rule ?? "")
+      });
+    }
+  }
+  return { diagnostics, checkedFiles: [...checkedFiles].sort(), malformed };
+}
+async function runCodelinterDiffScan(options) {
+  const started = Date.now();
+  const rawReportPath = path.join(options.validationOutputDir, "codelinter-raw-report.json");
+  const derivedReportPath = path.join(options.validationOutputDir, "codelinter-derived.json");
+  const stdoutPath = path.join(options.validationOutputDir, "codelinter-stdout.txt");
+  const stderrPath = path.join(options.validationOutputDir, "codelinter-stderr.txt");
+  const summaryPath = path.join(options.validationOutputDir, "codelinter-fix-summary.md");
+  await mkdir(options.validationOutputDir, { recursive: true });
+  await clearArtifacts(rawReportPath, derivedReportPath, stdoutPath, stderrPath, summaryPath);
+  let payload;
+  try {
+    const files = await changedEtsFiles(options.projectRoot, options.baseRef ?? "HEAD", options.headRef ?? null);
+    const changedLineRanges = await changedEtsLineRanges(options.projectRoot, options.baseRef ?? "HEAD", options.headRef ?? null);
+    if (!files.length) {
+      payload = {
+        tool: "codelinter",
+        tool_status: "ok",
+        success: true,
+        checked_files: [],
+        diagnostics: [],
+        summary: { errorCount: 0, warnCount: 0, suggestionCount: 0 },
+        reason: "no changed ETS files",
+        scope: "diff",
+        changed_files_only: true,
+        changed_line_ranges: {}
+      };
+    } else {
+      const codelinter = await findCodelinterTool(options.commandlineTools);
+      const checkedFileList = files.map((file) => path.relative(options.projectRoot, file).replace(/\\/g, "/"));
+      if (!codelinter) {
+        payload = unavailable("codelinter not found", checkedFileList, changedLineRanges, void 0, "codelinter-missing");
+      } else {
+        const command = [
+          "--format",
+          "json",
+          "--output",
+          rawReportPath,
+          "--exit-on",
+          "error"
+        ];
+        if (options.incremental) command.push("--incremental");
+        command.push(...checkedFileList);
+        const result = await runCommand(codelinter, command, options.projectRoot, options.timeoutSeconds ?? 30);
+        await writeFile(stdoutPath, result.stdout || "", "utf8");
+        await writeFile(stderrPath, result.stderr || "", "utf8");
+        if (result.timedOut) {
+          payload = unavailable(`codelinter timed out after ${options.timeoutSeconds ?? 30}s`, checkedFileList, changedLineRanges, Date.now() - started, "codelinter-timeout");
+          payload.incremental = Boolean(options.incremental);
+          payload.timeout_seconds = options.timeoutSeconds ?? 30;
+        } else {
+          const parsedReport = await parseReport(rawReportPath);
+          if (parsedReport === null) {
+            payload = unavailable("codelinter produced an unreadable JSON report", checkedFileList, changedLineRanges, Date.now() - started, "codelinter-report-invalid");
+            payload.exit_code = result.code;
+            payload.incremental = Boolean(options.incremental);
+            payload.timeout_seconds = options.timeoutSeconds ?? 30;
+          } else {
+            const { diagnostics, checkedFiles, malformed } = diagnosticsFromReport(parsedReport, options.projectRoot, checkedFileList, changedLineRanges);
+            if (malformed) {
+              payload = unavailable("codelinter produced a malformed JSON report", checkedFileList, changedLineRanges, Date.now() - started, "codelinter-report-invalid");
+              payload.exit_code = result.code;
+              payload.incremental = Boolean(options.incremental);
+              payload.timeout_seconds = options.timeoutSeconds ?? 30;
+            } else {
+              const toolStatus = await exists(rawReportPath) ? "ok" : "internal_error";
+              payload = {
+                tool: "codelinter",
+                tool_status: toolStatus,
+                evidence_status: toolStatus === "ok" ? "raw_structured" : "partial",
+                success: toolStatus === "ok" && !diagnostics.some((item) => item.severity === "error"),
+                checked_files: checkedFiles,
+                diagnostics,
+                summary: {
+                  errorCount: diagnostics.filter((item) => item.severity === "error").length,
+                  warnCount: diagnostics.filter((item) => item.severity === "warning").length,
+                  suggestionCount: diagnostics.filter((item) => item.severity === "suggestion").length
+                },
+                reason: toolStatus === "ok" ? null : `codelinter exited without report (exit_code=${result.code})`,
+                failure_rule: toolStatus === "ok" ? null : "codelinter-report-missing",
+                scope: "diff",
+                changed_files_only: true,
+                changed_line_ranges: Object.fromEntries(Object.entries(changedLineRanges).map(([file, ranges]) => [file, ranges.map(([start, end]) => [start, end])])),
+                exit_code: result.code,
+                elapsed_ms: Date.now() - started,
+                incremental: Boolean(options.incremental),
+                timeout_seconds: options.timeoutSeconds ?? 30
+              };
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    payload = unavailable(
+      error instanceof Error ? error.message : String(error),
+      [],
+      {},
+      Date.now() - started,
+      "git-diff-failed"
+    );
+  }
+  payload.artifact_paths = buildArtifactPaths(derivedReportPath, rawReportPath, summaryPath, stdoutPath, stderrPath);
+  await writeFile(derivedReportPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  await writeSummary(payload, summaryPath);
+  return payload;
+}
+const __test__ = {
+  parseUnifiedZeroHunks,
+  relativeFile
+};
+export {
+  __test__,
+  findCodelinterTool,
+  runCodelinterDiffScan
+};