android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/validation/req-model.js

@@ -0,0 +1,580 @@
+function add(issues, code, path, message) {
+  issues.push({ code, path, message });
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) =>
+    left.localeCompare(right, "en"),
+  );
+}
+function graphTargetKey(target) {
+  return "status" in target
+    ? `unresolved:${target.unresolvedRef}`
+    : `${target.kind}:${target.ref}`;
+}
+function reqBranchTargetKey(target) {
+  return "status" in target
+    ? `unresolved:${target.unresolvedRef}`
+    : `${target.kind}:${target.ref}`;
+}
+function validateExternalTarget(target, path, graph, issues) {
+  const endpoint = graph.externalEndpoints.find(
+    (candidate) => candidate.id === target.ref,
+  );
+  if (!endpoint) {
+    add(
+      issues,
+      "REQ_FEATURE_EXTERNAL_TARGET_MISSING",
+      `${path}/ref`,
+      `Unknown external endpoint ${target.ref}`,
+    );
+    return;
+  }
+  for (const field of ["presentation", "intentAction", "mimeType", "uri"]) {
+    if (
+      endpoint[field] !== undefined &&
+      JSON.stringify(target[field]) !== JSON.stringify(endpoint[field])
+    ) {
+      add(
+        issues,
+        "REQ_FEATURE_EXTERNAL_METADATA_MISMATCH",
+        `${path}/${field}`,
+        `Feature target must preserve endpoint ${field}`,
+      );
+    }
+  }
+}
+function graphConditionAlternatives(edges) {
+  return uniqueSorted(
+    edges.flatMap((edge) => {
+      const alternatives =
+        edge.conditionAlternatives && edge.conditionAlternatives.length > 0
+          ? edge.conditionAlternatives
+          : [{ conditionRefs: edge.conditions }];
+      return alternatives.map((alternative) =>
+        uniqueSorted(alternative.conditionRefs).join("\u0000"),
+      );
+    }),
+  );
+}
+function interactionViews(feature) {
+  if (feature.interactions !== undefined) return feature.interactions;
+  return [
+    {
+      id: feature.id,
+      trigger: feature.trigger,
+      conditions: feature.conditions,
+      effects: feature.effects,
+      ...(feature.target === undefined ? {} : { target: feature.target }),
+      unresolvedRefs: feature.unresolvedRefs,
+    },
+  ];
+}
+function validateInteractionSemantics(
+  interaction,
+  action,
+  interactionPath,
+  feature,
+  graph,
+  graphAreaById,
+  unresolvedIds,
+  issues,
+) {
+  if (interaction.trigger !== action.trigger) {
+    add(
+      issues,
+      "REQ_INTERACTION_TRIGGER_MISMATCH",
+      `${interactionPath}/trigger`,
+      "Interaction trigger differs from its Graph Action",
+    );
+  }
+  const graphEffects = action.effectRefs
+    .map((effectRef) => graph.effects.find((effect) => effect.id === effectRef))
+    .filter((effect) => effect !== undefined);
+  if (graphEffects.length !== interaction.effects.length) {
+    add(
+      issues,
+      "REQ_FEATURE_EFFECT_SET_MISMATCH",
+      `${interactionPath}/effects`,
+      "Interaction must preserve every Effect owned by its Action",
+    );
+  } else {
+    graphEffects.forEach((graphEffect, effectIndex) => {
+      const reqEffect = interaction.effects[effectIndex];
+      if (reqEffect.kind !== undefined && reqEffect.kind !== graphEffect.kind) {
+        add(
+          issues,
+          "REQ_FEATURE_EFFECT_KIND_MISMATCH",
+          `${interactionPath}/effects/${effectIndex}/kind`,
+          "Interaction Effect kind differs from Area Graph",
+        );
+      }
+      for (const field of ["stateKey", "value"]) {
+        if (
+          graphEffect[field] !== undefined &&
+          JSON.stringify(reqEffect[field]) !==
+            JSON.stringify(graphEffect[field])
+        ) {
+          add(
+            issues,
+            "REQ_FEATURE_EFFECT_DATA_MISMATCH",
+            `${interactionPath}/effects/${effectIndex}/${field}`,
+            `Interaction Effect must preserve Graph ${field}`,
+          );
+        }
+      }
+    });
+  }
+  const requiredConditionRefs = uniqueSorted([
+    ...action.preconditionRefs,
+    ...((action.preconditionAlternatives?.length ?? 0) > 1 &&
+    action.preconditionAlternatives?.every(
+      (alternative) => alternative.conditionRefs.length > 0,
+    )
+      ? action.preconditionAlternatives.flatMap(
+          (alternative) => alternative.conditionRefs,
+        )
+      : []),
+    ...graph.edges
+      .filter((edge) => edge.actionRef === action.id)
+      .flatMap((edge) => edge.preconditions),
+  ]);
+  const projectedConditionRefs = new Set(
+    interaction.conditions.flatMap((condition) => condition.supportRefs),
+  );
+  if (requiredConditionRefs.some((ref) => !projectedConditionRefs.has(ref))) {
+    add(
+      issues,
+      "REQ_INTERACTION_CONDITION_SET_MISMATCH",
+      `${interactionPath}/conditions`,
+      "Interaction must preserve every Action precondition",
+    );
+  }
+  const target = interaction.target;
+  if (target && !("status" in target) && target.kind === "external") {
+    validateExternalTarget(target, `${interactionPath}/target`, graph, issues);
+  }
+  if (
+    target &&
+    !("status" in target) &&
+    target.kind === "conditional-area-set"
+  ) {
+    const expectedRefs = [
+      ...new Set(
+        graph.edges.flatMap((edge) =>
+          edge.actionRef === action.id &&
+          !("status" in edge.target) &&
+          edge.target.kind === "area"
+            ? [edge.target.ref]
+            : [],
+        ),
+      ),
+    ].sort();
+    const actualRefs = [...target.refs].sort();
+    const branchRefs = (target.branches ?? [])
+      .map((branch) => branch.ref)
+      .sort();
+    if (
+      JSON.stringify(actualRefs) !== JSON.stringify(expectedRefs) ||
+      JSON.stringify(branchRefs) !== JSON.stringify(expectedRefs)
+    ) {
+      add(
+        issues,
+        "REQ_FEATURE_CONDITIONAL_BRANCH_MISMATCH",
+        `${interactionPath}/target/branches`,
+        "Conditional target must preserve every Graph target branch",
+      );
+    }
+  }
+  if (
+    target &&
+    !("status" in target) &&
+    target.kind === "alternative-target-set"
+  ) {
+    const actionEdges = graph.edges.filter(
+      (edge) => edge.actionRef === action.id,
+    );
+    const expectedKeys = uniqueSorted(
+      actionEdges.map((edge) => graphTargetKey(edge.target)),
+    );
+    const actualKeys = target.branches.map((branch) =>
+      reqBranchTargetKey(branch.target),
+    );
+    if (
+      new Set(actualKeys).size !== actualKeys.length ||
+      JSON.stringify([...actualKeys].sort()) !== JSON.stringify(expectedKeys)
+    ) {
+      add(
+        issues,
+        "REQ_FEATURE_ALTERNATIVE_TARGET_MISMATCH",
+        `${interactionPath}/target/branches`,
+        "Alternative target must preserve every Graph target branch",
+      );
+    }
+    target.branches.forEach((branch, branchIndex) => {
+      const branchPath = `${interactionPath}/target/branches/${branchIndex}`;
+      const key = reqBranchTargetKey(branch.target);
+      const matchingEdges = actionEdges.filter(
+        (edge) => graphTargetKey(edge.target) === key,
+      );
+      if ("status" in branch.target) {
+        if (!unresolvedIds.has(branch.target.unresolvedRef)) {
+          add(
+            issues,
+            "REQ_FEATURE_TARGET_UNRESOLVED_MISSING",
+            `${branchPath}/target/unresolvedRef`,
+            `Unknown unresolved item ${branch.target.unresolvedRef}`,
+          );
+        }
+        if (
+          !interaction.unresolvedRefs.includes(branch.target.unresolvedRef) ||
+          !feature.unresolvedRefs.includes(branch.target.unresolvedRef)
+        ) {
+          add(
+            issues,
+            "REQ_FEATURE_TARGET_UNRESOLVED_NOT_LISTED",
+            `${interactionPath}/unresolvedRefs`,
+            "Interaction and Feature unresolvedRefs must include every " +
+              "unresolved target branch",
+          );
+        }
+      } else if (branch.target.kind === "area") {
+        if (!graphAreaById.has(branch.target.ref)) {
+          add(
+            issues,
+            "REQ_FEATURE_AREA_TARGET_MISSING",
+            `${branchPath}/target/ref`,
+            `Unknown Area ${branch.target.ref}`,
+          );
+        }
+      } else {
+        validateExternalTarget(
+          branch.target,
+          `${branchPath}/target`,
+          graph,
+          issues,
+        );
+      }
+      const expectedAlternatives = graphConditionAlternatives(matchingEdges);
+      const actualAlternatives = uniqueSorted(
+        branch.conditionAlternatives.map((alternative) =>
+          uniqueSorted(
+            alternative.conditions.flatMap(
+              (condition) => condition.supportRefs,
+            ),
+          ).join("\u0000"),
+        ),
+      );
+      if (
+        JSON.stringify(actualAlternatives) !==
+        JSON.stringify(expectedAlternatives)
+      ) {
+        add(
+          issues,
+          "REQ_FEATURE_ALTERNATIVE_CONDITION_MISMATCH",
+          `${branchPath}/conditionAlternatives`,
+          "Alternative target must preserve every Graph condition branch",
+        );
+      }
+      const expectedSupportRefs = uniqueSorted(
+        matchingEdges.flatMap((edge) => edge.sourceFactRefs),
+      );
+      if (
+        JSON.stringify(uniqueSorted(branch.supportRefs)) !==
+        JSON.stringify(expectedSupportRefs)
+      ) {
+        add(
+          issues,
+          "REQ_FEATURE_ALTERNATIVE_SUPPORT_MISMATCH",
+          `${branchPath}/supportRefs`,
+          "Alternative target must preserve Graph branch support",
+        );
+      }
+    });
+  }
+  interaction.unresolvedRefs.forEach((ref) => {
+    if (!unresolvedIds.has(ref)) {
+      add(
+        issues,
+        "REQ_UNRESOLVED_REF_MISSING",
+        `${interactionPath}/unresolvedRefs`,
+        `Unknown unresolved item ${ref}`,
+      );
+    }
+    if (!feature.unresolvedRefs.includes(ref)) {
+      add(
+        issues,
+        "REQ_INTERACTION_UNRESOLVED_NOT_LISTED",
+        `${interactionPath}/unresolvedRefs`,
+        "Feature unresolvedRefs must include every Interaction unresolved ref",
+      );
+    }
+  });
+}
+export function validateReqModel(req, graph, source) {
+  const issues = [];
+  if (
+    req.caseId !== graph.caseId ||
+    JSON.stringify(req.analysisContext) !==
+      JSON.stringify(graph.analysisContext)
+  ) {
+    add(
+      issues,
+      "REQ_CONTEXT_MISMATCH",
+      "/analysisContext",
+      "req-model and area-graph must use the same analysis context",
+    );
+  }
+  const graphAreaById = new Map(graph.areas.map((area) => [area.id, area]));
+  const controlById = new Map(
+    graph.controls.map((control) => [control.id, control]),
+  );
+  const pathById = new Map(graph.paths.map((path) => [path.id, path]));
+  const unresolvedIds = new Set(graph.unresolved.map((item) => item.id));
+  const reqIds = new Set();
+  req.areas.forEach((area, areaIndex) => {
+    const base = `/areas/${areaIndex}`;
+    if (reqIds.has(area.id)) {
+      add(issues, "REQ_ID_DUPLICATE", `${base}/id`, area.id);
+    }
+    reqIds.add(area.id);
+    const graphArea = graphAreaById.get(area.areaRef);
+    if (!graphArea) {
+      add(
+        issues,
+        "REQ_AREA_REF_MISSING",
+        `${base}/areaRef`,
+        `Unknown Area ${area.areaRef}`,
+      );
+    }
+    if (
+      area.canonicalPath.status === "resolved" ||
+      area.canonicalPath.status === "unreachable"
+    ) {
+      const path = pathById.get(area.canonicalPath.pathRef);
+      if (!path || path.targetAreaRef !== area.areaRef) {
+        add(
+          issues,
+          "REQ_PATH_REF_INVALID",
+          `${base}/canonicalPath/pathRef`,
+          `Canonical path does not target ${area.areaRef}`,
+        );
+      } else if (area.canonicalPath.reachability !== path.reachability) {
+        add(
+          issues,
+          "REQ_PATH_REACHABILITY_MISMATCH",
+          `${base}/canonicalPath/reachability`,
+          `Expected path reachability ${path.reachability}`,
+        );
+      }
+    } else if (!unresolvedIds.has(area.canonicalPath.unresolvedRef)) {
+      add(
+        issues,
+        "REQ_PATH_UNRESOLVED_MISSING",
+        `${base}/canonicalPath`,
+        `Unknown unresolved ${area.canonicalPath.unresolvedRef}`,
+      );
+    }
+    area.features.forEach((feature, featureIndex) => {
+      const featurePath = `${base}/features/${featureIndex}`;
+      if (reqIds.has(feature.id)) {
+        add(issues, "REQ_ID_DUPLICATE", `${featurePath}/id`, feature.id);
+      }
+      reqIds.add(feature.id);
+      const control = controlById.get(feature.controlRef);
+      const controlInArea =
+        graphArea !== undefined &&
+        control !== undefined &&
+        control.areaRef === area.areaRef &&
+        graphArea.controlRefs.includes(control.id);
+      if (!controlInArea) {
+        add(
+          issues,
+          "REQ_FEATURE_OWNER_CHAIN_INVALID",
+          featurePath,
+          "Feature does not preserve Area→Control ownership",
+        );
+      }
+      if (control?.enabled !== undefined) {
+        const enabledMatches =
+          feature.enabled?.status === control.enabled.status &&
+          (control.enabled.status === "resolved"
+            ? feature.enabled?.status === "resolved" &&
+              feature.enabled.value === control.enabled.value &&
+              feature.enabled.confidence === control.enabled.confidence &&
+              JSON.stringify(feature.enabled.supportRefs) ===
+                JSON.stringify(control.enabled.supportRefs)
+            : feature.enabled?.status === "unresolved" &&
+              feature.enabled.unresolvedRef === control.enabled.unresolvedRef);
+        if (!enabledMatches) {
+          add(
+            issues,
+            "REQ_FEATURE_ENABLED_MISMATCH",
+            `${featurePath}/enabled`,
+            "Feature must preserve its Control's static enabled value",
+          );
+        }
+      }
+      const interactions = interactionViews(feature);
+      if (feature.interactions !== undefined) {
+        if (feature.interactions.length === 0) {
+          add(
+            issues,
+            "REQ_FEATURE_INTERACTIONS_EMPTY",
+            `${featurePath}/interactions`,
+            "A Control-backed Feature must contain at least one Interaction",
+          );
+        }
+        const actualActionRefs = feature.interactions.map(
+          (interaction) => interaction.actionRef,
+        );
+        const expectedActionRefs = controlInArea ? control.actionRefs : [];
+        if (
+          new Set(actualActionRefs).size !== actualActionRefs.length ||
+          JSON.stringify(actualActionRefs) !==
+            JSON.stringify(expectedActionRefs)
+        ) {
+          add(
+            issues,
+            "REQ_FEATURE_INTERACTION_SET_MISMATCH",
+            `${featurePath}/interactions`,
+            "Feature must preserve every Control Action exactly once and in " +
+              "stable order",
+          );
+        }
+      }
+      interactions.forEach((interaction, interactionIndex) => {
+        const interactionPath =
+          feature.interactions === undefined
+            ? featurePath
+            : `${featurePath}/interactions/${interactionIndex}`;
+        if (feature.interactions !== undefined) {
+          if (reqIds.has(interaction.id)) {
+            add(
+              issues,
+              "REQ_ID_DUPLICATE",
+              `${interactionPath}/id`,
+              interaction.id,
+            );
+          }
+          reqIds.add(interaction.id);
+        }
+        const matchingActions = !controlInArea
+          ? []
+          : interaction.actionRef === undefined
+            ? graph.actions.filter(
+                (action) =>
+                  action.controlRef === feature.controlRef &&
+                  action.trigger === interaction.trigger,
+              )
+            : graph.actions.filter(
+                (action) =>
+                  action.id === interaction.actionRef &&
+                  action.controlRef === feature.controlRef,
+              );
+        if (matchingActions.length === 0) {
+          add(
+            issues,
+            "REQ_FEATURE_ACTION_MISSING",
+            interaction.actionRef === undefined
+              ? `${interactionPath}/trigger`
+              : `${interactionPath}/actionRef`,
+            "No graph Action matches this Area, Control and Interaction",
+          );
+        } else if (matchingActions.length > 1) {
+          add(
+            issues,
+            "REQ_FEATURE_ACTION_AMBIGUOUS",
+            `${interactionPath}/trigger`,
+            "Multiple graph Actions match this legacy Interaction",
+          );
+        }
+        const action =
+          matchingActions.length === 1 ? matchingActions[0] : undefined;
+        if (
+          action !== undefined &&
+          control !== undefined &&
+          !control.actionRefs.includes(action.id)
+        ) {
+          add(
+            issues,
+            "REQ_FEATURE_OWNER_CHAIN_INVALID",
+            interactionPath,
+            "Interaction does not preserve Area→Control→Action ownership",
+          );
+        }
+        if (action) {
+          validateInteractionSemantics(
+            interaction,
+            action,
+            interactionPath,
+            feature,
+            graph,
+            graphAreaById,
+            unresolvedIds,
+            issues,
+          );
+        }
+      });
+      feature.unresolvedRefs.forEach((ref) => {
+        if (!unresolvedIds.has(ref)) {
+          add(
+            issues,
+            "REQ_UNRESOLVED_REF_MISSING",
+            `${featurePath}/unresolvedRefs`,
+            `Unknown unresolved item ${ref}`,
+          );
+        }
+      });
+    });
+    if (area.features.some((feature) => feature.interactions !== undefined)) {
+      const actualControlRefs = area.features.map(
+        (feature) => feature.controlRef,
+      );
+      const expectedControlRefs = (graphArea?.controlRefs ?? []).filter(
+        (controlRef) =>
+          (controlById.get(controlRef)?.actionRefs.length ?? 0) > 0,
+      );
+      if (
+        new Set(actualControlRefs).size !== actualControlRefs.length ||
+        JSON.stringify(actualControlRefs) !==
+          JSON.stringify(expectedControlRefs)
+      ) {
+        add(
+          issues,
+          "REQ_AREA_FEATURE_CONTROL_SET_MISMATCH",
+          `${base}/features`,
+          "Area must project every actionable Control to exactly one Feature",
+        );
+      }
+    }
+  });
+  if (
+    req.areas.length !== graph.areas.length ||
+    graph.areas.some(
+      (area) => !req.areas.some((reqArea) => reqArea.areaRef === area.id),
+    )
+  ) {
+    add(
+      issues,
+      "REQ_AREA_SET_MISMATCH",
+      "/areas",
+      "req-model must include every graph Area exactly once",
+    );
+  }
+  if (source) {
+    const sourceIds = new Set(source.facts.map((fact) => fact.id));
+    req.areas.forEach((area, areaIndex) => {
+      area.supportRefs.forEach((ref) => {
+        if (!sourceIds.has(ref)) {
+          add(
+            issues,
+            "REQ_SUPPORT_REF_MISSING",
+            `/areas/${areaIndex}/supportRefs`,
+            `Unknown source fact ${ref}`,
+          );
+        }
+      });
+    });
+  }
+  return { ok: issues.length === 0, issues };
+}