android2harmony 0.1.6 → 0.1.8

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

@@ -0,0 +1,15 @@
+export { buildAreaGraph } from "./build.js";
+export {
+  CALLBACK_ITERATION_BUDGET_EXHAUSTED,
+  CALL_DEPTH_BUDGET_EXHAUSTED,
+  CallbackFlowTraversal,
+  CallbackIterationBudgetExceededError,
+  CallDepthBudgetExceededError,
+  DEFAULT_MAX_CALLBACK_ITERATIONS,
+  DEFAULT_MAX_CALL_DEPTH,
+} from "./callback-flow.js";
+export {
+  DEFAULT_MAX_GRAPH_STATES,
+  GRAPH_STATE_BUDGET_EXHAUSTED,
+  GraphStateBudgetExceededError,
+} from "../../graph/paths.js";

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

@@ -0,0 +1,12 @@
+export {
+  NAME_TRACEABILITY_FILENAME,
+  buildNameTraceEntries,
+  buildNameTraceability,
+} from "./traceability.js";
+export {
+  componentIdentifierName,
+  controlNameCandidates,
+  interactionSymbolName,
+  resolveNameCandidates,
+  semanticIdentifierName,
+} from "./policy.js";

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/names/policy.js

@@ -0,0 +1,469 @@
+const technicalIdentifierTokens = new Set([
+  "action",
+  "api",
+  "btn",
+  "button",
+  "callback",
+  "change",
+  "click",
+  "column",
+  "composable",
+  "composer",
+  "container",
+  "control",
+  "fab",
+  "finish",
+  "finished",
+  "get",
+  "handler",
+  "ic",
+  "icon",
+  "image",
+  "img",
+  "invoke",
+  "item",
+  "iv",
+  "lambda",
+  "on",
+  "raw",
+  "row",
+  "set",
+  "shape",
+  "tv",
+  "unknown",
+  "value",
+  "view",
+]);
+const frameworkGenericNames = new Set([
+  "activity",
+  "alert dialog",
+  "basic alert dialog",
+  "basic text field",
+  "bottom sheet",
+  "bottom sheet scaffold",
+  "box",
+  "button",
+  "checkbox",
+  "column",
+  "composable",
+  "content",
+  "dialog",
+  "drawer",
+  "dropdown menu",
+  "fragment",
+  "icon",
+  "image",
+  "list item",
+  "modal bottom sheet",
+  "modal surface",
+  "navigation drawer",
+  "overlay",
+  "page",
+  "pager",
+  "popup",
+  "radio button",
+  "row",
+  "scaffold",
+  "screen",
+  "sheet",
+  "surface",
+  "switch",
+  "text",
+  "text field",
+  "toggle",
+  "top app bar",
+  "view",
+]);
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) =>
+    left.localeCompare(right, "en"),
+  );
+}
+function simpleWords(value) {
+  return value
+    .replace(/[_-]+/gu, " ")
+    .replace(/([a-z0-9])([A-Z])/gu, "$1 $2")
+    .replace(/\s+/gu, " ")
+    .trim();
+}
+function classLeaf(value) {
+  return value.replace(/^.*[./#]/u, "");
+}
+function stripComponentSuffix(value) {
+  let current = value;
+  let previous = "";
+  while (current !== previous) {
+    previous = current;
+    current = current.replace(
+      /(Activity|Fragment|Screen|Composable|Dialog|Sheet|Drawer|Overlay|Popup|Page|View|Kt|Impl)$/u,
+      "",
+    );
+  }
+  return current;
+}
+function decodeRouteSymbol(value) {
+  const marker = "#route-symbol:";
+  const markerIndex = value.lastIndexOf(marker);
+  if (markerIndex < 0) return undefined;
+  const encoded = value.slice(markerIndex + marker.length);
+  let decoded;
+  try {
+    decoded = decodeURIComponent(encoded);
+  } catch {
+    return undefined;
+  }
+  const subjects = decoded.split("\u0000").filter(Boolean);
+  for (const subject of subjects) {
+    const leaf = stripComponentSuffix(classLeaf(subject));
+    if (leaf.trim().length > 0) return simpleWords(leaf);
+  }
+  return undefined;
+}
+function containsSyntheticAnalyzerIdentity(value) {
+  return (
+    /(?:^|[^A-Za-z0-9])(?:raw|fact|evidence|area|control|action|effect|edge|call|binding|method|lambda|callback|unresolved):[A-Za-z0-9/_-]*/u.test(
+      value,
+    ) ||
+    /(?:^|[:/#@_-])(?:sha(?:1|256)[:_-]?)?[a-f0-9]{12,}(?=$|[:/#@_-])/iu.test(
+      value,
+    ) ||
+    /(?:^|[:/#@_-])[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?=$|[:/#@_-])/iu.test(
+      value,
+    )
+  );
+}
+/**
+ * Convert a declaration/route identity into a human-readable code candidate.
+ * Synthetic surface hashes and raw analyzer IDs deliberately have no fallback.
+ */
+export function componentIdentifierName(value) {
+  const routeMarker = value.lastIndexOf("#route:");
+  if (routeMarker >= 0) {
+    const routeBase = value
+      .slice(routeMarker + "#route:".length)
+      .split(/[/?]/u, 1)[0]
+      .replace(/^\{.*\}$/u, "");
+    return routeBase.trim().length > 0 &&
+      !containsSyntheticAnalyzerIdentity(routeBase)
+      ? simpleWords(routeBase)
+      : undefined;
+  }
+  const routeSymbol = decodeRouteSymbol(value);
+  if (routeSymbol && !containsSyntheticAnalyzerIdentity(routeSymbol)) {
+    return routeSymbol;
+  }
+  const inlineSurfaceMarker = "#surface:inline-detail:";
+  const inlineSurfaceIndex = value.lastIndexOf(inlineSurfaceMarker);
+  if (inlineSurfaceIndex >= 0) {
+    const receiver = value
+      .slice(inlineSurfaceIndex + inlineSurfaceMarker.length)
+      .split(":", 1)[0];
+    return receiver.trim().length > 0 &&
+      !containsSyntheticAnalyzerIdentity(receiver)
+      ? simpleWords(receiver)
+      : undefined;
+  }
+  // Builder/call-site identities are valid graph anchors, but no substring of
+  // them is a product label. Reject the whole candidate before `classLeaf`
+  // can accidentally select a Java parameter type immediately before the raw
+  // suffix (for example `OnDismissListener):raw:<hash>`).
+  if (containsSyntheticAnalyzerIdentity(value)) return undefined;
+  if (
+    value.includes("#surface:") ||
+    value.includes("#surface-call:") ||
+    value.includes("#pager-page:") ||
+    value.startsWith("@compose/unresolved-owner/")
+  )
+    return undefined;
+  const leaf = stripComponentSuffix(classLeaf(value));
+  return leaf.trim().length > 0 ? simpleWords(leaf) : undefined;
+}
+/** Clean technical prefixes/suffixes from a resource or source symbol. */
+export function semanticIdentifierName(value) {
+  const words = simpleWords(classLeaf(value));
+  const retained = words
+    .split(/\s+/u)
+    .filter(
+      (token) =>
+        token.length > 0 &&
+        !technicalIdentifierTokens.has(token.toLowerCase()) &&
+        !/^\d+$/u.test(token),
+    );
+  return retained.length > 0 ? retained.join(" ") : undefined;
+}
+/*
+ * Small, framework-independent accessibility vocabulary for conventional
+ * actionable icons. These are interaction roles, not product-domain terms;
+ * an unknown icon keeps the ordinary low-confidence identifier fallback.
+ */
+const universalIconRoleNames = {
+  arrowback: "返回",
+  back: "返回",
+  close: "关闭",
+  delete: "删除",
+  edit: "编辑",
+  menu: "菜单",
+  more: "更多",
+  morehoriz: "更多",
+  morehorizontal: "更多",
+  morevert: "更多",
+  morevertical: "更多",
+  overflow: "更多",
+  pause: "暂停",
+  play: "播放",
+  search: "搜索",
+  settings: "设置",
+  share: "分享",
+};
+export function iconResourceName(value) {
+  const fallback = semanticIdentifierName(value);
+  if (!fallback) return undefined;
+  const compact = fallback.replace(/[^A-Za-z0-9]/gu, "").toLowerCase();
+  return universalIconRoleNames[compact] ?? fallback;
+}
+/**
+ * Callback slot names can prove a small set of framework-independent user
+ * interaction roles. This mapping is intentionally limited to universal
+ * dialog/navigation verbs and never uses application-domain keywords.
+ */
+export function interactionSymbolName(value) {
+  const role = value.replace(/^.*[./#:]/u, "");
+  const compact = role.replace(/[^a-z0-9]/giu, "").toLowerCase();
+  switch (compact) {
+    case "confirm":
+    case "onconfirm":
+    case "positive":
+    case "onpositive":
+    case "onpositiveclick":
+      return "确认";
+    case "cancel":
+    case "oncancel":
+    case "negative":
+    case "onnegative":
+    case "onnegativeclick":
+      return "取消";
+    case "close":
+    case "onclose":
+    case "dismiss":
+    case "ondismiss":
+    case "ondismissrequest":
+      return "关闭";
+    case "back":
+    case "onback":
+    case "onbackpressed":
+      return "返回";
+    default:
+      return semanticIdentifierName(role);
+  }
+}
+function rejectedReason(candidate) {
+  const raw = candidate.rawValue?.trim();
+  const value = candidate.normalizedValue?.trim();
+  if (
+    candidate.kind === "code" &&
+    raw &&
+    containsSyntheticAnalyzerIdentity(raw)
+  ) {
+    return {
+      code: "NAME_CANDIDATE_RAW_ID",
+      message: "候选是分析器 raw/stable ID，不是用户可见名称。",
+    };
+  }
+  if (!raw || !value) {
+    return {
+      code: "NAME_CANDIDATE_BLANK",
+      message: "候选为空或清洗后不含产品语义。",
+    };
+  }
+  if (candidate.frameworkGeneric) {
+    return {
+      code: "NAME_CANDIDATE_FRAMEWORK_API_GENERIC",
+      message: "候选只描述框架 API/Surface 类型，不是产品名称。",
+    };
+  }
+  const lower = value.toLocaleLowerCase("en-US");
+  if (frameworkGenericNames.has(lower)) {
+    return {
+      code: "NAME_CANDIDATE_FRAMEWORK_GENERIC",
+      message: "候选是单独的框架控件或容器泛称。",
+    };
+  }
+  if (/^(?:R\.string\.|@string\/|string\/)/u.test(value)) {
+    return {
+      code: "NAME_CANDIDATE_RESOURCE_REFERENCE",
+      message: "候选是未解析的字符串资源引用，不是资源值。",
+    };
+  }
+  if (
+    candidate.kind === "code" &&
+    (/^(?:base|abstract)(?:\s|$)/iu.test(value) ||
+      /^(?:base|abstract)$/iu.test(value))
+  ) {
+    return {
+      code: "NAME_CANDIDATE_ABSTRACT_BASE",
+      message: "候选来自抽象 Base/模板声明。",
+    };
+  }
+  if (
+    candidate.kind === "code" &&
+    (/^(?:raw|hash|unknown|unnamed)(?:\s|$)/iu.test(value) ||
+      /^@compose\/unresolved-owner\//u.test(raw) ||
+      containsSyntheticAnalyzerIdentity(raw))
+  ) {
+    return {
+      code: "NAME_CANDIDATE_RAW_ID",
+      message: "候选是分析器 raw/stable ID，不是用户可见名称。",
+    };
+  }
+  if (
+    candidate.kind === "code" &&
+    (/^\d{6,}$/u.test(value) ||
+      /^(?:sha(?:1|256)[:_-]?)?[a-f0-9]{12,}$/iu.test(value) ||
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(
+        value,
+      ) ||
+      /@[0-9a-f]{8,}$/iu.test(raw))
+  ) {
+    return {
+      code: "NAME_CANDIDATE_HASH",
+      message: "候选是 hash、UUID 或纯数字身份。",
+    };
+  }
+  if (
+    candidate.kind === "code" &&
+    (/^\{[^{}]+\}$/u.test(value) || /^<[^<>]+>$/u.test(value))
+  ) {
+    return {
+      code: "NAME_CANDIDATE_PLACEHOLDER",
+      message: "候选是路由/源码占位符。",
+    };
+  }
+  return undefined;
+}
+export function resolveNameCandidates(candidates) {
+  let selected = false;
+  const attempts = candidates.map((candidate) => {
+    if (candidate.rawValue === undefined) {
+      return { ...candidate, outcome: "absent" };
+    }
+    const rejection = rejectedReason(candidate);
+    if (rejection) {
+      return {
+        ...candidate,
+        outcome: "rejected",
+        reasonCode: rejection.code,
+        reason: rejection.message,
+      };
+    }
+    if (selected) {
+      return {
+        ...candidate,
+        outcome: "skipped",
+        reasonCode: "NAME_CANDIDATE_LOWER_PRIORITY",
+        reason: "更高优先级的名称候选已经命中。",
+      };
+    }
+    selected = true;
+    return { ...candidate, outcome: "selected" };
+  });
+  const chosen = attempts.find((attempt) => attempt.outcome === "selected");
+  return {
+    ...(chosen?.normalizedValue
+      ? {
+          value: chosen.normalizedValue,
+          confidence: chosen.confidence,
+          selectedStrategy: chosen.strategy,
+        }
+      : {}),
+    supportRefs: chosen ? uniqueSorted(chosen.supportRefs) : [],
+    attempts,
+  };
+}
+export function literalNameCandidate(
+  strategy,
+  value,
+  supportRefs,
+  confidence,
+  options = {},
+) {
+  return {
+    strategy,
+    kind: "literal",
+    ...(value === undefined
+      ? {}
+      : { rawValue: value, normalizedValue: value.trim() }),
+    confidence,
+    supportRefs: uniqueSorted(supportRefs),
+    ...(options.frameworkGeneric ? { frameworkGeneric: true } : {}),
+  };
+}
+export function codeNameCandidate(strategy, value, supportRefs, normalizer) {
+  return {
+    strategy,
+    kind: "code",
+    ...(value === undefined
+      ? {}
+      : {
+          rawValue: value,
+          normalizedValue: normalizer(value),
+        }),
+    confidence: "low",
+    supportRefs: uniqueSorted(supportRefs),
+  };
+}
+export function structuralNameCandidate(value, supportRefs) {
+  return {
+    strategy: "dynamic-list-item",
+    kind: "structural",
+    ...(value === undefined
+      ? {}
+      : { rawValue: value, normalizedValue: value.trim() }),
+    confidence: "medium",
+    supportRefs: uniqueSorted(supportRefs),
+  };
+}
+export function controlNameCandidates(
+  data,
+  factRef,
+  confidence,
+  repeatedItemName,
+  repeatedItemSupportRefs = [],
+) {
+  return [
+    literalNameCandidate(
+      "visible-text",
+      data.visibleText,
+      [factRef],
+      confidence,
+    ),
+    literalNameCandidate(
+      "content-description",
+      data.contentDescription,
+      [factRef],
+      confidence,
+    ),
+    literalNameCandidate(
+      "associated-label",
+      data.associatedLabel,
+      [factRef],
+      confidence,
+    ),
+    structuralNameCandidate(repeatedItemName, [
+      factRef,
+      ...repeatedItemSupportRefs,
+    ]),
+    codeNameCandidate(
+      "resource-id",
+      data.resourceId,
+      [factRef],
+      semanticIdentifierName,
+    ),
+    codeNameCandidate("symbol", data.symbol, [factRef], interactionSymbolName),
+    codeNameCandidate(
+      "icon-resource",
+      data.iconResource,
+      [factRef],
+      iconResourceName,
+    ),
+  ];
+}