android2harmony 0.1.6 → 0.1.8

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

@@ -0,0 +1,234 @@
+import { resourceIdAliases } from "./resource-id.js";
+export class NormalizationState {
+  builder;
+  applicationId;
+  componentByQualifiedName = new Map();
+  componentTypeById = new Map();
+  layoutOwners = new Map();
+  uiByResourceId = new Map();
+  uiByLayout = new Map();
+  rootUiByLayout = new Map();
+  repeatedContainerIdsByLayoutOwner = new Map();
+  uiOwnerById = new Map();
+  callbackBySymbol = new Map();
+  fragmentByNavigationId = new Map();
+  navigationTargetByActionId = new Map();
+  navigationHostsByGraph = new Map();
+  activityAliasTargetByQualifiedName = new Map();
+  conditionalSurfacesByStateSymbol = new Map();
+  /**
+   * Compose surfaces whose visibility is controlled through a resolved state
+   * object API, for example DrawerState.open()/close(). The key is the same
+   * structured symbol identity used by expression normalization.
+   */
+  statefulSurfacesByStateSymbol = new Map();
+  /**
+   * Exact resolved state-object methods whose semantics were established by
+   * the surface call site itself (for example, a method matching the boolean
+   * `expanded` accessor or the method invoked by `onDismissRequest`).
+   */
+  statefulSurfaceTransitionsByStateSymbol = new Map();
+  /**
+   * Records the canonical effect emitted for a resolved UAST call. Kotlin
+   * property writes can be reported both as a synthetic setter call and as an
+   * assignment; the later assignment pass uses this registry to prove that
+   * both raw records describe the same mutation before suppressing the less
+   * precise duplicate.
+   */
+  effectByResolvedCall = new Map();
+  callbackByRawCallable = new Map();
+  constructor(builder, applicationId) {
+    this.builder = builder;
+    this.applicationId = applicationId?.trim() || undefined;
+  }
+  ensureComponent(
+    qualifiedName,
+    componentType,
+    location,
+    role,
+    confidence,
+    details = {},
+  ) {
+    const normalizedName = qualifiedName.trim();
+    const existingId = this.componentByQualifiedName.get(normalizedName);
+    const existingType = existingId
+      ? this.componentTypeById.get(existingId)
+      : undefined;
+    const type =
+      existingType && existingType !== "other" ? existingType : componentType;
+    const id = this.builder.addFact("component", {
+      identity: [{ kind: "component", value: normalizedName }],
+      confidence,
+      support: [{ location, role }],
+      data: {
+        componentType: type,
+        qualifiedName: normalizedName,
+        applicationModule: this.builder.analysisContext.applicationModule,
+        ...(details.uiTechnology ? { uiTechnology: details.uiTechnology } : {}),
+        ...(details.layoutResource
+          ? { layoutResource: details.layoutResource }
+          : {}),
+        ...(details.exported !== undefined
+          ? { exported: details.exported }
+          : {}),
+        ...(details.manifestProvenance
+          ? { manifestProvenance: details.manifestProvenance }
+          : {}),
+        ...(details.analysisRole ? { analysisRole: details.analysisRole } : {}),
+      },
+    });
+    this.componentByQualifiedName.set(normalizedName, id);
+    this.componentTypeById.set(id, type);
+    return id;
+  }
+  ensureLayoutSurrogate(layout, location) {
+    return this.ensureComponent(
+      `@layout/${layout}`,
+      "widget",
+      location,
+      "layout owner surrogate",
+      "medium",
+      {
+        uiTechnology: "views",
+        layoutResource: layout,
+      },
+    );
+  }
+  addLayoutOwner(layout, componentRef) {
+    const owners = this.layoutOwners.get(layout) ?? new Set();
+    owners.add(componentRef);
+    this.layoutOwners.set(layout, owners);
+  }
+  registerRepeatedLayoutContainer(layout, componentRef, resourceId) {
+    const key = `${layout}\u0000${componentRef}`;
+    const ids = this.repeatedContainerIdsByLayoutOwner.get(key) ?? new Set();
+    ids.add(resourceId);
+    this.repeatedContainerIdsByLayoutOwner.set(key, ids);
+  }
+  repeatedLayoutResourceId(layout, componentRef) {
+    const ids = [
+      ...(this.repeatedContainerIdsByLayoutOwner.get(
+        `${layout}\u0000${componentRef}`,
+      ) ?? []),
+    ].sort();
+    return ids.length === 1 ? `${ids[0]}/item` : undefined;
+  }
+  registerUi(resourceId, factId) {
+    if (!resourceId) return;
+    for (const alias of resourceIdAliases(resourceId)) {
+      const facts = this.uiByResourceId.get(alias) ?? new Set();
+      facts.add(factId);
+      this.uiByResourceId.set(alias, facts);
+    }
+  }
+  registerLayoutUi(layout, factId, isRoot) {
+    const facts = this.uiByLayout.get(layout) ?? new Set();
+    facts.add(factId);
+    this.uiByLayout.set(layout, facts);
+    if (!isRoot) return;
+    const roots = this.rootUiByLayout.get(layout) ?? new Set();
+    roots.add(factId);
+    this.rootUiByLayout.set(layout, roots);
+  }
+  registerCallback(symbol, factId) {
+    this.callbackBySymbol.set(symbol, factId);
+  }
+  callbackForRawCallable(rawCallableRef) {
+    return this.callbackByRawCallable.get(rawCallableRef);
+  }
+  /**
+   * A raw callable is one source-level declaration and therefore has one
+   * normalized callback identity, even when more than one normalizer observes
+   * it. The first registration is retained deterministically; callers must
+   * query before creating a new callback fact.
+   */
+  registerRawCallableCallback(rawCallableRef, callbackRef) {
+    const rawRef = rawCallableRef.trim();
+    if (rawRef.length === 0) {
+      throw new Error("rawCallableRef must not be blank");
+    }
+    const fact = this.builder.fact(callbackRef);
+    if (!fact || fact.kind !== "callback") {
+      throw new Error(
+        `Raw callable ${rawRef} must reference a callback fact: ${callbackRef}`,
+      );
+    }
+    const existing = this.callbackByRawCallable.get(rawRef);
+    if (existing) return existing;
+    this.callbackByRawCallable.set(rawRef, callbackRef);
+    return callbackRef;
+  }
+  /**
+   * Replaces an earlier use-site identity with the declaration-owned identity.
+   * Compose is normalized before JVM declarations, so a method reference can
+   * legitimately be observed first under its UI owner. The JVM declaration is
+   * the canonical callable once it becomes available.
+   */
+  canonicalizeRawCallableCallback(rawCallableRef, callbackRef) {
+    const rawRef = rawCallableRef.trim();
+    if (rawRef.length === 0) {
+      throw new Error("rawCallableRef must not be blank");
+    }
+    const fact = this.builder.fact(callbackRef);
+    if (!fact || fact.kind !== "callback") {
+      throw new Error(
+        `Raw callable ${rawRef} must reference a callback fact: ${callbackRef}`,
+      );
+    }
+    this.callbackByRawCallable.set(rawRef, callbackRef);
+  }
+  registerResolvedCallEffect(rawCallRef, effectRef) {
+    const rawRef = rawCallRef.trim();
+    if (rawRef.length === 0) {
+      throw new Error("rawCallRef must not be blank");
+    }
+    const fact = this.builder.fact(effectRef);
+    if (!fact || fact.kind !== "behavior-effect") {
+      throw new Error(
+        `Raw call ${rawRef} must reference a behavior-effect fact: ${effectRef}`,
+      );
+    }
+    this.effectByResolvedCall.set(rawRef, effectRef);
+  }
+  effectForResolvedCall(rawCallRef) {
+    return this.effectByResolvedCall.get(rawCallRef);
+  }
+  registerConditionalSurfaceState(stateSymbol, surfaceRef, activation) {
+    const key = stateSymbol.trim();
+    if (key.length === 0) {
+      throw new Error("stateSymbol must not be blank");
+    }
+    const surfaces =
+      this.conditionalSurfacesByStateSymbol.get(key) ?? new Map();
+    surfaces.set(surfaceRef, activation);
+    this.conditionalSurfacesByStateSymbol.set(key, surfaces);
+  }
+  registerStatefulSurfaceState(stateSymbol, surfaceRef) {
+    const key = stateSymbol.trim();
+    if (key.length === 0) {
+      throw new Error("stateSymbol must not be blank");
+    }
+    const surfaces = this.statefulSurfacesByStateSymbol.get(key) ?? new Set();
+    surfaces.add(surfaceRef);
+    this.statefulSurfacesByStateSymbol.set(key, surfaces);
+  }
+  registerStatefulSurfaceTransition(stateSymbol, targetSignature, transition) {
+    const key = stateSymbol.trim();
+    const signature = targetSignature.trim();
+    if (key.length === 0 || signature.length === 0) {
+      throw new Error("stateSymbol and targetSignature must not be blank");
+    }
+    const methods =
+      this.statefulSurfaceTransitionsByStateSymbol.get(key) ?? new Map();
+    const transitions = methods.get(signature) ?? new Set();
+    transitions.add(transition);
+    methods.set(signature, transitions);
+    this.statefulSurfaceTransitionsByStateSymbol.set(key, methods);
+  }
+  statefulSurfaceTransition(stateSymbol, targetSignature) {
+    const transitions = this.statefulSurfaceTransitionsByStateSymbol
+      .get(stateSymbol.trim())
+      ?.get(targetSignature.trim());
+    return transitions?.size === 1 ? [...transitions][0] : undefined;
+  }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,40 @@
+import { extractMergedManifest } from "./manifest.js";
+import { selectAndroidResources } from "./resources.js";
+import { ANDROID_XML_CONTRACT_VERSION } from "./types.js";
+import { extractAndroidViews } from "./views.js";
+export function extractAndroidXml(input) {
+  const selection = selectAndroidResources(
+    input.selected,
+    input.resourceConfiguration,
+  );
+  const manifest = extractMergedManifest(
+    input.selected,
+    input.mergedManifestPath,
+  );
+  const xml = extractAndroidViews(input.selected, selection, manifest);
+  return {
+    contractVersion: ANDROID_XML_CONTRACT_VERSION,
+    target: {
+      applicationModule: input.selected.applicationModule.gradlePath,
+      buildVariant: input.selected.variant.name,
+      resourceConfiguration: input.resourceConfiguration,
+    },
+    manifest: {
+      ...manifest,
+      entries: [...manifest.entries, ...xml.shortcutEntries].sort(
+        (left, right) =>
+          `${left.kind}:${left.componentName}:${left.uri ?? ""}:${left.data.shortcutId ?? ""}`.localeCompare(
+            `${right.kind}:${right.componentName}:${right.uri ?? ""}:${right.data.shortcutId ?? ""}`,
+            "en",
+          ),
+      ),
+    },
+    values: selection.values,
+    resources: selection.resources,
+    views: xml.views,
+    fragments: xml.fragments,
+    includes: xml.includes,
+    navigationTargets: xml.navigationTargets,
+    appWidgetLayouts: xml.appWidgetLayouts,
+  };
+}

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

@@ -0,0 +1,6 @@
+export * from "./extract.js";
+export * from "./manifest.js";
+export * from "./resources.js";
+export * from "./types.js";
+export * from "./views.js";
+export * from "./xml-parser.js";