android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/source-facts/normalize.js

@@ -0,0 +1,33 @@
+import { normalizeAreaTitleFacts } from "./area-titles.js";
+import { normalizeAndroidFacts, prepareAndroidStructure } from "./android.js";
+import { SourceFactsBuilder } from "./builder.js";
+import { normalizeComposeFacts } from "./compose.js";
+import { normalizeComposeCallSiteFacts } from "./compose-call-sites.js";
+import { normalizeInteractionEffects } from "./interaction-effects.js";
+import { normalizeJvmFacts, prepareJvmStructure } from "./jvm.js";
+import { normalizePendingIntentFacts } from "./pending-intents.js";
+import { normalizeRouteStateVariants } from "./route-state-variants.js";
+import { NormalizationState } from "./state.js";
+export function buildSourceFacts(input) {
+  const builder = new SourceFactsBuilder(input.caseId, {
+    ...input.android.target,
+    ...(input.sourceSnapshot ? { sourceSnapshot: input.sourceSnapshot } : {}),
+  });
+  const state = new NormalizationState(
+    builder,
+    input.android.manifest.packageName,
+  );
+  // Component identities must exist before calls and XML controls establish
+  // their strong owner references.
+  prepareAndroidStructure(input.android, state);
+  const jvmIndex = prepareJvmStructure(input.jvm, state);
+  normalizeAndroidFacts(input.android, state);
+  normalizeComposeFacts(input.android, input.jvm, state);
+  normalizeJvmFacts(input.jvm, state, jvmIndex);
+  normalizeComposeCallSiteFacts(input.android, input.jvm, state);
+  normalizeAreaTitleFacts(input.android, state, jvmIndex);
+  normalizePendingIntentFacts(input.jvm, state);
+  normalizeInteractionEffects(input.jvm, state);
+  normalizeRouteStateVariants(input.jvm, state);
+  return builder.finish();
+}

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/source-facts/pending-intents.js

@@ -0,0 +1,565 @@
+function objectValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+}
+function object(record, key) {
+  return objectValue(record.data[key]);
+}
+function objectText(value, key) {
+  const candidate = value?.[key];
+  return typeof candidate === "string" && candidate.trim().length > 0
+    ? candidate.trim()
+    : undefined;
+}
+function text(record, key) {
+  const candidate = record.data[key];
+  return typeof candidate === "string" && candidate.trim().length > 0
+    ? candidate.trim()
+    : undefined;
+}
+function boolean(record, key) {
+  const candidate = record.data[key];
+  return typeof candidate === "boolean" ? candidate : undefined;
+}
+function sourceKind(record) {
+  const language = text(record, "language");
+  if (language === "kotlin" || record.location?.path.endsWith(".kt")) {
+    return "kotlin";
+  }
+  if (language === "java" || record.location?.path.endsWith(".java")) {
+    return "java";
+  }
+  return "other";
+}
+function recordLocation(record, anchor, symbol) {
+  if (!record.location) return undefined;
+  return {
+    sourceKind: sourceKind(record),
+    path: record.location.path,
+    anchor,
+    range: {
+      startLine: Math.max(1, record.location.startLine),
+      endLine: Math.max(
+        Math.max(1, record.location.startLine),
+        record.location.endLine,
+      ),
+      ...(record.location.startColumn >= 1
+        ? { startColumn: record.location.startColumn }
+        : {}),
+      ...(record.location.endColumn >= 1
+        ? { endColumn: record.location.endColumn }
+        : {}),
+    },
+    ...(symbol ? { symbol } : {}),
+  };
+}
+function appendBinding(bindings, record) {
+  const callRef = text(record, "callRef");
+  if (!callRef) return;
+  const values = bindings.get(callRef) ?? [];
+  values.push(record);
+  bindings.set(callRef, values);
+}
+function buildIndex(jvm) {
+  const callsById = new Map();
+  const resolvedCalls = [];
+  const bindingsByCallRef = new Map();
+  const methodsBySignature = new Map();
+  const returnsByCallableRef = new Map();
+  for (const record of jvm.body) {
+    if (record.kind === "resolved-call" || record.kind === "unresolved-call") {
+      callsById.set(record.id, record);
+      if (record.kind === "resolved-call") resolvedCalls.push(record);
+    } else if (record.kind === "call-argument-binding") {
+      appendBinding(bindingsByCallRef, record);
+    } else if (record.kind === "method-declaration") {
+      const signature = text(record, "signature");
+      if (signature) {
+        const values = methodsBySignature.get(signature) ?? [];
+        values.push(record);
+        methodsBySignature.set(signature, values);
+      }
+    } else if (record.kind === "return") {
+      const callableRef = text(record, "enclosingCallableRef");
+      if (!callableRef) continue;
+      const values = returnsByCallableRef.get(callableRef) ?? [];
+      values.push(record);
+      returnsByCallableRef.set(callableRef, values);
+    }
+  }
+  return {
+    callsById,
+    resolvedCalls: resolvedCalls.sort((left, right) =>
+      left.id.localeCompare(right.id, "en"),
+    ),
+    bindingsByCallRef,
+    methodsBySignature,
+    returnsByCallableRef,
+  };
+}
+function expression(binding) {
+  return object(binding, "expression");
+}
+/**
+ * Follows only analyzer-provided expression structure. In particular, this
+ * deliberately does not parse argumentSource, initializerSource, or source.
+ */
+function callRefFromExpression(value, visited = new Set()) {
+  if (!value || visited.has(value)) return undefined;
+  visited.add(value);
+  const direct = objectText(value, "callRef");
+  if (direct) return direct;
+  const symbol = objectValue(value.resolvedSymbol);
+  const initializer = objectValue(symbol?.initializer);
+  return initializer ? callRefFromExpression(initializer, visited) : undefined;
+}
+function classFromExpression(value, visited = new Set()) {
+  if (!value || visited.has(value)) return undefined;
+  visited.add(value);
+  const literal = objectValue(value.classLiteral);
+  const direct = objectText(literal, "resolvedClassQualifiedName");
+  if (direct) return direct;
+  const symbol = objectValue(value.resolvedSymbol);
+  const initializer = objectValue(symbol?.initializer);
+  return initializer ? classFromExpression(initializer, visited) : undefined;
+}
+function resourceFromExpression(value, resourceType) {
+  const resource = objectValue(value?.resourceReference);
+  return objectText(resource, "resourceType") === resourceType
+    ? objectText(resource, "resourceName")
+    : undefined;
+}
+function uniqueString(values) {
+  const unique = [...new Set(values.filter((value) => value !== undefined))];
+  return unique.length === 1 ? unique[0] : undefined;
+}
+function isRemoteViewsClick(call) {
+  return (
+    text(call, "targetOwnerQualifiedName") === "android.widget.RemoteViews" &&
+    text(call, "targetName") === "setOnClickPendingIntent"
+  );
+}
+function isRemoteViewsConstructor(call) {
+  return (
+    text(call, "targetOwnerQualifiedName") === "android.widget.RemoteViews" &&
+    text(call, "targetName") === "RemoteViews" &&
+    boolean(call, "targetConstructor") === true
+  );
+}
+function isNotificationContentIntent(call) {
+  const owner = text(call, "targetOwnerQualifiedName");
+  return (
+    text(call, "targetName") === "setContentIntent" &&
+    (owner === "android.app.Notification.Builder" ||
+      owner === "androidx.core.app.NotificationCompat.Builder")
+  );
+}
+function isActivityPendingIntent(call) {
+  return (
+    text(call, "targetOwnerQualifiedName") === "android.app.PendingIntent" &&
+    text(call, "targetName") === "getActivity"
+  );
+}
+function isIntentConstructor(call) {
+  return (
+    text(call, "targetOwnerQualifiedName") === "android.content.Intent" &&
+    text(call, "targetName") === "Intent" &&
+    boolean(call, "targetConstructor") === true
+  );
+}
+function callsReferencedByBindings(callRef, index) {
+  const refs = (index.bindingsByCallRef.get(callRef) ?? [])
+    .map((binding) => callRefFromExpression(expression(binding)))
+    .filter((ref) => ref !== undefined);
+  return [...new Set(refs)]
+    .map((ref) => index.callsById.get(ref))
+    .filter((call) => call !== undefined);
+}
+function receiverInitializerCall(call, index) {
+  const receiver = object(call, "receiverResolvedSymbol");
+  const initializer = objectValue(receiver?.initializer);
+  const callRef = callRefFromExpression(initializer);
+  return callRef ? index.callsById.get(callRef) : undefined;
+}
+function layoutForRemoteViews(clickCall, index) {
+  const constructor = receiverInitializerCall(clickCall, index);
+  if (!constructor || !isRemoteViewsConstructor(constructor)) {
+    return undefined;
+  }
+  return uniqueString(
+    (index.bindingsByCallRef.get(constructor.id) ?? []).map((binding) =>
+      resourceFromExpression(expression(binding), "layout"),
+    ),
+  );
+}
+function intentForPendingIntent(pendingIntent, index) {
+  const candidates = callsReferencedByBindings(pendingIntent.id, index).filter(
+    isIntentConstructor,
+  );
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+function targetForIntent(intent, index) {
+  return uniqueString(
+    (index.bindingsByCallRef.get(intent.id) ?? []).map((binding) =>
+      classFromExpression(expression(binding)),
+    ),
+  );
+}
+function uniqueRecords(records) {
+  return [
+    ...new Map(records.map((record) => [record.id, record])).values(),
+  ].sort((left, right) => left.id.localeCompare(right.id, "en"));
+}
+function directActivityPendingIntent(call, index) {
+  if (!isActivityPendingIntent(call)) return undefined;
+  const intentCall = intentForPendingIntent(call, index);
+  const targetClass = intentCall
+    ? targetForIntent(intentCall, index)
+    : undefined;
+  return intentCall && targetClass
+    ? {
+        pendingIntentCall: call,
+        intentCall,
+        targetClass,
+        flowRecords: uniqueRecords([call, intentCall]),
+      }
+    : undefined;
+}
+function activityPendingIntentFromExpression(
+  value,
+  index,
+  visitedDeclarations = new Set(),
+) {
+  const callRef = callRefFromExpression(value);
+  const call = callRef ? index.callsById.get(callRef) : undefined;
+  return call
+    ? activityPendingIntentFromCall(call, index, visitedDeclarations)
+    : undefined;
+}
+function activityPendingIntentFromCall(call, index, visitedDeclarations) {
+  const direct = directActivityPendingIntent(call, index);
+  if (direct) return direct;
+  const targetSignature = text(call, "targetSignature");
+  const declarations = targetSignature
+    ? (index.methodsBySignature.get(targetSignature) ?? [])
+    : [];
+  const declaration = declarations.length === 1 ? declarations[0] : undefined;
+  if (!declaration || visitedDeclarations.has(declaration.id)) {
+    return undefined;
+  }
+  const returns = [
+    ...(index.returnsByCallableRef.get(declaration.id) ?? []),
+  ].sort((left, right) => left.id.localeCompare(right.id, "en"));
+  if (returns.length === 0) return undefined;
+  const nextVisited = new Set(visitedDeclarations);
+  nextVisited.add(declaration.id);
+  const resolutions = returns.map((record) =>
+    activityPendingIntentFromExpression(
+      object(record, "expression"),
+      index,
+      nextVisited,
+    ),
+  );
+  // A partially understood factory is not a unique static route. Every
+  // observed return must resolve and all of them must agree on one Activity.
+  if (resolutions.some((resolution) => resolution === undefined)) {
+    return undefined;
+  }
+  const resolved = resolutions;
+  const targetClass = uniqueString(
+    resolved.map((resolution) => resolution.targetClass),
+  );
+  if (!targetClass) return undefined;
+  const representative = [...resolved].sort((left, right) =>
+    left.pendingIntentCall.id.localeCompare(right.pendingIntentCall.id, "en"),
+  )[0];
+  return {
+    pendingIntentCall: representative.pendingIntentCall,
+    intentCall: representative.intentCall,
+    targetClass,
+    flowRecords: uniqueRecords([
+      call,
+      declaration,
+      ...returns,
+      ...resolved.flatMap((resolution) => resolution.flowRecords),
+    ]),
+  };
+}
+function activityPendingIntentArgument(call, index) {
+  const bindings = (index.bindingsByCallRef.get(call.id) ?? []).filter(
+    (binding) => text(binding, "parameterType") === "android.app.PendingIntent",
+  );
+  return bindings.length === 1
+    ? activityPendingIntentFromExpression(expression(bindings[0]), index)
+    : undefined;
+}
+function resourceIdForClick(clickCall, index) {
+  return uniqueString(
+    (index.bindingsByCallRef.get(clickCall.id) ?? []).map((binding) =>
+      resourceFromExpression(expression(binding), "id"),
+    ),
+  );
+}
+function widgetControl(state, clickCall, layout, resourceId) {
+  const enclosingClass = text(clickCall, "enclosingClass");
+  const enclosingOwner = enclosingClass
+    ? state.componentByQualifiedName.get(enclosingClass)
+    : undefined;
+  const enclosingWidget =
+    enclosingOwner && state.componentTypeById.get(enclosingOwner) === "widget"
+      ? enclosingOwner
+      : undefined;
+  let candidates = [...(state.uiByLayout.get(layout) ?? [])]
+    .map((id) => state.builder.fact(id))
+    .filter(
+      (fact) =>
+        fact?.kind === "ui-element" &&
+        fact.data.resourceId === resourceId &&
+        state.componentTypeById.get(fact.data.ownerKey) === "widget",
+    );
+  if (enclosingWidget) {
+    const owned = candidates.filter(
+      (fact) =>
+        fact?.kind === "ui-element" && fact.data.ownerKey === enclosingWidget,
+    );
+    if (owned.length > 0) candidates = owned;
+  }
+  const unique = [
+    ...new Map(candidates.map((fact) => [fact?.id, fact])).values(),
+  ];
+  const control = unique.length === 1 ? unique[0] : undefined;
+  return control?.kind === "ui-element"
+    ? {
+        controlRef: control.id,
+        widgetRef: control.data.ownerKey,
+      }
+    : undefined;
+}
+function resolveRemoteViewsClick(state, clickCall, index) {
+  const layout = layoutForRemoteViews(clickCall, index);
+  const resourceId = resourceIdForClick(clickCall, index);
+  const pendingIntent = activityPendingIntentArgument(clickCall, index);
+  if (!layout || !resourceId || !pendingIntent) return undefined;
+  const control = widgetControl(state, clickCall, layout, resourceId);
+  if (!control) return undefined;
+  return {
+    clickCall,
+    pendingIntentCall: pendingIntent.pendingIntentCall,
+    intentCall: pendingIntent.intentCall,
+    targetClass: pendingIntent.targetClass,
+    layout,
+    resourceId,
+    ...control,
+  };
+}
+function addRemoteViewsClickFacts(state, resolution) {
+  const clickSignature =
+    text(resolution.clickCall, "targetSignature") ??
+    "android.widget.RemoteViews#setOnClickPendingIntent";
+  const pendingSignature =
+    text(resolution.pendingIntentCall, "targetSignature") ??
+    "android.app.PendingIntent#getActivity";
+  const clickLocation = recordLocation(
+    resolution.clickCall,
+    `remote-views-click:${resolution.layout}/${resolution.resourceId}`,
+    clickSignature,
+  );
+  const pendingLocation = recordLocation(
+    resolution.pendingIntentCall,
+    `activity-pending-intent:${resolution.targetClass}`,
+    pendingSignature,
+  );
+  const targetLocation = recordLocation(
+    resolution.intentCall,
+    `explicit-intent-target:${resolution.targetClass}`,
+    resolution.targetClass,
+  );
+  if (!clickLocation || !pendingLocation || !targetLocation) return;
+  const targetRef = state.ensureComponent(
+    resolution.targetClass,
+    "activity",
+    targetLocation,
+    "explicit Activity PendingIntent target",
+    "high",
+    { uiTechnology: "views" },
+  );
+  const callbackRef = state.builder.addFact("callback", {
+    identity: [
+      { kind: "component", value: resolution.widgetRef },
+      {
+        kind: "callback",
+        value:
+          `remote-views:${resolution.clickCall.id}:` +
+          resolution.pendingIntentCall.id,
+      },
+    ],
+    confidence: "high",
+    support: [
+      {
+        location: clickLocation,
+        role: "RemoteViews PendingIntent click binding",
+      },
+      {
+        location: pendingLocation,
+        role: "resolved activity PendingIntent factory",
+      },
+    ],
+    data: {
+      ownerKey: resolution.widgetRef,
+      callableSymbol: `${clickSignature} -> ${pendingSignature}`,
+      callbackKind: "function",
+    },
+    relatedFactRefs: [resolution.widgetRef],
+  });
+  const interactionRef = state.builder.addFact("interaction-binding", {
+    identity: [
+      { kind: "control", value: resolution.controlRef },
+      { kind: "callback", value: callbackRef },
+      { kind: "semantic-key", value: clickSignature },
+    ],
+    confidence: "high",
+    support: [
+      {
+        location: clickLocation,
+        role: "resolved RemoteViews click interaction",
+      },
+    ],
+    data: {
+      elementKey: resolution.controlRef,
+      callbackKey: callbackRef,
+      trigger: "click",
+      bindingApi: clickSignature,
+    },
+    relatedFactRefs: [resolution.controlRef, callbackRef],
+  });
+  const effectRef = state.builder.addFact("behavior-effect", {
+    identity: [
+      { kind: "callback", value: callbackRef },
+      { kind: "component", value: targetRef },
+      { kind: "semantic-key", value: "activity-pending-intent" },
+    ],
+    confidence: "high",
+    support: [
+      {
+        location: pendingLocation,
+        role: "PendingIntent launches an Activity",
+      },
+      {
+        location: targetLocation,
+        role: "explicit Intent component target",
+      },
+    ],
+    data: {
+      callbackKey: callbackRef,
+      effectKind: "navigate-area",
+      targetKey: targetRef,
+    },
+    relatedFactRefs: [callbackRef, targetRef, interactionRef],
+  });
+  state.builder.addFact("navigation-target", {
+    identity: [
+      { kind: "semantic-key", value: effectRef },
+      { kind: "component", value: targetRef },
+    ],
+    confidence: "high",
+    support: [
+      {
+        location: targetLocation,
+        role: "explicit Activity class in PendingIntent Intent",
+      },
+    ],
+    data: {
+      effectKey: effectRef,
+      targetKind: "component",
+      targetKey: targetRef,
+    },
+    relatedFactRefs: [effectRef, targetRef],
+  });
+}
+function addNotificationEntry(state, consumer, resolution) {
+  const consumerSignature =
+    text(consumer, "targetSignature") ??
+    `${text(consumer, "targetOwnerQualifiedName") ?? "Notification.Builder"}` +
+      "#setContentIntent";
+  const consumerLocation = recordLocation(
+    consumer,
+    `notification-content-intent:${consumer.id}`,
+    consumerSignature,
+  );
+  const targetLocation = recordLocation(
+    resolution.intentCall,
+    `explicit-intent-target:${resolution.targetClass}`,
+    resolution.targetClass,
+  );
+  if (!consumerLocation || !targetLocation) return;
+  const targetRef = state.ensureComponent(
+    resolution.targetClass,
+    "activity",
+    targetLocation,
+    "explicit notification Activity target",
+    "high",
+    { uiTechnology: "views" },
+  );
+  const flowSupport = resolution.flowRecords.flatMap((record) => {
+    const location = recordLocation(
+      record,
+      `notification-pending-intent-flow:${record.id}`,
+      text(record, "targetSignature") ??
+        text(record, "signature") ??
+        resolution.targetClass,
+    );
+    return location
+      ? [
+          {
+            location,
+            role:
+              record.kind === "return"
+                ? "local PendingIntent factory return"
+                : "resolved notification PendingIntent flow",
+          },
+        ]
+      : [];
+  });
+  state.builder.addFact("entry-point", {
+    identity: [
+      { kind: "entry", value: "notification" },
+      { kind: "component", value: targetRef },
+      { kind: "semantic-key", value: consumer.id },
+    ],
+    confidence: "high",
+    support: [
+      {
+        location: consumerLocation,
+        role: "Notification builder consumes content PendingIntent",
+      },
+      ...flowSupport,
+    ],
+    data: {
+      entryKind: "notification",
+      category: "alternate",
+      componentKey: targetRef,
+      conditionKeys: [],
+    },
+    relatedFactRefs: [targetRef],
+  });
+}
+/**
+ * Resolves only consumed activity PendingIntents. Merely constructing or
+ * returning a PendingIntent is intentionally not treated as a notification
+ * entry; an entry kind requires a corresponding consuming API.
+ */
+export function normalizePendingIntentFacts(jvm, state) {
+  if (!jvm) return;
+  const index = buildIndex(jvm);
+  for (const call of index.resolvedCalls) {
+    if (isRemoteViewsClick(call)) {
+      const resolution = resolveRemoteViewsClick(state, call, index);
+      if (resolution) addRemoteViewsClickFacts(state, resolution);
+    }
+    if (isNotificationContentIntent(call)) {
+      const resolution = activityPendingIntentArgument(call, index);
+      if (resolution) addNotificationEntry(state, call, resolution);
+    }
+  }
+}

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/source-facts/resource-id.js

@@ -0,0 +1,42 @@
+/**
+ * Android resource names and generated ViewBinding properties use two
+ * spellings for the same source identity. A layout ID may be written as
+ * `search_btn`, while the generated property is `searchBtn`. Some projects
+ * also use lower-camel IDs directly in XML, so neither spelling can be
+ * treated as the one canonical serialized value.
+ *
+ * These helpers deliberately keep a small, reversible alias set. We do not
+ * remove separators or case-fold arbitrary strings: if two controls share an
+ * alias in one owner, callers will see both candidates and retain the
+ * ambiguity instead of silently joining them.
+ */
+export function camelToSnakeResourceId(value) {
+  return value
+    .replace(/([a-z0-9])([A-Z])/gu, "$1_$2")
+    .replace(/([A-Z]+)([A-Z][a-z])/gu, "$1_$2")
+    .toLowerCase();
+}
+export function snakeToLowerCamelResourceId(value) {
+  return value.replace(/_+([A-Za-z0-9])/gu, (_match, next) =>
+    next.toUpperCase(),
+  );
+}
+export function resourceIdAliases(value) {
+  const exact = value.trim();
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(exact)) {
+    return exact.length > 0 ? [exact] : [];
+  }
+  const snake = camelToSnakeResourceId(exact);
+  return [
+    ...new Set([
+      exact,
+      snake,
+      snakeToLowerCamelResourceId(exact),
+      snakeToLowerCamelResourceId(snake),
+    ]),
+  ];
+}
+export function resourceIdsEquivalent(left, right) {
+  const rightAliases = new Set(resourceIdAliases(right));
+  return resourceIdAliases(left).some((alias) => rightAliases.has(alias));
+}