android2harmony 0.1.7 → 0.1.8

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

@@ -0,0 +1,474 @@
+export const DEFAULT_MAX_GRAPH_STATES = 50_000;
+export const GRAPH_STATE_BUDGET_EXHAUSTED = "GRAPH_STATE_BUDGET_EXHAUSTED";
+export class GraphStateBudgetExceededError extends Error {
+  code = GRAPH_STATE_BUDGET_EXHAUSTED;
+  stage = "paths";
+  maxGraphStates;
+  statesUsed;
+  attemptedState;
+  constructor(maxGraphStates, statesUsed) {
+    super(
+      `Area path search exceeded the global ${maxGraphStates}-state budget.`,
+    );
+    this.name = "GraphStateBudgetExceededError";
+    this.maxGraphStates = maxGraphStates;
+    this.statesUsed = statesUsed;
+    this.attemptedState = statesUsed + 1;
+  }
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) =>
+    left.localeCompare(right, "en"),
+  );
+}
+function stripOuterParentheses(value) {
+  let result = value.trim();
+  while (result.startsWith("(") && result.endsWith(")")) {
+    let depth = 0;
+    let wrapsWholeExpression = true;
+    for (let index = 0; index < result.length; index += 1) {
+      const character = result[index];
+      if (character === "(") depth += 1;
+      if (character === ")") depth -= 1;
+      if (depth === 0 && index < result.length - 1) {
+        wrapsWholeExpression = false;
+        break;
+      }
+      if (depth < 0) {
+        wrapsWholeExpression = false;
+        break;
+      }
+    }
+    if (!wrapsWholeExpression || depth !== 0) break;
+    result = result.slice(1, -1).trim();
+  }
+  return result;
+}
+function conditionConstraint(expression) {
+  const compact = stripOuterParentheses(expression).replace(/\s+/gu, "");
+  if (compact.startsWith("!(") && compact.endsWith(")")) {
+    const inner = conditionConstraint(compact.slice(2, -1));
+    if (inner.relation === "equals") {
+      return { ...inner, relation: "not-equals" };
+    }
+    if (inner.relation === "not-equals") {
+      return { ...inner, relation: "equals" };
+    }
+    if (inner.relation === "truthy") {
+      return { ...inner, relation: "not" };
+    }
+    if (inner.relation === "not") {
+      return { ...inner, relation: "truthy" };
+    }
+    return {
+      subject: compact.slice(2, -1),
+      relation: "not",
+      values: [],
+    };
+  }
+  if (compact.startsWith("!") && !compact.startsWith("!=")) {
+    return {
+      subject: stripOuterParentheses(compact.slice(1)),
+      relation: "not",
+      values: [],
+    };
+  }
+  const membership = /^(.+?)in\((.*)\)$/u.exec(compact);
+  if (membership) {
+    return {
+      subject: stripOuterParentheses(membership[1]),
+      relation: "member",
+      values: membership[2]
+        .split(",")
+        .map((value) => stripOuterParentheses(value))
+        .filter((value) => value.length > 0)
+        .sort((left, right) => left.localeCompare(right, "en")),
+    };
+  }
+  const comparison = /^(.+?)(===|!==|==|!=)(.+)$/u.exec(compact);
+  if (comparison) {
+    const left = stripOuterParentheses(comparison[1]);
+    const right = stripOuterParentheses(comparison[3]);
+    return {
+      subject: left,
+      relation: comparison[2].includes("!") ? "not-equals" : "equals",
+      values: [right],
+    };
+  }
+  const assignment = /^(.+?)=(?!=)(.+)$/u.exec(compact);
+  if (assignment && !/[!<>=]$/u.test(assignment[1])) {
+    return {
+      subject: stripOuterParentheses(assignment[1]),
+      relation: "equals",
+      values: [stripOuterParentheses(assignment[2])],
+    };
+  }
+  return {
+    subject: compact,
+    relation: "truthy",
+    values: [],
+  };
+}
+function constraintsContradict(left, right) {
+  if (left.subject !== right.subject) return false;
+  if (
+    (left.relation === "truthy" && right.relation === "not") ||
+    (left.relation === "not" && right.relation === "truthy")
+  )
+    return true;
+  if (left.relation === "equals" && right.relation === "equals") {
+    return left.values[0] !== right.values[0];
+  }
+  if (left.relation === "member" && right.relation === "member") {
+    const rightValues = new Set(right.values);
+    return !left.values.some((value) => rightValues.has(value));
+  }
+  if (left.relation === "equals" && right.relation === "member") {
+    return !right.values.includes(left.values[0]);
+  }
+  if (left.relation === "member" && right.relation === "equals") {
+    return !left.values.includes(right.values[0]);
+  }
+  if (left.relation === "equals" && right.relation === "not-equals")
+    return left.values[0] === right.values[0];
+  if (left.relation === "not-equals" && right.relation === "equals")
+    return left.values[0] === right.values[0];
+  return false;
+}
+export function conditionsAreCompatible(conditionRefs, expressions) {
+  if (!expressions) return true;
+  const constraints = uniqueSorted(conditionRefs).flatMap((ref) => {
+    const expression = expressions.get(ref)?.trim();
+    return expression ? [conditionConstraint(expression)] : [];
+  });
+  for (let left = 0; left < constraints.length; left += 1) {
+    for (let right = left + 1; right < constraints.length; right += 1) {
+      if (constraintsContradict(constraints[left], constraints[right])) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function deterministicActivationSubject(conditionRef, expressions) {
+  const expression = expressions?.get(conditionRef)?.trim();
+  if (!expression) return undefined;
+  const constraint = conditionConstraint(expression);
+  if (
+    constraint.relation === "equals" ||
+    constraint.relation === "truthy" ||
+    constraint.relation === "not" ||
+    (constraint.relation === "member" && constraint.values.length === 1)
+  )
+    return constraint.subject;
+  return undefined;
+}
+/**
+ * Entering a conditioned target Area establishes that Area's deterministic
+ * activation state. Only those post-state dimensions replace prior routing
+ * constraints. Edge conditions themselves remain guards and can never erase
+ * a conflict merely because they mention the same subject.
+ */
+function applyTargetActivation(
+  routingConditions,
+  targetConditions,
+  expressions,
+) {
+  const replacedSubjects = new Set(
+    targetConditions.flatMap((conditionRef) => {
+      const subject = deterministicActivationSubject(conditionRef, expressions);
+      return subject ? [subject] : [];
+    }),
+  );
+  const retained =
+    replacedSubjects.size === 0
+      ? routingConditions
+      : routingConditions.filter((conditionRef) => {
+          const expression = expressions?.get(conditionRef)?.trim();
+          return (
+            !expression ||
+            !replacedSubjects.has(conditionConstraint(expression).subject)
+          );
+        });
+  return uniqueSorted([...retained, ...targetConditions]);
+}
+function edgeConditionChoices(edge) {
+  const alternatives = edge.conditionAlternatives ?? [];
+  if (alternatives.length === 0) return [uniqueSorted(edge.conditions)];
+  const alternativeRefs = new Set(
+    alternatives.flatMap((alternative) => alternative.conditionRefs),
+  );
+  const common = edge.conditions.filter((ref) => !alternativeRefs.has(ref));
+  return alternatives.map((alternative) =>
+    uniqueSorted([...common, ...alternative.conditionRefs]),
+  );
+}
+function stepFrom(edge) {
+  if ("status" in edge.target || edge.target.kind !== "area") {
+    return undefined;
+  }
+  return {
+    edgeRef: edge.id,
+    sourceAreaRef: edge.sourceAreaRef,
+    controlRef: edge.controlRef,
+    actionRef: edge.actionRef,
+    targetAreaRef: edge.target.ref,
+  };
+}
+function candidateKey(candidate) {
+  return [
+    candidate.entry.id,
+    candidate.steps.map((step) => step.edgeRef).join("\u0000"),
+  ].join("\u0001");
+}
+function startupRank(entry) {
+  switch (entry.startupRole) {
+    case "default":
+      return 0;
+    case "conditional":
+      return 1;
+    case "override":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function compareCandidateCost(left, right) {
+  return (
+    startupRank(left.entry) - startupRank(right.entry) ||
+    left.steps.length - right.steps.length ||
+    left.preconditions.length - right.preconditions.length
+  );
+}
+function compareCandidate(left, right) {
+  return (
+    compareCandidateCost(left, right) ||
+    candidateKey(left).localeCompare(candidateKey(right), "en")
+  );
+}
+function retainState(budget, candidate) {
+  if (budget.used >= budget.limit) {
+    throw new GraphStateBudgetExceededError(budget.limit, budget.used);
+  }
+  budget.used += 1;
+  return candidate;
+}
+function shortestCandidates(
+  areas,
+  conditionsByArea,
+  edges,
+  entries,
+  budget,
+  conditionExpressions,
+) {
+  const bySource = new Map();
+  for (const edge of edges) {
+    const step = stepFrom(edge);
+    if (!step) {
+      continue;
+    }
+    const outgoing = bySource.get(edge.sourceAreaRef) ?? [];
+    outgoing.push(edge);
+    bySource.set(edge.sourceAreaRef, outgoing);
+  }
+  for (const outgoing of bySource.values()) {
+    outgoing.sort((left, right) => left.id.localeCompare(right.id, "en"));
+  }
+  const queue = entries.flatMap((entry) =>
+    [...entry.rootAreaRefs]
+      .sort((left, right) => left.localeCompare(right, "en"))
+      .flatMap((area) => {
+        const routingConditions = uniqueSorted([
+          ...entry.conditions,
+          ...(conditionsByArea.get(area) ?? []),
+        ]);
+        if (!conditionsAreCompatible(routingConditions, conditionExpressions))
+          return [];
+        return [
+          retainState(budget, {
+            entry,
+            area,
+            preconditions: uniqueSorted(
+              entry.preconditions ?? entry.conditions,
+            ),
+            routingConditions,
+            steps: [],
+            visited: new Set([area]),
+          }),
+        ];
+      }),
+  );
+  const result = new Map();
+  const best = new Map();
+  let cursor = 0;
+  while (cursor < queue.length) {
+    const candidate = queue[cursor++];
+    const known = best.get(candidate.area);
+    const comparison =
+      known === undefined ? -1 : compareCandidateCost(candidate, known);
+    if (known === undefined || comparison < 0) {
+      best.set(candidate.area, candidate);
+      result.set(candidate.area, [candidate]);
+    } else if (comparison === 0) {
+      const candidates = result.get(candidate.area) ?? [];
+      if (
+        !candidates.some(
+          (item) => candidateKey(item) === candidateKey(candidate),
+        )
+      ) {
+        candidates.push(candidate);
+        result.set(candidate.area, candidates);
+      }
+    } else {
+      continue;
+    }
+    for (const edge of bySource.get(candidate.area) ?? []) {
+      const step = stepFrom(edge);
+      if (!step || candidate.visited.has(step.targetAreaRef)) {
+        continue;
+      }
+      for (const edgeConditions of edgeConditionChoices(edge)) {
+        const guardedConditions = uniqueSorted([
+          ...candidate.routingConditions,
+          ...edgeConditions,
+          ...edge.preconditions,
+        ]);
+        if (!conditionsAreCompatible(guardedConditions, conditionExpressions))
+          continue;
+        const routingConditions = applyTargetActivation(
+          guardedConditions,
+          conditionsByArea.get(step.targetAreaRef) ?? [],
+          conditionExpressions,
+        );
+        if (!conditionsAreCompatible(routingConditions, conditionExpressions))
+          continue;
+        const next = {
+          entry: candidate.entry,
+          area: step.targetAreaRef,
+          preconditions: uniqueSorted([
+            ...candidate.preconditions,
+            ...edge.preconditions,
+          ]),
+          routingConditions,
+          steps: [...candidate.steps, step],
+          visited: new Set([...candidate.visited, step.targetAreaRef]),
+        };
+        const knownTarget = best.get(step.targetAreaRef);
+        if (
+          knownTarget !== undefined &&
+          compareCandidateCost(next, knownTarget) > 0
+        )
+          continue;
+        queue.push(retainState(budget, next));
+      }
+    }
+  }
+  for (const area of areas) {
+    const candidates = result.get(area);
+    candidates?.sort(compareCandidate);
+  }
+  return result;
+}
+/**
+ * Compute path semantics without inventing prose or IDs. Normal launcher roots
+ * are solved independently from alternate roots, so an alternate deep link can
+ * never replace a canonical launcher path.
+ */
+export function computePaths(graph, options = {}) {
+  const areaIds = graph.areas.map((area) => area.id);
+  const conditionsByArea = new Map(
+    graph.areas.map((area) => [area.id, area.conditions]),
+  );
+  const maxGraphStates = options.maxGraphStates ?? DEFAULT_MAX_GRAPH_STATES;
+  if (!Number.isSafeInteger(maxGraphStates) || maxGraphStates <= 0) {
+    throw new RangeError(
+      `maxGraphStates must be a positive safe integer, got ${maxGraphStates}.`,
+    );
+  }
+  const budget = {
+    limit: maxGraphStates,
+    used: 0,
+  };
+  const byEntryId = (left, right) => left.id.localeCompare(right.id, "en");
+  const normalEntries = graph.entryPoints
+    .filter((entry) => entry.category === "normal")
+    .sort(byEntryId);
+  const alternateEntries = graph.entryPoints
+    .filter((entry) => entry.category === "alternate")
+    .sort(byEntryId);
+  const normal = shortestCandidates(
+    areaIds,
+    conditionsByArea,
+    graph.edges,
+    normalEntries,
+    budget,
+    options.conditionExpressions,
+  );
+  // Preserve the shortest route from every alternate root independently.
+  // A direct deep link must not erase a widget -> detail route merely because
+  // both are alternate ways to enter the app. All searches share one budget.
+  const alternateByRoot = alternateEntries.flatMap((entry) =>
+    [...entry.rootAreaRefs]
+      .sort((left, right) => left.localeCompare(right, "en"))
+      .map((rootAreaRef) =>
+        shortestCandidates(
+          areaIds,
+          conditionsByArea,
+          graph.edges,
+          [{ ...entry, rootAreaRefs: [rootAreaRef] }],
+          budget,
+          options.conditionExpressions,
+        ),
+      ),
+  );
+  const paths = [];
+  for (const area of areaIds) {
+    const normalCandidates = normal.get(area) ?? [];
+    if (normalCandidates.length === 0) {
+      paths.push({
+        kind: "unreachable",
+        reachability: "unreachable",
+        targetAreaRef: area,
+        preconditions: [],
+        steps: [],
+      });
+    } else {
+      normalCandidates.forEach((candidate, index) => {
+        paths.push({
+          kind: index === 0 ? "canonical" : "equivalent",
+          reachability:
+            candidate.preconditions.length > 0
+              ? "conditional"
+              : "unconditional",
+          targetAreaRef: area,
+          rootEntryRef: candidate.entry.id,
+          preconditions: candidate.preconditions,
+          steps: candidate.steps,
+        });
+      });
+    }
+    const alternateCandidates = alternateByRoot
+      .flatMap((byArea) => byArea.get(area) ?? [])
+      .sort(compareCandidate);
+    for (const candidate of alternateCandidates) {
+      paths.push({
+        kind: "alternate",
+        reachability:
+          candidate.preconditions.length > 0 ? "conditional" : "unconditional",
+        targetAreaRef: area,
+        rootEntryRef: candidate.entry.id,
+        preconditions: candidate.preconditions,
+        steps: candidate.steps,
+      });
+    }
+  }
+  return paths;
+}
+export function pathSignature(path) {
+  return JSON.stringify([
+    path.kind,
+    path.targetAreaRef,
+    path.rootEntryRef ?? null,
+    path.steps.map((step) => step.edgeRef),
+  ]);
+}

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

@@ -0,0 +1,15 @@
+export {
+  JVM_RAW_PROTOCOL,
+  JVM_RAW_SCHEMA_VERSION,
+  jvmKnownEventKinds,
+  jvmProtocolErrorCodes,
+  parseJvmNdjson,
+  readJvmNdjsonFile,
+} from "./protocol.js";
+export {
+  RAW_JVM_FILE_NAME,
+  buildJvmAnalyzer,
+  jvmLintTask,
+  jvmRunnerErrorCodes,
+  runJvmAnalysis,
+} from "./runner.js";