android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/android/manifest.js

@@ -0,0 +1,513 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join, relative, sep } from "node:path";
+import { hardFailure } from "../diagnostics.js";
+import { descendantElements, localName, parseXml } from "./xml-parser.js";
+function attribute(element, name) {
+  return element.attributes[`android:${name}`] ?? element.attributes[name];
+}
+function relativePath(root, path) {
+  return relative(root, path).split(sep).join("/");
+}
+function evidence(selected, path, element, anchor) {
+  return {
+    sourceKind: "manifest",
+    path: relativePath(selected.model.projectRoot, path),
+    anchor,
+    range: {
+      startLine: element.startLine,
+      endLine: element.endLine,
+    },
+  };
+}
+function resolveClassName(name, packageName) {
+  if (!packageName) return name;
+  if (name.startsWith(".")) return `${packageName}${name}`;
+  if (!name.includes(".")) return `${packageName}.${name}`;
+  return name;
+}
+function comparablePath(path) {
+  const slashes = path.trim().replaceAll("\\", "/");
+  const wslDrive = /^\/mnt\/([A-Za-z])\/(.*)$/u.exec(slashes);
+  return (wslDrive ? `${wslDrive[1]}:/${wslDrive[2]}` : slashes)
+    .replace(/\/{2,}/gu, "/")
+    .toLowerCase();
+}
+function walkFiles(root) {
+  if (!existsSync(root) || !statSync(root).isDirectory()) return [];
+  return readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(root, entry.name);
+    return entry.isDirectory() ? walkFiles(path) : entry.isFile() ? [path] : [];
+  });
+}
+/** Locate the AGP sidecar whose numbered lines correspond to the merge. */
+function manifestMergerBlamePath(selected, manifestPath) {
+  const root = join(
+    selected.applicationModule.directory,
+    "build",
+    "intermediates",
+    "manifest_merge_blame_file",
+    selected.variant.name,
+  );
+  const candidates = walkFiles(root)
+    .filter((path) => /manifest-merger-blame-.*-report\.txt$/u.test(path))
+    .sort();
+  if (candidates.length === 0) return undefined;
+  const taskDirectory = basename(dirname(manifestPath));
+  return (
+    candidates.find((path) => path.split(/[\\/]/u).includes(taskDirectory)) ??
+    (candidates.length === 1 ? candidates[0] : undefined)
+  );
+}
+function readBlameOrigins(path) {
+  if (!path || !existsSync(path)) return new Map();
+  const origins = new Map();
+  for (const line of readFileSync(path, "utf8").split(/\r?\n/u)) {
+    /*
+     * Columns are mandatory in AGP blame coordinates. Requiring the final
+     * `:line:column` pair makes the greedy path safe for both `C:\\...` and
+     * `[group:artifact:version] C:\\...` origins.
+     */
+    const match = /^(\d+)-->(.+):(\d+):(\d+)(?:-(?:(\d+):)?(\d+))?\s*$/u.exec(
+      line,
+    );
+    if (!match) continue;
+    const mergedLine = Number(match[1]);
+    const values = origins.get(mergedLine) ?? [];
+    values.push({ path: match[2].trim(), sourceLine: Number(match[3]) });
+    origins.set(mergedLine, values);
+  }
+  return origins;
+}
+function localManifestSources(selected) {
+  const sources = [];
+  for (const module of selected.reachableModules) {
+    for (const sourceSet of selected.activeSourceSets.get(module.gradlePath) ??
+      []) {
+      if (!existsSync(sourceSet.manifest)) continue;
+      sources.push({
+        ownership:
+          module.gradlePath === selected.applicationModule.gradlePath
+            ? "app"
+            : "local-module",
+        modulePath: module.gradlePath,
+        manifestPath: relativePath(
+          selected.model.projectRoot,
+          sourceSet.manifest,
+        ),
+        absolutePath: sourceSet.manifest,
+      });
+    }
+  }
+  return sources.sort((left, right) =>
+    `${left.ownership}:${left.modulePath}:${left.manifestPath}`.localeCompare(
+      `${right.ownership}:${right.modulePath}:${right.manifestPath}`,
+      "en",
+    ),
+  );
+}
+function sourceForBlameOrigin(origin, sources) {
+  const reported = comparablePath(origin.path);
+  const match = sources.find((source) => {
+    const absolute = comparablePath(source.absolutePath);
+    const projectRelative = comparablePath(source.manifestPath);
+    return (
+      reported === absolute ||
+      reported.endsWith(`/${projectRelative}`) ||
+      absolute.endsWith(`/${reported}`)
+    );
+  });
+  return match
+    ? {
+        ownership: match.ownership,
+        modulePath: match.modulePath,
+        manifestPath: match.manifestPath,
+        sourceLine: origin.sourceLine,
+      }
+    : undefined;
+}
+function sourceComponentNames(selected, module, manifestPath) {
+  try {
+    const root = parseXml(readFileSync(manifestPath, "utf8"));
+    const packageName =
+      root.attributes.package ??
+      module.namespace ??
+      (module.gradlePath === selected.applicationModule.gradlePath
+        ? selected.variant.applicationId
+        : undefined);
+    const application = root.children.find(
+      (child) => localName(child.name) === "application",
+    );
+    if (!application) return [];
+    return descendantElements(application).flatMap((element) => {
+      const kind = localName(element.name);
+      if (
+        kind !== "activity" &&
+        kind !== "activity-alias" &&
+        kind !== "fragment" &&
+        kind !== "receiver"
+      )
+        return [];
+      const rawName = attribute(element, "name")?.replaceAll(
+        "${applicationId}",
+        selected.variant.applicationId ?? packageName ?? "",
+      );
+      return rawName
+        ? [
+            {
+              name: resolveClassName(rawName, packageName),
+              sourceLine: element.startLine,
+            },
+          ]
+        : [];
+    });
+  } catch {
+    // The merged Manifest remains the authoritative parse. A missing fallback
+    // declaration must never fabricate local ownership.
+    return [];
+  }
+}
+function declarationsByComponent(selected, sources) {
+  const moduleByPath = new Map(
+    selected.reachableModules.map((module) => [module.gradlePath, module]),
+  );
+  const result = new Map();
+  for (const source of sources) {
+    const module = moduleByPath.get(source.modulePath);
+    if (!module) continue;
+    for (const component of sourceComponentNames(
+      selected,
+      module,
+      source.absolutePath,
+    )) {
+      const values = result.get(component.name) ?? [];
+      values.push({
+        ownership: source.ownership,
+        modulePath: source.modulePath,
+        manifestPath: source.manifestPath,
+        sourceLine: component.sourceLine,
+      });
+      result.set(component.name, values);
+    }
+  }
+  return result;
+}
+function uniqueSources(sources) {
+  return [
+    ...new Map(
+      sources.map((source) => [
+        `${source.ownership}:${source.modulePath}:${source.manifestPath}:` +
+          `${source.sourceLine ?? ""}`,
+        source,
+      ]),
+    ).values(),
+  ].sort((left, right) => {
+    const leftKey =
+      `${left.ownership}:${left.modulePath}:` +
+      `${left.manifestPath}:${left.sourceLine ?? ""}`;
+    const rightKey =
+      `${right.ownership}:${right.modulePath}:` +
+      `${right.manifestPath}:${right.sourceLine ?? ""}`;
+    return leftKey.localeCompare(rightKey, "en");
+  });
+}
+function componentProvenance(
+  name,
+  element,
+  blameOrigins,
+  localSources,
+  fallbackDeclarations,
+) {
+  const firstChildLine = element.children.reduce(
+    (earliest, child) => Math.min(earliest, child.startLine),
+    Number.POSITIVE_INFINITY,
+  );
+  const declarationEndLine = Number.isFinite(firstChildLine)
+    ? Math.max(element.startLine, firstChildLine - 1)
+    : element.endLine;
+  const declarationOrigins = Array.from(
+    { length: declarationEndLine - element.startLine + 1 },
+    (_, index) => element.startLine + index,
+  ).flatMap((line) => blameOrigins.get(line) ?? []);
+  const origins = blameOrigins.get(element.startLine)?.length
+    ? [...(blameOrigins.get(element.startLine) ?? [])]
+    : declarationOrigins;
+  const blamedLocal = origins.flatMap((origin) => {
+    const source = sourceForBlameOrigin(origin, localSources);
+    return source ? [source] : [];
+  });
+  const sources = uniqueSources(
+    origins.length > 0 ? blamedLocal : (fallbackDeclarations.get(name) ?? []),
+  );
+  return {
+    ownership: sources.some((source) => source.ownership === "app")
+      ? "app"
+      : sources.length > 0
+        ? "local-module"
+        : "external-dependency",
+    attribution:
+      origins.length > 0
+        ? "manifest-merger-blame"
+        : sources.length > 0
+          ? "active-source-manifest"
+          : "merged-manifest-only",
+    sources,
+  };
+}
+function dataAttributes(element) {
+  return Object.fromEntries(
+    Object.entries(element.attributes)
+      .map(([name, value]) => [localName(name), value])
+      .sort(([left], [right]) => left.localeCompare(right, "en")),
+  );
+}
+function deepLinkUri(data) {
+  if (!data.scheme) return undefined;
+  let uri = data.host
+    ? `${data.scheme}://${data.host}${data.port ? `:${data.port}` : ""}`
+    : `${data.scheme}:`;
+  uri += data.path ?? data.pathPrefix ?? data.pathPattern ?? "";
+  return uri;
+}
+function resourceName(value, expectedType) {
+  if (!value) return undefined;
+  const match = /^@(?:(?:[^:/]+):)?([^/]+)\/(.+)$/u.exec(value);
+  return match?.[1] === expectedType ? match[2] : undefined;
+}
+function metadataResource(component, metadataName) {
+  for (const child of component.children) {
+    if (
+      localName(child.name) !== "meta-data" ||
+      attribute(child, "name") !== metadataName
+    )
+      continue;
+    const name = resourceName(attribute(child, "resource"), "xml");
+    if (name) return { name, element: child };
+  }
+  return undefined;
+}
+function intentFilterActions(component) {
+  return component.children
+    .filter((child) => localName(child.name) === "intent-filter")
+    .flatMap((filter) =>
+      filter.children
+        .filter((child) => localName(child.name) === "action")
+        .map((child) => attribute(child, "name"))
+        .filter((value) => value !== undefined),
+    );
+}
+function intentEntries(selected, manifestPath, componentName, component) {
+  return component.children
+    .filter((child) => localName(child.name) === "intent-filter")
+    .flatMap((filter) => {
+      const actions = filter.children
+        .filter((child) => localName(child.name) === "action")
+        .map((child) => attribute(child, "name"))
+        .filter((value) => value !== undefined);
+      const categories = filter.children
+        .filter((child) => localName(child.name) === "category")
+        .map((child) => attribute(child, "name"))
+        .filter((value) => value !== undefined)
+        .sort((left, right) => left.localeCompare(right, "en"));
+      const results = [];
+      if (
+        actions.includes("android.intent.action.MAIN") &&
+        categories.includes("android.intent.category.LAUNCHER")
+      ) {
+        results.push({
+          kind: "launcher",
+          category: "normal",
+          componentName,
+          action: "android.intent.action.MAIN",
+          categories,
+          data: {},
+          evidence: evidence(
+            selected,
+            manifestPath,
+            filter,
+            `launcher:${componentName}`,
+          ),
+        });
+      }
+      if (
+        actions.includes("android.intent.action.VIEW") &&
+        categories.includes("android.intent.category.BROWSABLE")
+      ) {
+        const dataElements = filter.children.filter(
+          (child) => localName(child.name) === "data",
+        );
+        const alternatives = dataElements.length > 0 ? dataElements : [filter];
+        for (const dataElement of alternatives) {
+          const data =
+            dataElement === filter ? {} : dataAttributes(dataElement);
+          const uri = deepLinkUri(data);
+          results.push({
+            kind: "deep-link",
+            category: "alternate",
+            componentName,
+            action: "android.intent.action.VIEW",
+            categories,
+            ...(uri ? { uri } : {}),
+            data,
+            evidence: evidence(
+              selected,
+              manifestPath,
+              dataElement,
+              `deep-link:${componentName}${uri ? `:${uri}` : ""}`,
+            ),
+          });
+        }
+      }
+      return results;
+    });
+}
+export function extractMergedManifest(selected, manifestPath) {
+  try {
+    const root = parseXml(readFileSync(manifestPath, "utf8"));
+    if (localName(root.name) !== "manifest") {
+      throw new Error(`root element is ${root.name}, expected manifest`);
+    }
+    const packageName =
+      root.attributes.package ??
+      selected.variant.applicationId ??
+      selected.applicationModule.namespace;
+    const componentPackage =
+      root.attributes.package ??
+      selected.applicationModule.namespace ??
+      selected.variant.applicationId;
+    const application = root.children.find(
+      (child) => localName(child.name) === "application",
+    );
+    if (!application) {
+      throw new Error("manifest has no application element");
+    }
+    const componentElements = descendantElements(application).filter(
+      (element) => {
+        const name = localName(element.name);
+        return (
+          name === "activity" ||
+          name === "activity-alias" ||
+          name === "fragment" ||
+          name === "receiver"
+        );
+      },
+    );
+    const localSources = localManifestSources(selected);
+    const blameOrigins = readBlameOrigins(
+      manifestMergerBlamePath(selected, manifestPath),
+    );
+    const fallbackDeclarations = declarationsByComponent(
+      selected,
+      localSources,
+    );
+    const components = [];
+    const entries = [];
+    for (const element of componentElements) {
+      const rawName = attribute(element, "name");
+      if (!rawName) continue;
+      const name = resolveClassName(rawName, componentPackage);
+      const elementKind = localName(element.name);
+      const appWidgetMetadata =
+        elementKind === "receiver"
+          ? metadataResource(element, "android.appwidget.provider")
+          : undefined;
+      const widgetAction = intentFilterActions(element).includes(
+        "android.appwidget.action.APPWIDGET_UPDATE",
+      );
+      const kind =
+        elementKind === "receiver" && (appWidgetMetadata || widgetAction)
+          ? "app-widget"
+          : elementKind;
+      const exported = attribute(element, "exported");
+      const targetActivity = attribute(element, "targetActivity");
+      const shortcuts =
+        elementKind === "activity" || elementKind === "activity-alias"
+          ? metadataResource(element, "android.app.shortcuts")
+          : undefined;
+      components.push({
+        kind,
+        name,
+        ...(targetActivity
+          ? {
+              targetActivity: resolveClassName(
+                targetActivity,
+                componentPackage,
+              ),
+            }
+          : {}),
+        ...(exported === "true" || exported === "false"
+          ? { exported: exported === "true" }
+          : {}),
+        ...(appWidgetMetadata
+          ? { appWidgetInfoResource: appWidgetMetadata.name }
+          : {}),
+        ...(shortcuts ? { shortcutResources: [shortcuts.name] } : {}),
+        provenance: componentProvenance(
+          name,
+          element,
+          blameOrigins,
+          localSources,
+          fallbackDeclarations,
+        ),
+        evidence: evidence(selected, manifestPath, element, `${kind}:${name}`),
+      });
+      entries.push(...intentEntries(selected, manifestPath, name, element));
+      if (kind === "app-widget") {
+        const entryElement =
+          element.children.find(
+            (child) =>
+              localName(child.name) === "intent-filter" &&
+              child.children.some(
+                (grandchild) =>
+                  localName(grandchild.name) === "action" &&
+                  attribute(grandchild, "name") ===
+                    "android.appwidget.action.APPWIDGET_UPDATE",
+              ),
+          ) ??
+          appWidgetMetadata?.element ??
+          element;
+        entries.push({
+          kind: "widget",
+          category: "alternate",
+          componentName: name,
+          action: "android.appwidget.action.APPWIDGET_UPDATE",
+          categories: [],
+          data: appWidgetMetadata
+            ? { providerInfo: `@xml/${appWidgetMetadata.name}` }
+            : {},
+          evidence: evidence(
+            selected,
+            manifestPath,
+            entryElement,
+            `widget:${name}`,
+          ),
+        });
+      }
+    }
+    components.sort((left, right) =>
+      `${left.kind}:${left.name}`.localeCompare(
+        `${right.kind}:${right.name}`,
+        "en",
+      ),
+    );
+    entries.sort((left, right) =>
+      `${left.kind}:${left.componentName}:${left.uri ?? ""}`.localeCompare(
+        `${right.kind}:${right.componentName}:${right.uri ?? ""}`,
+        "en",
+      ),
+    );
+    return {
+      ...(packageName ? { packageName } : {}),
+      components,
+      entries,
+    };
+  } catch (error) {
+    if (error instanceof Error && error.name === "AnalysisFailure") throw error;
+    throw hardFailure(
+      "MERGED_MANIFEST_PARSE_FAILED",
+      "manifest",
+      `Could not parse merged Android Manifest: ${error instanceof Error ? error.message : String(error)}`,
+      undefined,
+      { path: relativePath(selected.model.projectRoot, manifestPath) },
+    );
+  }
+}