android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/jvm/runner.js

@@ -0,0 +1,452 @@
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { hardFailure } from "../diagnostics.js";
+import { runGradle } from "../project/gradle-runner.js";
+import { parseJvmNdjson, readJvmNdjsonFile } from "./protocol.js";
+export const RAW_JVM_FILE_NAME = "raw-jvm.ndjson";
+const DEFAULT_LINT_INIT_SCRIPT = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+  "gradle",
+  "reqgen-lint.init.gradle",
+);
+export const jvmRunnerErrorCodes = {
+  analyzerBuildFailed: "JVM_ANALYZER_BUILD_FAILED",
+  analyzerJarMissing: "JVM_ANALYZER_JAR_MISSING",
+  analyzerJarAmbiguous: "JVM_ANALYZER_JAR_AMBIGUOUS",
+  invalidTarget: "JVM_TARGET_INVALID",
+  pathInaccessible: "JVM_PATH_INACCESSIBLE",
+  outputPrepareFailed: "JVM_OUTPUT_PREPARE_FAILED",
+  lintFailed: "JVM_LINT_FAILED",
+  outputMissing: "JVM_OUTPUT_MISSING",
+  mergeIncompatible: "JVM_MERGE_INCOMPATIBLE",
+  mergeIdConflict: "JVM_MERGE_ID_CONFLICT",
+  mergeWriteFailed: "JVM_MERGE_WRITE_FAILED",
+};
+const DIAGNOSTIC_LOG_LIMIT = 16_000;
+function buildFailure(code, message, details) {
+  throw hardFailure(code, "uast", message, undefined, details);
+}
+function findAnalyzerJar(analyzerProjectRoot, artifactPath) {
+  if (artifactPath) {
+    const explicit = resolve(analyzerProjectRoot, artifactPath);
+    if (!existsSync(explicit) || !statSync(explicit).isFile()) {
+      return buildFailure(
+        jvmRunnerErrorCodes.analyzerJarMissing,
+        `JVM analyzer Jar is missing: ${explicit}`,
+        { path: explicit },
+      );
+    }
+    return explicit;
+  }
+  const libraryDirectory = join(analyzerProjectRoot, "build", "libs");
+  const candidates = existsSync(libraryDirectory)
+    ? readdirSync(libraryDirectory, { withFileTypes: true })
+        .filter(
+          (entry) =>
+            entry.isFile() &&
+            entry.name.endsWith(".jar") &&
+            !/-(?:sources|javadoc|tests)\.jar$/u.test(entry.name),
+        )
+        .map((entry) => resolve(libraryDirectory, entry.name))
+        .sort()
+    : [];
+  if (candidates.length === 0) {
+    return buildFailure(
+      jvmRunnerErrorCodes.analyzerJarMissing,
+      "Gradle completed without producing the JVM analyzer Jar.",
+      { libraryDirectory },
+    );
+  }
+  if (candidates.length !== 1) {
+    return buildFailure(
+      jvmRunnerErrorCodes.analyzerJarAmbiguous,
+      "Gradle produced more than one candidate JVM analyzer Jar.",
+      { candidates },
+    );
+  }
+  return candidates[0];
+}
+export async function buildJvmAnalyzer(options) {
+  const analyzerProjectRoot = resolve(options.analyzerProjectRoot);
+  const executeGradle = options.executeGradle ?? runGradle;
+  const gradleResult = await executeGradle(
+    analyzerProjectRoot,
+    ["--no-daemon", "--console=plain", "jar"],
+    options.gradle,
+  );
+  if (gradleResult.exitCode !== 0) {
+    return buildFailure(
+      jvmRunnerErrorCodes.analyzerBuildFailed,
+      "Gradle could not build the JVM analyzer Jar.",
+      {
+        command: gradleResult.execution.displayCommand,
+        stdoutTail: gradleResult.stdout.slice(-DIAGNOSTIC_LOG_LIMIT),
+        stderrTail: gradleResult.stderr.slice(-DIAGNOSTIC_LOG_LIMIT),
+      },
+    );
+  }
+  return {
+    jarPath: findAnalyzerJar(analyzerProjectRoot, options.artifactPath),
+    gradleResult,
+  };
+}
+function mapGradlePath(path, mapper) {
+  const absolutePath = resolve(path);
+  try {
+    return mapper(absolutePath);
+  } catch (error) {
+    return buildFailure(
+      jvmRunnerErrorCodes.pathInaccessible,
+      `Gradle cannot access required JVM analysis path: ${absolutePath}`,
+      {
+        path: absolutePath,
+        cause: error instanceof Error ? error.message : String(error),
+      },
+    );
+  }
+}
+function validateTarget(target) {
+  const validModule =
+    target.applicationModulePath === ":" ||
+    /^:(?:[A-Za-z0-9_.-]+)(?::[A-Za-z0-9_.-]+)*$/u.test(
+      target.applicationModulePath,
+    );
+  if (
+    !validModule ||
+    target.variantName.trim().length === 0 ||
+    /[\s:]/u.test(target.variantName)
+  ) {
+    return buildFailure(
+      jvmRunnerErrorCodes.invalidTarget,
+      "JVM analysis requires a valid Gradle application module path and variant.",
+      {
+        applicationModulePath: target.applicationModulePath,
+        variantName: target.variantName,
+      },
+    );
+  }
+}
+function upperCamel(value) {
+  return `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}`;
+}
+export function jvmLintTask(applicationModulePath, variantName) {
+  validateTarget({
+    projectRoot: ".",
+    applicationModulePath,
+    variantName,
+  });
+  const prefix = applicationModulePath === ":" ? "" : applicationModulePath;
+  return `${prefix}:lintAnalyze${upperCamel(variantName)}`;
+}
+async function runSingleJvmAnalysis(options) {
+  validateTarget(options.target);
+  const projectRoot = resolve(options.target.projectRoot);
+  const analyzerJarPath = resolve(options.analyzerJarPath);
+  if (!existsSync(analyzerJarPath) || !statSync(analyzerJarPath).isFile()) {
+    return buildFailure(
+      jvmRunnerErrorCodes.analyzerJarMissing,
+      `JVM analyzer Jar is missing: ${analyzerJarPath}`,
+      { path: analyzerJarPath },
+    );
+  }
+  const outputPath = resolve(options.outputDirectory, RAW_JVM_FILE_NAME);
+  try {
+    mkdirSync(resolve(options.outputDirectory), { recursive: true });
+    rmSync(outputPath, { force: true });
+  } catch (error) {
+    return buildFailure(
+      jvmRunnerErrorCodes.outputPrepareFailed,
+      `Unable to prepare raw JVM output: ${outputPath}`,
+      {
+        cause: error instanceof Error ? error.message : String(error),
+      },
+    );
+  }
+  const mapper = options.mapPathForGradle ?? ((path) => path);
+  const gradleOutputPath = mapGradlePath(outputPath, mapper);
+  const gradleSourceRoot = mapGradlePath(
+    options.target.sourceRoot ?? projectRoot,
+    mapper,
+  );
+  const gradleAnalyzerJar = mapGradlePath(analyzerJarPath, mapper);
+  const gradleInitScript = mapGradlePath(
+    options.initScriptPath ?? DEFAULT_LINT_INIT_SCRIPT,
+    mapper,
+  );
+  const lintTask = jvmLintTask(
+    options.target.applicationModulePath,
+    options.target.variantName,
+  );
+  const args = [
+    "--no-daemon",
+    "--console=plain",
+    // Lint analyzes source and does not package the target bytecode. Some
+    // otherwise analyzable Android builds contain library modules whose Java
+    // and Kotlin target declarations differ; Kotlin's default error mode would
+    // prevent Lint from starting at all. Keep the diagnostic visible while
+    // allowing static extraction to proceed.
+    "-Pkotlin.jvm.target.validation.mode=warning",
+    "--init-script",
+    gradleInitScript,
+    `-Dreqgen.lint.jar=${gradleAnalyzerJar}`,
+    `-Dreqgen.application.module=${options.target.applicationModulePath}`,
+    `-Dreqgen.lint.task=${lintTask}`,
+    `-Dreqgen.raw.output=${gradleOutputPath}`,
+    `-Dreqgen.source.root=${gradleSourceRoot}`,
+    lintTask,
+  ];
+  const environment = {
+    ...options.gradle?.environment,
+    ANDROID_LINT_JARS: gradleAnalyzerJar,
+    REQGEN_RAW_OUTPUT: gradleOutputPath,
+    REQGEN_SOURCE_ROOT: gradleSourceRoot,
+  };
+  const executeGradle = options.executeGradle ?? runGradle;
+  const gradleResult = await executeGradle(projectRoot, args, {
+    ...options.gradle,
+    environment,
+  });
+  if (gradleResult.exitCode !== 0) {
+    return buildFailure(
+      jvmRunnerErrorCodes.lintFailed,
+      `Gradle task ${lintTask} failed during JVM analysis.`,
+      {
+        command: gradleResult.execution.displayCommand,
+        stdoutTail: gradleResult.stdout.slice(-DIAGNOSTIC_LOG_LIMIT),
+        stderrTail: gradleResult.stderr.slice(-DIAGNOSTIC_LOG_LIMIT),
+      },
+    );
+  }
+  if (!existsSync(outputPath) || !statSync(outputPath).isFile()) {
+    return buildFailure(
+      jvmRunnerErrorCodes.outputMissing,
+      `Gradle task ${lintTask} did not produce ${RAW_JVM_FILE_NAME}.`,
+      { outputPath },
+    );
+  }
+  return {
+    outputPath,
+    lintTask,
+    document: readJvmNdjsonFile(outputPath),
+    gradleResult,
+  };
+}
+function targetKey(target) {
+  return `${target.applicationModulePath}\u0000${target.variantName}`;
+}
+function orderedModuleTargets(options) {
+  if (options.moduleTargets === undefined) return [options.target];
+  if (options.moduleTargets.length === 0) {
+    return buildFailure(
+      jvmRunnerErrorCodes.invalidTarget,
+      "JVM module analysis requires at least one target.",
+    );
+  }
+  const projectRoot = resolve(options.target.projectRoot);
+  const sourceRoot = resolve(
+    options.target.sourceRoot ?? options.target.projectRoot,
+  );
+  const seen = new Set();
+  const targets = [...options.moduleTargets].sort(
+    (left, right) =>
+      left.applicationModulePath.localeCompare(
+        right.applicationModulePath,
+        "en",
+      ) || left.variantName.localeCompare(right.variantName, "en"),
+  );
+  for (const target of targets) {
+    validateTarget(target);
+    const key = targetKey(target);
+    if (seen.has(key)) {
+      return buildFailure(
+        jvmRunnerErrorCodes.invalidTarget,
+        `JVM module target is duplicated: ${target.applicationModulePath}/${target.variantName}.`,
+        {
+          applicationModulePath: target.applicationModulePath,
+          variantName: target.variantName,
+        },
+      );
+    }
+    seen.add(key);
+    const targetProjectRoot = resolve(target.projectRoot);
+    const targetSourceRoot = resolve(target.sourceRoot ?? target.projectRoot);
+    if (targetProjectRoot !== projectRoot || targetSourceRoot !== sourceRoot) {
+      return buildFailure(
+        jvmRunnerErrorCodes.invalidTarget,
+        "All JVM module targets must share one Gradle project and source root.",
+        {
+          expectedProjectRoot: projectRoot,
+          actualProjectRoot: targetProjectRoot,
+          expectedSourceRoot: sourceRoot,
+          actualSourceRoot: targetSourceRoot,
+          applicationModulePath: target.applicationModulePath,
+        },
+      );
+    }
+  }
+  if (!seen.has(targetKey(options.target))) {
+    return buildFailure(
+      jvmRunnerErrorCodes.invalidTarget,
+      "The primary JVM target is absent from moduleTargets.",
+      {
+        applicationModulePath: options.target.applicationModulePath,
+        variantName: options.target.variantName,
+      },
+    );
+  }
+  return targets;
+}
+function moduleOutputDirectory(outputDirectory, target) {
+  const token = Buffer.from(targetKey(target), "utf8").toString("base64url");
+  return resolve(outputDirectory, "raw-jvm-modules", token);
+}
+function recordSignature(record) {
+  return JSON.stringify(record);
+}
+function mergedJvmDocument(runs, primary) {
+  const engineVersions = new Set(
+    runs.map((run) => run.document.header.data.engineVersion),
+  );
+  if (engineVersions.size !== 1) {
+    return buildFailure(
+      jvmRunnerErrorCodes.mergeIncompatible,
+      "JVM module outputs use different analyzer engine versions.",
+      { engineVersions: [...engineVersions].sort() },
+    );
+  }
+  const body = [];
+  const byId = new Map();
+  for (const run of runs) {
+    for (const record of run.document.body) {
+      const signature = recordSignature(record);
+      const existing = byId.get(record.id);
+      if (existing === undefined) {
+        byId.set(record.id, signature);
+        body.push(record);
+        continue;
+      }
+      if (existing !== signature) {
+        return buildFailure(
+          jvmRunnerErrorCodes.mergeIdConflict,
+          `JVM module outputs disagree for record ID ${record.id}.`,
+          {
+            id: record.id,
+            applicationModulePath: run.target.applicationModulePath,
+            variantName: run.target.variantName,
+          },
+        );
+      }
+    }
+  }
+  const countsByKind = {};
+  for (const record of body) {
+    countsByKind[record.kind] = (countsByKind[record.kind] ?? 0) + 1;
+  }
+  const orderedCounts = Object.fromEntries(
+    Object.entries(countsByKind).sort(([left], [right]) =>
+      left.localeCompare(right, "en"),
+    ),
+  );
+  const header = {
+    ...primary.document.header,
+    id: "header:android-lint-uast:merged",
+    data: {
+      ...primary.document.header.data,
+      project: primary.document.header.data.project,
+    },
+  };
+  const footer = {
+    ...primary.document.footer,
+    id: "footer:android-lint-uast:merged",
+    data: {
+      ...primary.document.footer.data,
+      complete: true,
+      recordCount: body.length,
+      countsByKind: orderedCounts,
+    },
+  };
+  const controlIds = new Set([header.id, footer.id]);
+  const controlCollision = body.find((record) => controlIds.has(record.id));
+  if (controlCollision) {
+    return buildFailure(
+      jvmRunnerErrorCodes.mergeIdConflict,
+      `JVM body record collides with merged control ID ${controlCollision.id}.`,
+      { id: controlCollision.id },
+    );
+  }
+  const records = [header, ...body, footer];
+  const ndjson =
+    records.map((record) => JSON.stringify(record)).join("\n") + "\n";
+  return {
+    document: parseJvmNdjson(ndjson),
+    ndjson,
+  };
+}
+export async function runJvmAnalysis(options) {
+  const targets = orderedModuleTargets(options);
+  if (targets.length === 1) {
+    return runSingleJvmAnalysis({
+      ...options,
+      target: targets[0],
+      moduleTargets: undefined,
+    });
+  }
+  const outputDirectory = resolve(options.outputDirectory);
+  const moduleRoot = resolve(outputDirectory, "raw-jvm-modules");
+  const outputPath = resolve(outputDirectory, RAW_JVM_FILE_NAME);
+  try {
+    mkdirSync(outputDirectory, { recursive: true });
+    rmSync(moduleRoot, { recursive: true, force: true });
+    rmSync(outputPath, { force: true });
+  } catch (error) {
+    return buildFailure(
+      jvmRunnerErrorCodes.outputPrepareFailed,
+      `Unable to prepare multi-module JVM output: ${outputDirectory}`,
+      {
+        cause: error instanceof Error ? error.message : String(error),
+      },
+    );
+  }
+  const moduleRuns = [];
+  for (const target of targets) {
+    const run = await runSingleJvmAnalysis({
+      ...options,
+      target,
+      moduleTargets: undefined,
+      outputDirectory: moduleOutputDirectory(outputDirectory, target),
+    });
+    moduleRuns.push({ ...run, target });
+  }
+  const primary = moduleRuns.find(
+    (run) => targetKey(run.target) === targetKey(options.target),
+  );
+  const merged = mergedJvmDocument(moduleRuns, primary);
+  try {
+    writeFileSync(outputPath, merged.ndjson, "utf8");
+  } catch (error) {
+    return buildFailure(
+      jvmRunnerErrorCodes.mergeWriteFailed,
+      `Unable to write merged raw JVM output: ${outputPath}`,
+      {
+        cause: error instanceof Error ? error.message : String(error),
+      },
+    );
+  }
+  return {
+    outputPath,
+    lintTask: primary.lintTask,
+    document: merged.document,
+    gradleResult: primary.gradleResult,
+    moduleRuns,
+  };
+}

package/skills/a2h-app-req-gen/scripts/reqgen/src/pipeline/index.js

@@ -0,0 +1,8 @@
+export { DEFAULT_ANALYSIS_LIMITS, runStage1 } from "./run-stage1.js";
+export {
+  publishStagedArtifacts,
+  serializeArtifact,
+  sha256Text,
+  writeJsonArtifact,
+  writeTextArtifact,
+} from "./output.js";

package/skills/a2h-app-req-gen/scripts/reqgen/src/pipeline/output.js

@@ -0,0 +1,165 @@
+import { createHash } from "node:crypto";
+import { lstat, mkdir, mkdtemp, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+function posixRelative(root, path) {
+  return relative(root, path).split(sep).join("/");
+}
+function assertChildPath(outputDirectory, filename) {
+  if (
+    filename.length === 0 ||
+    filename === "." ||
+    filename === ".." ||
+    filename.includes("/") ||
+    filename.includes("\\") ||
+    basename(filename) !== filename
+  ) {
+    throw new Error(`Artifact filename must be a basename: ${filename}`);
+  }
+  const root = resolve(outputDirectory);
+  const target = resolve(root, filename);
+  if (dirname(target) !== root) {
+    throw new Error(`Artifact escapes output directory: ${filename}`);
+  }
+  return target;
+}
+export function serializeArtifact(value) {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+export function sha256Text(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+/**
+ * Write one complete artifact atomically. A failed process leaves at most a
+ * hidden temporary file; it never exposes a truncated final JSON document.
+ */
+export async function writeJsonArtifact(
+  outputDirectory,
+  filename,
+  kind,
+  value,
+) {
+  const root = resolve(outputDirectory);
+  const target = assertChildPath(root, filename);
+  await mkdir(root, { recursive: true });
+  const text = serializeArtifact(value);
+  const temporary = join(root, `.${filename}.${process.pid}.${Date.now()}.tmp`);
+  try {
+    await writeFile(temporary, text, {
+      encoding: "utf8",
+      flag: "wx",
+    });
+    await rename(temporary, target);
+  } catch (error) {
+    await rm(temporary, { force: true });
+    throw error;
+  }
+  return {
+    kind,
+    relativePath: posixRelative(root, target),
+    sha256: sha256Text(text),
+  };
+}
+export async function writeTextArtifact(outputDirectory, filename, kind, text) {
+  const root = resolve(outputDirectory);
+  const target = assertChildPath(root, filename);
+  await mkdir(root, { recursive: true });
+  const normalized = text.endsWith("\n") ? text : `${text}\n`;
+  const temporary = join(root, `.${filename}.${process.pid}.${Date.now()}.tmp`);
+  try {
+    await writeFile(temporary, normalized, {
+      encoding: "utf8",
+      flag: "wx",
+    });
+    await rename(temporary, target);
+  } catch (error) {
+    await rm(temporary, { force: true });
+    throw error;
+  }
+  return {
+    kind,
+    relativePath: posixRelative(root, target),
+    sha256: sha256Text(normalized),
+  };
+}
+async function pathExists(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+/**
+ * Publish a validated set of top-level artifact files as one transaction.
+ *
+ * Artifacts are fully written in `stagingDirectory` before this function is
+ * called. Existing artifacts are moved aside and restored if any rename
+ * fails, so a caught publication error does not expose a mixture of runs.
+ * The report file should be the last filename: it is the commit marker readers
+ * use to decide whether the run is publishable.
+ */
+export async function publishStagedArtifacts(
+  stagingDirectory,
+  outputDirectory,
+  filenames,
+  removeFilenames = [],
+) {
+  const staging = resolve(stagingDirectory);
+  const output = resolve(outputDirectory);
+  if (staging === output) {
+    throw new Error("Artifact staging and output directories must differ");
+  }
+  const allFilenames = [...filenames, ...removeFilenames];
+  const unique = new Set(allFilenames);
+  if (unique.size !== allFilenames.length) {
+    throw new Error("Artifact publication filenames must be unique");
+  }
+  allFilenames.forEach((filename) => assertChildPath(output, filename));
+  await mkdir(output, { recursive: true });
+  for (const filename of filenames) {
+    const source = assertChildPath(staging, filename);
+    if (!(await pathExists(source))) {
+      throw new Error(`Staged artifact is missing: ${filename}`);
+    }
+  }
+  const backup = await mkdtemp(join(output, ".reqgen-backup-"));
+  const backedUp = [];
+  const published = [];
+  try {
+    // A tombstone is part of the same rollback boundary. This is used by a
+    // failed run to remove successful three-layer artifacts from an earlier
+    // run in the same output directory.
+    for (const filename of removeFilenames) {
+      const target = assertChildPath(output, filename);
+      if (await pathExists(target)) {
+        await rename(target, assertChildPath(backup, filename));
+        backedUp.push(filename);
+      }
+    }
+    for (const filename of filenames) {
+      const target = assertChildPath(output, filename);
+      if (await pathExists(target)) {
+        await rename(target, assertChildPath(backup, filename));
+        backedUp.push(filename);
+      }
+      await rename(assertChildPath(staging, filename), target);
+      published.push(filename);
+    }
+  } catch (error) {
+    for (const filename of [...published].reverse()) {
+      await rm(assertChildPath(output, filename), { force: true });
+    }
+    for (const filename of [...backedUp].reverse()) {
+      const saved = assertChildPath(backup, filename);
+      if (await pathExists(saved)) {
+        await rename(saved, assertChildPath(output, filename));
+      }
+    }
+    throw error;
+  } finally {
+    await rm(backup, { recursive: true, force: true });
+  }
+}