android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/project/discovery.js

@@ -0,0 +1,299 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { hardFailure } from "../diagnostics.js";
+const SETTINGS_NAMES = ["settings.gradle.kts", "settings.gradle"];
+const BUILD_NAMES = ["build.gradle.kts", "build.gradle"];
+function firstExisting(root, names) {
+  return names
+    .map((name) => join(root, name))
+    .find((path) => existsSync(path) && statSync(path).isFile());
+}
+function moduleDirectory(projectRoot, gradlePath) {
+  if (gradlePath === ":") {
+    return projectRoot;
+  }
+  return join(projectRoot, ...gradlePath.slice(1).split(":"));
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort();
+}
+export function parseIncludedModules(settingsText) {
+  const modules = [];
+  const callPattern = /\binclude\s*\(([\s\S]*?)\)/gu;
+  for (const match of settingsText.matchAll(callPattern)) {
+    for (const value of match[1].matchAll(/["'](:[^"']+)["']/gu)) {
+      modules.push(value[1]);
+    }
+  }
+  const groovyPattern = /^\s*include\s+(.+)$/gmu;
+  for (const match of settingsText.matchAll(groovyPattern)) {
+    for (const value of match[1].matchAll(/["'](:[^"']+)["']/gu)) {
+      modules.push(value[1]);
+    }
+  }
+  return uniqueSorted(modules);
+}
+function block(text, name) {
+  const start = new RegExp(`\\b${name}\\s*\\{`, "u").exec(text);
+  if (!start) {
+    return undefined;
+  }
+  const open = text.indexOf("{", start.index);
+  let depth = 0;
+  let quote;
+  for (let index = open; index < text.length; index += 1) {
+    const character = text[index];
+    const previous = text[index - 1];
+    if (quote) {
+      if (character === quote && previous !== "\\") {
+        quote = undefined;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === "{") {
+      depth += 1;
+    } else if (character === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return text.slice(open + 1, index);
+      }
+    }
+  }
+  return undefined;
+}
+function assignedString(text, name) {
+  const patterns = [
+    new RegExp(`\\b${name}\\s*=\\s*["']([^"']+)["']`, "u"),
+    new RegExp(`\\b${name}\\s+["']([^"']+)["']`, "u"),
+  ];
+  for (const pattern of patterns) {
+    const value = pattern.exec(text)?.[1];
+    if (value) {
+      return value;
+    }
+  }
+  return undefined;
+}
+function parseNamedContainers(text) {
+  const names = [
+    ...text.matchAll(
+      /\b(?:create|maybeCreate|named|register)\s*\(\s*["']([^"']+)["']\s*\)/gu,
+    ),
+  ].map((match) => match[1]);
+  return uniqueSorted(names);
+}
+function upperCamel(value) {
+  return value.length === 0
+    ? value
+    : `${value[0].toUpperCase()}${value.slice(1)}`;
+}
+function buildVariants(buildTypes, productFlavors) {
+  if (productFlavors.length === 0) {
+    return buildTypes.map((buildType) => ({
+      name: buildType,
+      buildType,
+      productFlavors: [],
+    }));
+  }
+  // The frozen baseline uses at most one flavor dimension. A Gradle-derived
+  // model replaces this fallback before wider toolchain support is claimed.
+  return productFlavors.flatMap((flavor) =>
+    buildTypes.map((buildType) => ({
+      name: `${flavor.name}${upperCamel(buildType)}`,
+      buildType,
+      productFlavors: [flavor],
+    })),
+  );
+}
+function parseModule(projectRoot, gradlePath) {
+  const directory = moduleDirectory(projectRoot, gradlePath);
+  const buildFile = firstExisting(directory, BUILD_NAMES);
+  if (!buildFile) {
+    return undefined;
+  }
+  const text = readFileSync(buildFile, "utf8");
+  const hasAppliedPlugin = (pluginId) =>
+    text
+      .split(/\r?\n/u)
+      .some(
+        (line) =>
+          line.includes(pluginId) &&
+          !/\bapply\s+false\b/u.test(line) &&
+          (/\bid\s*\(/u.test(line) ||
+            /\bapply\s+plugin\s*:/u.test(line) ||
+            /\bplugins\.apply\s*\(/u.test(line)),
+      );
+  const kind = hasAppliedPlugin("com.android.application")
+    ? "application"
+    : hasAppliedPlugin("com.android.library")
+      ? "library"
+      : undefined;
+  if (!kind) {
+    return undefined;
+  }
+  const android = block(text, "android") ?? text;
+  const buildTypesBlock = block(android, "buildTypes") ?? "";
+  const parsedBuildTypes = parseNamedContainers(buildTypesBlock);
+  const buildTypes =
+    parsedBuildTypes.length > 0 ? parsedBuildTypes : ["debug", "release"];
+  const flavorsBlock = block(android, "productFlavors") ?? "";
+  const dimension = assignedString(android, "flavorDimensions");
+  const productFlavors = parseNamedContainers(flavorsBlock).map((name) => ({
+    name,
+    ...(dimension ? { dimension } : {}),
+  }));
+  const localProjectDependencies = uniqueSorted(
+    [...text.matchAll(/\bproject\s*\(\s*["'](:[^"']+)["']\s*\)/gu)].map(
+      (match) => match[1],
+    ),
+  );
+  return {
+    gradlePath,
+    directory,
+    buildFile,
+    kind,
+    namespace: assignedString(android, "namespace"),
+    applicationId: assignedString(
+      block(android, "defaultConfig") ?? android,
+      "applicationId",
+    ),
+    buildTypes,
+    productFlavors,
+    variants: buildVariants(buildTypes, productFlavors),
+    localProjectDependencies,
+  };
+}
+function ensureInside(root, candidate) {
+  const child = relative(root, candidate);
+  if (
+    child === ".." ||
+    child.startsWith(`..${sep}`) ||
+    child.startsWith("/") ||
+    /^[A-Za-z]:/u.test(child)
+  ) {
+    throw hardFailure(
+      "PROJECT_ROOT_ESCAPE",
+      "input",
+      `Resolved project path escapes the selected root: ${candidate}`,
+    );
+  }
+}
+export function discoverAndroidProject(projectRoot) {
+  const absoluteRoot = realpathSync(resolve(projectRoot));
+  const settingsFile = firstExisting(absoluteRoot, SETTINGS_NAMES);
+  if (!settingsFile) {
+    throw hardFailure(
+      "GRADLE_SETTINGS_MISSING",
+      "gradle",
+      `No settings.gradle(.kts) exists at ${absoluteRoot}`,
+      "Pass the Android Gradle root rather than an individual source folder.",
+    );
+  }
+  const included = parseIncludedModules(readFileSync(settingsFile, "utf8"));
+  const rootBuild = firstExisting(absoluteRoot, BUILD_NAMES);
+  const candidates = [...(rootBuild ? [":"] : []), ...included];
+  const modules = candidates
+    .map((path) => {
+      const directory = moduleDirectory(absoluteRoot, path);
+      ensureInside(absoluteRoot, resolve(directory));
+      return parseModule(absoluteRoot, path);
+    })
+    .filter((module) => module !== undefined)
+    .sort((left, right) =>
+      left.gradlePath.localeCompare(right.gradlePath, "en"),
+    );
+  if (modules.every((module) => module.kind !== "application")) {
+    throw hardFailure(
+      "APPLICATION_MODULE_MISSING",
+      "gradle",
+      "No Android application module was discovered.",
+    );
+  }
+  return {
+    projectRoot: absoluteRoot,
+    settingsFile,
+    modules,
+  };
+}
+function reachableModules(inventory, root) {
+  const byPath = new Map(
+    inventory.modules.map((module) => [module.gradlePath, module]),
+  );
+  const visited = new Set();
+  const queue = [root.gradlePath];
+  while (queue.length > 0) {
+    const path = queue.shift();
+    if (!path || visited.has(path)) {
+      continue;
+    }
+    visited.add(path);
+    const module = byPath.get(path);
+    module?.localProjectDependencies.forEach((dependency) =>
+      queue.push(dependency),
+    );
+  }
+  return [...visited]
+    .map((path) => byPath.get(path))
+    .filter((module) => module !== undefined)
+    .sort((left, right) =>
+      left.gradlePath.localeCompare(right.gradlePath, "en"),
+    );
+}
+export function selectProjectModel(inventory, options) {
+  const applications = inventory.modules.filter(
+    (module) => module.kind === "application",
+  );
+  const applicationModule = options.applicationModule
+    ? applications.find(
+        (module) => module.gradlePath === options.applicationModule,
+      )
+    : applications.length === 1
+      ? applications[0]
+      : undefined;
+  if (!applicationModule) {
+    throw hardFailure(
+      options.applicationModule
+        ? "APPLICATION_MODULE_UNKNOWN"
+        : "APPLICATION_MODULE_AMBIGUOUS",
+      "variant",
+      options.applicationModule
+        ? `Application module ${options.applicationModule} was not found.`
+        : `More than one application module exists: ${applications.map((module) => module.gradlePath).join(", ")}`,
+      "Select exactly one application module.",
+    );
+  }
+  const buildVariant = options.buildVariant
+    ? applicationModule.variants.find(
+        (variant) => variant.name === options.buildVariant,
+      )
+    : applicationModule.variants.length === 1
+      ? applicationModule.variants[0]
+      : undefined;
+  if (!buildVariant) {
+    throw hardFailure(
+      options.buildVariant
+        ? "BUILD_VARIANT_UNKNOWN"
+        : "BUILD_VARIANT_AMBIGUOUS",
+      "variant",
+      options.buildVariant
+        ? `Variant ${options.buildVariant} does not exist in ${applicationModule.gradlePath}.`
+        : `More than one variant exists in ${applicationModule.gradlePath}: ${applicationModule.variants.map((variant) => variant.name).join(", ")}`,
+      "Select exactly one build variant.",
+    );
+  }
+  return {
+    projectRoot: inventory.projectRoot,
+    applicationModule,
+    buildVariant,
+    reachableModules: reachableModules(inventory, applicationModule),
+    resourceConfiguration: options.resourceConfiguration,
+  };
+}
+export function projectRelativePath(projectRoot, path) {
+  return relative(projectRoot, resolve(path)).split(sep).join("/");
+}
+export function projectDirectoryFromSettings(settingsFile) {
+  return dirname(settingsFile);
+}

package/skills/a2h-app-req-gen/scripts/reqgen/src/project/gradle-model.js

@@ -0,0 +1,358 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { hardFailure } from "../diagnostics.js";
+import { runGradle, writeGradleProjectModel } from "./gradle-runner.js";
+/**
+ * Convert every model filesystem field through an explicitly supplied mapper.
+ * Native execution uses the paths produced by Gradle unchanged; non-native
+ * executors must normalize their model before returning it or inject a mapper.
+ */
+export function normalizeGradleProjectModelPaths(
+  model,
+  mapPath = (path) => path,
+) {
+  return {
+    ...model,
+    projectRoot: mapPath(model.projectRoot),
+    modules: model.modules.map((module) => ({
+      ...module,
+      directory: mapPath(module.directory),
+      buildFile: mapPath(module.buildFile),
+      sourceSets: module.sourceSets.map((sourceSet) => ({
+        ...sourceSet,
+        java: sourceSet.java.map(mapPath),
+        res: sourceSet.res.map(mapPath),
+        manifest: mapPath(sourceSet.manifest),
+      })),
+    })),
+  };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string")
+    ? value
+    : undefined;
+}
+function parseSourceSet(value, path) {
+  if (!isRecord(value)) {
+    throw new Error(`${path} must be an object`);
+  }
+  const java = stringArray(value.java);
+  const res = stringArray(value.res);
+  if (
+    typeof value.name !== "string" ||
+    !java ||
+    !res ||
+    typeof value.manifest !== "string"
+  ) {
+    throw new Error(`${path} has an invalid source-set shape`);
+  }
+  return {
+    name: value.name,
+    java,
+    res,
+    manifest: value.manifest,
+  };
+}
+function parseVariant(value, path) {
+  if (
+    !isRecord(value) ||
+    typeof value.name !== "string" ||
+    typeof value.buildType !== "string" ||
+    !Array.isArray(value.productFlavors)
+  ) {
+    throw new Error(`${path} has an invalid variant shape`);
+  }
+  const productFlavors = value.productFlavors.map((flavor, index) => {
+    if (!isRecord(flavor) || typeof flavor.name !== "string") {
+      throw new Error(`${path}.productFlavors[${index}] is invalid`);
+    }
+    return {
+      name: flavor.name,
+      ...(typeof flavor.dimension === "string"
+        ? { dimension: flavor.dimension }
+        : {}),
+    };
+  });
+  return {
+    name: value.name,
+    buildType: value.buildType,
+    productFlavors,
+    ...(typeof value.applicationId === "string"
+      ? { applicationId: value.applicationId }
+      : {}),
+  };
+}
+function parseModule(value, path) {
+  if (
+    !isRecord(value) ||
+    typeof value.gradlePath !== "string" ||
+    typeof value.directory !== "string" ||
+    typeof value.buildFile !== "string" ||
+    (value.kind !== "application" &&
+      value.kind !== "library" &&
+      value.kind !== "non-android-library") ||
+    !Array.isArray(value.variants) ||
+    !Array.isArray(value.sourceSets)
+  ) {
+    throw new Error(`${path} has an invalid Android module shape`);
+  }
+  const dependencies = stringArray(value.localProjectDependencies) ?? [];
+  return {
+    gradlePath: value.gradlePath,
+    directory: value.directory,
+    buildFile: value.buildFile,
+    kind: value.kind,
+    ...(typeof value.namespace === "string"
+      ? { namespace: value.namespace }
+      : {}),
+    variants: value.variants.map((variant, index) =>
+      parseVariant(variant, `${path}.variants[${index}]`),
+    ),
+    sourceSets: value.sourceSets.map((sourceSet, index) =>
+      parseSourceSet(sourceSet, `${path}.sourceSets[${index}]`),
+    ),
+    localProjectDependencies: dependencies,
+  };
+}
+export function parseGradleProjectModel(value) {
+  if (
+    !isRecord(value) ||
+    value.schemaVersion !== "1.0.0" ||
+    typeof value.projectRoot !== "string" ||
+    !Array.isArray(value.modules)
+  ) {
+    throw new Error("Gradle project model has an unsupported envelope");
+  }
+  return {
+    schemaVersion: "1.0.0",
+    projectRoot: value.projectRoot,
+    modules: value.modules.map((module, index) =>
+      parseModule(module, `modules[${index}]`),
+    ),
+  };
+}
+export async function loadGradleProjectModel(projectRoot, options) {
+  await writeGradleProjectModel(
+    projectRoot,
+    options.initScript,
+    options.outputPath,
+    options.runner,
+  );
+  try {
+    return normalizeGradleProjectModelPaths(
+      parseGradleProjectModel(
+        JSON.parse(readFileSync(options.outputPath, "utf8")),
+      ),
+    );
+  } catch (error) {
+    throw hardFailure(
+      "GRADLE_MODEL_INVALID",
+      "gradle",
+      `Gradle produced an invalid project model: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+/**
+ * Android names a source set that combines multiple flavor dimensions in
+ * lower camel case (for example, `free` + `demo` becomes `freeDemo`).
+ */
+export function combinedProductFlavorSourceSetName(variant) {
+  const flavors = variant.productFlavors.map((flavor) => flavor.name);
+  if (flavors.length < 2) return undefined;
+  return flavors
+    .map((flavor, index) =>
+      index === 0
+        ? flavor
+        : `${flavor[0]?.toUpperCase() ?? ""}${flavor.slice(1)}`,
+    )
+    .join("");
+}
+function activeNames(variant) {
+  const flavors = variant.productFlavors.map((flavor) => flavor.name);
+  const combinedFlavor = combinedProductFlavorSourceSetName(variant);
+  return [
+    "main",
+    ...flavors,
+    ...(combinedFlavor ? [combinedFlavor] : []),
+    variant.buildType,
+    variant.name,
+  ];
+}
+export function selectCompatibleModuleVariant(module, selected) {
+  const variant =
+    module.variants.find((candidate) => candidate.name === selected.name) ??
+    module.variants.find(
+      (candidate) =>
+        candidate.buildType === selected.buildType &&
+        candidate.productFlavors.length === 0,
+    );
+  if (!variant) {
+    throw hardFailure(
+      "DEPENDENCY_VARIANT_MISSING",
+      "variant",
+      `No compatible ${selected.name} source variant exists in ${module.gradlePath}.`,
+    );
+  }
+  return variant;
+}
+function selectModuleSourceSets(module, selected) {
+  // A non-android-library module has no variant concept and no res/manifest
+  // to merge — it contributes no source sets to resource/manifest merging.
+  if (module.kind === "non-android-library") return [];
+  const variant = selectCompatibleModuleVariant(module, selected);
+  const names = new Set(activeNames(variant));
+  return module.sourceSets.filter((sourceSet) => names.has(sourceSet.name));
+}
+function moduleClosure(model, root) {
+  const byPath = new Map(
+    model.modules.map((module) => [module.gradlePath, module]),
+  );
+  const visited = new Set();
+  const queue = [root.gradlePath];
+  while (queue.length > 0) {
+    const path = queue.shift();
+    if (!path || visited.has(path)) {
+      continue;
+    }
+    const module = byPath.get(path);
+    if (!module) {
+      throw hardFailure(
+        "LOCAL_MODULE_MISSING",
+        "gradle",
+        `Local dependency ${path} is absent from the Gradle model.`,
+      );
+    }
+    visited.add(path);
+    module.localProjectDependencies.forEach((dependency) =>
+      queue.push(dependency),
+    );
+  }
+  return [...visited]
+    .map((path) => byPath.get(path))
+    .filter((module) => module !== undefined)
+    .sort((left, right) =>
+      left.gradlePath.localeCompare(right.gradlePath, "en"),
+    );
+}
+export function selectGradleVariant(model, applicationModulePath, variantName) {
+  const applications = model.modules.filter(
+    (module) => module.kind === "application",
+  );
+  const applicationModule = applicationModulePath
+    ? applications.find((module) => module.gradlePath === applicationModulePath)
+    : applications.length === 1
+      ? applications[0]
+      : undefined;
+  if (!applicationModule) {
+    throw hardFailure(
+      applicationModulePath
+        ? "APPLICATION_MODULE_UNKNOWN"
+        : "APPLICATION_MODULE_AMBIGUOUS",
+      "variant",
+      applicationModulePath
+        ? `Unknown application module: ${applicationModulePath}`
+        : `Select one application module: ${applications.map((module) => module.gradlePath).join(", ")}`,
+    );
+  }
+  const variant = variantName
+    ? applicationModule.variants.find(
+        (candidate) => candidate.name === variantName,
+      )
+    : applicationModule.variants.length === 1
+      ? applicationModule.variants[0]
+      : undefined;
+  if (!variant) {
+    throw hardFailure(
+      variantName ? "BUILD_VARIANT_UNKNOWN" : "BUILD_VARIANT_AMBIGUOUS",
+      "variant",
+      variantName
+        ? `Unknown variant ${variantName} in ${applicationModule.gradlePath}.`
+        : `Select one variant in ${applicationModule.gradlePath}: ${applicationModule.variants.map((item) => item.name).join(", ")}`,
+    );
+  }
+  const reachableModules = moduleClosure(model, applicationModule);
+  const activeSourceSets = new Map(
+    reachableModules.map((module) => [
+      module.gradlePath,
+      selectModuleSourceSets(module, variant),
+    ]),
+  );
+  return {
+    model,
+    applicationModule,
+    variant,
+    reachableModules,
+    activeSourceSets,
+  };
+}
+function upperCamel(value) {
+  return value.length === 0
+    ? value
+    : `${value[0].toUpperCase()}${value.slice(1)}`;
+}
+function walkFiles(root) {
+  if (!existsSync(root) || !statSync(root).isDirectory()) {
+    return [];
+  }
+  const results = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const path = join(root, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkFiles(path));
+    } else if (entry.isFile()) {
+      results.push(path);
+    }
+  }
+  return results;
+}
+export async function prepareMergedManifest(selected, runner) {
+  const moduleTask =
+    selected.applicationModule.gradlePath === ":"
+      ? ""
+      : selected.applicationModule.gradlePath;
+  const variant = upperCamel(selected.variant.name);
+  const task = `${moduleTask}:process${variant}MainManifest`;
+  const result = await runGradle(
+    selected.model.projectRoot,
+    ["--no-daemon", "--console=plain", task],
+    runner,
+  );
+  if (result.exitCode !== 0) {
+    throw hardFailure(
+      "MERGED_MANIFEST_FAILED",
+      "manifest",
+      `Gradle task ${task} failed.`,
+      undefined,
+      {
+        stdoutTail: result.stdout.slice(-4_000),
+        stderrTail: result.stderr.slice(-4_000),
+      },
+    );
+  }
+  const candidates = walkFiles(
+    join(
+      selected.applicationModule.directory,
+      "build",
+      "intermediates",
+      "merged_manifest",
+      selected.variant.name,
+    ),
+  ).filter((path) => /AndroidManifest\.xml$/u.test(path));
+  if (candidates.length !== 1) {
+    throw hardFailure(
+      "MERGED_MANIFEST_AMBIGUOUS",
+      "manifest",
+      `Expected one merged main Manifest for ${selected.applicationModule.gradlePath}/${selected.variant.name}, found ${candidates.length}.`,
+      undefined,
+      {
+        candidates: candidates.map((path) =>
+          relative(selected.model.projectRoot, path).split(sep).join("/"),
+        ),
+      },
+    );
+  }
+  return resolve(candidates[0]);
+}