android2harmony 0.1.7 → 0.1.8

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

@@ -0,0 +1,447 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { hardFailure } from "../diagnostics.js";
+import { localName, parseXml } from "./xml-parser.js";
+function attribute(element, name) {
+  return (
+    element.attributes[`android:${name}`] ??
+    element.attributes[`app:${name}`] ??
+    element.attributes[name]
+  );
+}
+function referenceName(value, expectedType) {
+  if (!value) return undefined;
+  const match = /^@(?:\+)?([^/]+)\/(.+)$/u.exec(value);
+  if (!match) return value;
+  if (expectedType && match[1] !== expectedType) return undefined;
+  return match[2];
+}
+function resourceReference(raw) {
+  if (!raw) return undefined;
+  const match =
+    /^@(?:\+)?(?:(?<package>[^:/]+):)?(?<type>[^/]+)\/(?<name>.+)$/u.exec(raw);
+  const resourceType = match?.groups?.type;
+  const name = match?.groups?.name;
+  if (!resourceType || !name) return undefined;
+  const packageName = match?.groups?.package;
+  return {
+    raw,
+    resourceType,
+    name,
+    ...(packageName ? { packageName } : {}),
+  };
+}
+const iconAttributeNames = [
+  "src",
+  "srcCompat",
+  "icon",
+  "drawableStart",
+  "drawableEnd",
+  "drawableLeft",
+  "drawableRight",
+  "drawableTop",
+  "drawableBottom",
+];
+function iconResources(element) {
+  const seen = new Set();
+  return iconAttributeNames.flatMap((name) => {
+    const reference = resourceReference(attribute(element, name));
+    if (!reference) return [];
+    const key = `${reference.packageName ?? ""}:${reference.resourceType}/${reference.name}`;
+    if (seen.has(key)) return [];
+    seen.add(key);
+    return [reference];
+  });
+}
+function evidence(resource, element, anchor) {
+  return {
+    sourceKind: "xml",
+    path: resource.path,
+    anchor,
+    range: {
+      startLine: element.startLine,
+      endLine: element.endLine,
+    },
+  };
+}
+function interactiveTag(tag, resourceType) {
+  const name = localName(tag).toLowerCase();
+  if (resourceType === "menu" && name === "item") return true;
+  if (
+    resourceType === "xml" &&
+    name.includes("preference") &&
+    !name.endsWith("preferencecategory") &&
+    !name.endsWith("preferencescreen")
+  )
+    return true;
+  return (
+    name === "button" ||
+    name === "imagebutton" ||
+    name === "edittext" ||
+    name === "checkbox" ||
+    name === "radiobutton" ||
+    name === "switch" ||
+    name === "switchcompat" ||
+    name === "togglebutton" ||
+    name === "spinner" ||
+    name === "seekbar" ||
+    name === "ratingbar" ||
+    name.endsWith("button") ||
+    name.endsWith("chip") ||
+    name.endsWith("floatingactionbutton")
+  );
+}
+function recordView(resource, element, selection, isLayoutRoot) {
+  const preferenceElement =
+    resource.resourceType === "xml" &&
+    localName(element.name).toLowerCase().includes("preference");
+  const rawPreferenceKey = preferenceElement
+    ? attribute(element, "key")
+    : undefined;
+  const resolvedPreferenceKey = rawPreferenceKey
+    ? selection.resolveAttribute(rawPreferenceKey)
+    : undefined;
+  const preferenceKey =
+    resolvedPreferenceKey?.resolved?.trim() ||
+    (!rawPreferenceKey?.startsWith("@") ? rawPreferenceKey?.trim() : undefined);
+  const id = referenceName(attribute(element, "id"), "id") ?? preferenceKey;
+  const rawText = attribute(element, "text") ?? attribute(element, "title");
+  const rawTextAppearance = attribute(element, "textAppearance");
+  const rawHint = attribute(element, "hint");
+  const rawDescription = attribute(element, "contentDescription");
+  const rawEnabled = attribute(element, "enabled");
+  // `checked` is the existing transport slot for a control's initial
+  // selection. Preference XML calls the same concept `defaultValue`.
+  const rawChecked =
+    attribute(element, "checked") ??
+    (preferenceElement ? attribute(element, "defaultValue") : undefined);
+  const rawEntries = attribute(element, "entries");
+  const labelFor = referenceName(attribute(element, "labelFor"), "id");
+  const icons = iconResources(element);
+  const onClick = attribute(element, "onClick");
+  const actionable =
+    Boolean(onClick) ||
+    attribute(element, "clickable") === "true" ||
+    interactiveTag(element.name, resource.resourceType);
+  if (
+    !id &&
+    rawText === undefined &&
+    rawHint === undefined &&
+    rawDescription === undefined &&
+    rawEnabled === undefined &&
+    rawChecked === undefined &&
+    rawEntries === undefined &&
+    !labelFor &&
+    icons.length === 0 &&
+    !onClick &&
+    !actionable
+  ) {
+    return undefined;
+  }
+  const anchor = `${resource.resourceType}/${resource.name}#${id ?? `${localName(element.name)}:${element.startLine}`}`;
+  return {
+    resourceType: resource.resourceType,
+    resourceName: resource.name,
+    tag: element.name,
+    ...(isLayoutRoot ? { isLayoutRoot: true } : {}),
+    ...(id ? { id } : {}),
+    ...(rawText !== undefined
+      ? { text: selection.resolveAttribute(rawText) }
+      : {}),
+    ...(rawTextAppearance
+      ? {
+          textAppearance: selection.resolveAttribute(rawTextAppearance),
+        }
+      : {}),
+    ...(rawHint ? { hint: selection.resolveAttribute(rawHint) } : {}),
+    ...(rawDescription
+      ? { contentDescription: selection.resolveAttribute(rawDescription) }
+      : {}),
+    ...(rawEnabled !== undefined
+      ? { enabled: selection.resolveAttribute(rawEnabled) }
+      : {}),
+    ...(rawChecked !== undefined
+      ? { checked: selection.resolveAttribute(rawChecked) }
+      : {}),
+    ...(rawEntries !== undefined
+      ? { entries: selection.resolveAttribute(rawEntries) }
+      : {}),
+    ...(labelFor ? { labelFor } : {}),
+    ...(icons.length > 0 ? { iconResources: icons } : {}),
+    ...(onClick ? { onClick } : {}),
+    actionable,
+    evidence: evidence(resource, element, anchor),
+  };
+}
+function fragmentClass(element) {
+  const tag = localName(element.name);
+  if (tag === "fragment") {
+    return attribute(element, "name") ?? element.attributes.class;
+  }
+  if (tag.endsWith("FragmentContainerView")) {
+    return attribute(element, "name");
+  }
+  return undefined;
+}
+function sourceIdentity(element) {
+  if (!element) return undefined;
+  return (
+    referenceName(attribute(element, "id"), "id") ??
+    attribute(element, "shortcutId")
+  );
+}
+function visitResource(projectRoot, resource, selection) {
+  const path = resolve(projectRoot, resource.path);
+  const root = parseXml(readFileSync(path, "utf8"));
+  const views = [];
+  const fragments = [];
+  const includes = [];
+  const navigationTargets = [];
+  const appWidgetInfos = [];
+  const visit = (element, parent) => {
+    const preferenceResource =
+      resource.resourceType === "xml" &&
+      localName(root.name).toLowerCase().endsWith("preferencescreen");
+    if (
+      resource.resourceType === "layout" ||
+      resource.resourceType === "menu" ||
+      preferenceResource
+    ) {
+      const view = recordView(
+        resource,
+        element,
+        selection,
+        resource.resourceType === "layout" && element === root,
+      );
+      if (view) views.push(view);
+    }
+    const className = fragmentClass(element);
+    if (className) {
+      const id = referenceName(attribute(element, "id"), "id");
+      const rawLabel = attribute(element, "label");
+      const navigationGraph = referenceName(
+        attribute(element, "navGraph"),
+        "navigation",
+      );
+      fragments.push({
+        resourceName: resource.name,
+        ...(id ? { id } : {}),
+        className,
+        ...(rawLabel ? { label: selection.resolveAttribute(rawLabel) } : {}),
+        ...(navigationGraph ? { navigationGraph } : {}),
+        evidence: evidence(
+          resource,
+          element,
+          `${resource.resourceType}/${resource.name}#fragment:${id ?? className}`,
+        ),
+      });
+    }
+    if (localName(element.name) === "include") {
+      const includedLayout = referenceName(
+        element.attributes.layout ?? attribute(element, "layout"),
+        "layout",
+      );
+      if (includedLayout) {
+        includes.push({
+          resourceName: resource.name,
+          includedLayout,
+          evidence: evidence(
+            resource,
+            element,
+            `${resource.resourceType}/${resource.name}#include:${includedLayout}`,
+          ),
+        });
+      }
+    }
+    if (localName(element.name) === "navigation") {
+      const destination = referenceName(
+        attribute(element, "startDestination"),
+        "id",
+      );
+      if (destination) {
+        navigationTargets.push({
+          resourceType: resource.resourceType,
+          resourceName: resource.name,
+          kind: "graph-start",
+          destination,
+          evidence: evidence(
+            resource,
+            element,
+            `${resource.resourceType}/${resource.name}#start:${destination}`,
+          ),
+        });
+      }
+    }
+    if (localName(element.name) === "action") {
+      const actionId = referenceName(attribute(element, "id"), "id");
+      const destination = referenceName(
+        attribute(element, "destination"),
+        "id",
+      );
+      if (destination) {
+        const sourceId = sourceIdentity(parent);
+        navigationTargets.push({
+          resourceType: resource.resourceType,
+          resourceName: resource.name,
+          kind: "navigation-action",
+          ...(sourceId ? { sourceId } : {}),
+          ...(actionId ? { actionId } : {}),
+          destination,
+          evidence: evidence(
+            resource,
+            element,
+            `${resource.resourceType}/${resource.name}#action:${actionId ?? sourceId ?? element.startLine}->${destination}`,
+          ),
+        });
+      }
+    }
+    if (localName(element.name) === "intent") {
+      const targetClass = attribute(element, "targetClass");
+      const targetPackage = attribute(element, "targetPackage");
+      const intentAction = attribute(element, "action");
+      if (targetClass || targetPackage) {
+        const sourceId = sourceIdentity(parent);
+        navigationTargets.push({
+          resourceType: resource.resourceType,
+          resourceName: resource.name,
+          kind: "intent",
+          ...(sourceId ? { sourceId } : {}),
+          ...(targetClass ? { targetClass } : {}),
+          ...(targetPackage ? { targetPackage } : {}),
+          ...(intentAction ? { intentAction } : {}),
+          evidence: evidence(
+            resource,
+            element,
+            `${resource.resourceType}/${resource.name}#intent:${targetClass ?? targetPackage ?? element.startLine}`,
+          ),
+        });
+      }
+    }
+    if (element === root && localName(element.name) === "appwidget-provider") {
+      const layoutResourceName = referenceName(
+        attribute(element, "initialLayout"),
+        "layout",
+      );
+      if (layoutResourceName) {
+        appWidgetInfos.push({
+          infoResourceName: resource.name,
+          layoutResourceName,
+          evidence: evidence(
+            resource,
+            element,
+            `${resource.resourceType}/${resource.name}#initialLayout:` +
+              layoutResourceName,
+          ),
+        });
+      }
+    }
+    element.children.forEach((child) => visit(child, element));
+  };
+  visit(root);
+  return {
+    views,
+    fragments,
+    includes,
+    navigationTargets,
+    appWidgetInfos,
+  };
+}
+function byEvidence(left, right) {
+  return `${left.evidence.path}:${left.evidence.range.startLine}:${left.evidence.anchor}`.localeCompare(
+    `${right.evidence.path}:${right.evidence.range.startLine}:${right.evidence.anchor}`,
+    "en",
+  );
+}
+export function extractAndroidViews(selected, selection, manifest) {
+  try {
+    const extractions = selection.resources.map((resource) =>
+      visitResource(selected.model.projectRoot, resource, selection),
+    );
+    const navigationTargets = extractions
+      .flatMap((item) => item.navigationTargets)
+      .sort(byEvidence);
+    const shortcutResources = new Set(
+      manifest?.components.flatMap(
+        (component) => component.shortcutResources ?? [],
+      ) ?? [],
+    );
+    const shortcutEntries = navigationTargets
+      .filter(
+        (target) =>
+          target.kind === "intent" &&
+          shortcutResources.has(target.resourceName) &&
+          target.sourceId !== undefined &&
+          target.targetClass !== undefined,
+      )
+      .map((target) => {
+        const targetClass = target.targetClass;
+        const componentName = targetClass.startsWith(".")
+          ? `${manifest?.packageName ?? target.targetPackage ?? ""}${targetClass}`
+          : targetClass.includes(".")
+            ? targetClass
+            : `${manifest?.packageName ?? target.targetPackage ?? ""}.${targetClass}`;
+        return {
+          kind: "shortcut",
+          category: "alternate",
+          componentName,
+          action: target.intentAction ?? "android.intent.action.VIEW",
+          categories: [],
+          data: {
+            shortcutId: target.sourceId,
+            ...(target.targetPackage
+              ? { targetPackage: target.targetPackage }
+              : {}),
+          },
+          evidence: target.evidence,
+        };
+      })
+      .sort((left, right) =>
+        `${left.componentName}:${left.data.shortcutId}`.localeCompare(
+          `${right.componentName}:${right.data.shortcutId}`,
+          "en",
+        ),
+      );
+    const infoByName = new Map(
+      extractions
+        .flatMap((item) => item.appWidgetInfos)
+        .map((item) => [item.infoResourceName, item]),
+    );
+    const appWidgetLayouts =
+      manifest?.components
+        .flatMap((component) => {
+          if (
+            component.kind !== "app-widget" ||
+            !component.appWidgetInfoResource
+          )
+            return [];
+          const info = infoByName.get(component.appWidgetInfoResource);
+          return info
+            ? [
+                {
+                  componentName: component.name,
+                  infoResourceName: info.infoResourceName,
+                  layoutResourceName: info.layoutResourceName,
+                  evidence: info.evidence,
+                },
+              ]
+            : [];
+        })
+        .sort((left, right) =>
+          left.componentName.localeCompare(right.componentName, "en"),
+        ) ?? [];
+    return {
+      views: extractions.flatMap((item) => item.views).sort(byEvidence),
+      fragments: extractions.flatMap((item) => item.fragments).sort(byEvidence),
+      includes: extractions.flatMap((item) => item.includes).sort(byEvidence),
+      navigationTargets,
+      shortcutEntries,
+      appWidgetLayouts,
+    };
+  } catch (error) {
+    throw hardFailure(
+      "ANDROID_XML_PARSE_FAILED",
+      "resources",
+      `Could not parse selected Android XML: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}

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

@@ -0,0 +1,175 @@
+function lineAt(source, offset) {
+  let line = 1;
+  for (let index = 0; index < offset; index += 1) {
+    if (source.charCodeAt(index) === 10) {
+      line += 1;
+    }
+  }
+  return line;
+}
+function decodeXml(value) {
+  return value.replace(
+    /&(?:#x[0-9a-fA-F]+|#[0-9]+|amp|lt|gt|quot|apos);/gu,
+    (entity) => {
+      if (entity === "&amp;") return "&";
+      if (entity === "&lt;") return "<";
+      if (entity === "&gt;") return ">";
+      if (entity === "&quot;") return '"';
+      if (entity === "&apos;") return "'";
+      const numeric = entity.startsWith("&#x")
+        ? Number.parseInt(entity.slice(3, -1), 16)
+        : Number.parseInt(entity.slice(2, -1), 10);
+      return Number.isFinite(numeric) ? String.fromCodePoint(numeric) : entity;
+    },
+  );
+}
+function tagEnd(source, start) {
+  let quote;
+  for (let index = start + 1; index < source.length; index += 1) {
+    const character = source[index];
+    if (quote) {
+      if (character === quote) quote = undefined;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === ">") {
+      return index;
+    }
+  }
+  throw new Error(`Unterminated XML tag at line ${lineAt(source, start)}`);
+}
+function parseTag(raw) {
+  let body = raw.slice(1, -1).trim();
+  const closing = body.startsWith("/");
+  if (closing) body = body.slice(1).trim();
+  const selfClosing = !closing && body.endsWith("/");
+  if (selfClosing) body = body.slice(0, -1).trim();
+  const nameMatch = /^[^\s=/>]+/u.exec(body);
+  if (!nameMatch) {
+    throw new Error(`Invalid XML tag: ${raw}`);
+  }
+  const name = nameMatch[0];
+  const attributes = {};
+  let cursor = name.length;
+  while (cursor < body.length) {
+    while (/\s/u.test(body[cursor] ?? "")) cursor += 1;
+    if (cursor >= body.length) break;
+    const attributeMatch = /^[^\s=/>]+/u.exec(body.slice(cursor));
+    if (!attributeMatch) {
+      throw new Error(`Invalid attribute in XML tag: ${raw}`);
+    }
+    const attributeName = attributeMatch[0];
+    cursor += attributeName.length;
+    while (/\s/u.test(body[cursor] ?? "")) cursor += 1;
+    if (body[cursor] !== "=") {
+      attributes[attributeName] = "";
+      continue;
+    }
+    cursor += 1;
+    while (/\s/u.test(body[cursor] ?? "")) cursor += 1;
+    const quote = body[cursor];
+    if (quote !== '"' && quote !== "'") {
+      throw new Error(`Attribute ${attributeName} must be quoted`);
+    }
+    const valueStart = cursor + 1;
+    const valueEnd = body.indexOf(quote, valueStart);
+    if (valueEnd < 0) {
+      throw new Error(`Unterminated attribute ${attributeName}`);
+    }
+    attributes[attributeName] = decodeXml(body.slice(valueStart, valueEnd));
+    cursor = valueEnd + 1;
+  }
+  return { name, attributes, closing, selfClosing };
+}
+function asReadonly(element) {
+  return {
+    ...element,
+    children: element.children.map(asReadonly),
+  };
+}
+export function parseXml(source) {
+  const roots = [];
+  const stack = [];
+  let cursor = 0;
+  while (cursor < source.length) {
+    const opening = source.indexOf("<", cursor);
+    if (opening < 0) {
+      if (stack.length > 0) {
+        stack.at(-1).text += decodeXml(source.slice(cursor));
+      }
+      break;
+    }
+    if (stack.length > 0 && opening > cursor) {
+      stack.at(-1).text += decodeXml(source.slice(cursor, opening));
+    }
+    if (source.startsWith("<!--", opening)) {
+      const end = source.indexOf("-->", opening + 4);
+      if (end < 0) throw new Error("Unterminated XML comment");
+      cursor = end + 3;
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", opening)) {
+      const end = source.indexOf("]]>", opening + 9);
+      if (end < 0) throw new Error("Unterminated CDATA section");
+      if (stack.length > 0) {
+        stack.at(-1).text += source.slice(opening + 9, end);
+      }
+      cursor = end + 3;
+      continue;
+    }
+    if (source.startsWith("<?", opening)) {
+      const end = source.indexOf("?>", opening + 2);
+      if (end < 0) throw new Error("Unterminated XML declaration");
+      cursor = end + 2;
+      continue;
+    }
+    if (source.startsWith("<!", opening)) {
+      const end = tagEnd(source, opening);
+      cursor = end + 1;
+      continue;
+    }
+    const end = tagEnd(source, opening);
+    const parsed = parseTag(source.slice(opening, end + 1));
+    const line = lineAt(source, opening);
+    if (parsed.closing) {
+      const current = stack.pop();
+      if (!current || current.name !== parsed.name) {
+        throw new Error(
+          `Unexpected closing tag ${parsed.name} at line ${line}`,
+        );
+      }
+      current.endLine = lineAt(source, end);
+    } else {
+      const element = {
+        name: parsed.name,
+        attributes: parsed.attributes,
+        children: [],
+        text: "",
+        startLine: line,
+        endLine: lineAt(source, end),
+      };
+      const parent = stack.at(-1);
+      if (parent) parent.children.push(element);
+      else roots.push(element);
+      if (!parsed.selfClosing) stack.push(element);
+    }
+    cursor = end + 1;
+  }
+  if (stack.length > 0) {
+    throw new Error(`Unclosed XML tag ${stack.at(-1).name}`);
+  }
+  if (roots.length !== 1) {
+    throw new Error(`Expected one XML root, found ${roots.length}`);
+  }
+  return asReadonly(roots[0]);
+}
+export function localName(name) {
+  return name.includes(":") ? name.slice(name.lastIndexOf(":") + 1) : name;
+}
+export function descendantElements(root) {
+  return [root, ...root.children.flatMap(descendantElements)];
+}
+export function elementText(element) {
+  return [element.text, ...element.children.map(elementText)].join("").trim();
+}