android2harmony 0.1.6 → 0.1.8

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

@@ -0,0 +1,444 @@
+function issue(issues, code, path, message) {
+  issues.push({ code, path, message });
+}
+function duplicateIds(values, path, issues) {
+  const seen = new Set();
+  values.forEach((value, index) => {
+    if (seen.has(value.id)) {
+      issue(
+        issues,
+        "DUPLICATE_ID",
+        `/${path}/${index}/id`,
+        `Duplicate ${path} ID: ${value.id}`,
+      );
+    }
+    seen.add(value.id);
+  });
+}
+function validatePath(graph, path, index, issues) {
+  const base = `/paths/${index}`;
+  const areaIds = new Set(graph.areas.map((area) => area.id));
+  const edgeById = new Map(graph.edges.map((edge) => [edge.id, edge]));
+  const controlById = new Map(
+    graph.controls.map((control) => [control.id, control]),
+  );
+  const entry = path.rootEntryRef
+    ? graph.entryPoints.find((item) => item.id === path.rootEntryRef)
+    : undefined;
+  if (!areaIds.has(path.targetAreaRef)) {
+    issue(
+      issues,
+      "PATH_TARGET_MISSING",
+      `${base}/targetAreaRef`,
+      `Unknown path target ${path.targetAreaRef}`,
+    );
+  }
+  if (path.kind !== "unreachable" && (!path.rootEntryRef || !entry)) {
+    issue(
+      issues,
+      "PATH_ENTRY_MISSING",
+      `${base}/rootEntryRef`,
+      "Reachable paths require an existing root entry",
+    );
+  }
+  if (path.kind === "unreachable" && path.steps.length > 0) {
+    issue(
+      issues,
+      "UNREACHABLE_PATH_HAS_STEPS",
+      `${base}/steps`,
+      "An unreachable path cannot contain steps",
+    );
+  }
+  const expectedReachability =
+    path.kind === "unreachable"
+      ? "unreachable"
+      : path.preconditions.length > 0
+        ? "conditional"
+        : "unconditional";
+  if (path.reachability !== expectedReachability) {
+    issue(
+      issues,
+      "PATH_REACHABILITY_MISMATCH",
+      `${base}/reachability`,
+      `Expected ${expectedReachability} for ${path.kind} path`,
+    );
+  }
+  let expectedSources = new Set(entry?.rootAreaRefs ?? []);
+  path.steps.forEach((step, stepIndex) => {
+    const stepPath = `${base}/steps/${stepIndex}`;
+    const edge = edgeById.get(step.edgeRef);
+    if (!edge) {
+      issue(
+        issues,
+        "PATH_EDGE_MISSING",
+        `${stepPath}/edgeRef`,
+        `Unknown edge ${step.edgeRef}`,
+      );
+      return;
+    }
+    if (
+      edge.sourceAreaRef !== step.sourceAreaRef ||
+      edge.controlRef !== step.controlRef ||
+      edge.actionRef !== step.actionRef ||
+      "status" in edge.target ||
+      edge.target.kind !== "area" ||
+      edge.target.ref !== step.targetAreaRef
+    ) {
+      issue(
+        issues,
+        "PATH_STEP_EDGE_MISMATCH",
+        stepPath,
+        `Path step does not reproduce edge ${edge.id}`,
+      );
+    }
+    const edgeControl = controlById.get(edge.controlRef);
+    if (
+      edgeControl?.enabled?.status === "resolved" &&
+      edgeControl.enabled.value === false
+    ) {
+      issue(
+        issues,
+        "PATH_DISABLED_CONTROL",
+        `${stepPath}/controlRef`,
+        `Path step uses statically disabled Control ${edge.controlRef}`,
+      );
+    }
+    if (!expectedSources.has(step.sourceAreaRef)) {
+      issue(
+        issues,
+        "PATH_NOT_CONTIGUOUS",
+        `${stepPath}/sourceAreaRef`,
+        `Unexpected path source ${step.sourceAreaRef}`,
+      );
+    }
+    expectedSources = new Set([step.targetAreaRef]);
+  });
+  if (
+    path.steps.length === 0 &&
+    entry &&
+    !entry.rootAreaRefs.includes(path.targetAreaRef)
+  ) {
+    issue(
+      issues,
+      "ZERO_STEP_PATH_TARGET_MISMATCH",
+      `${base}/targetAreaRef`,
+      "A zero-step path must target one of its entry roots",
+    );
+  } else if (
+    path.steps.length > 0 &&
+    path.steps[path.steps.length - 1].targetAreaRef !== path.targetAreaRef
+  ) {
+    issue(
+      issues,
+      "PATH_FINAL_TARGET_MISMATCH",
+      `${base}/targetAreaRef`,
+      "The last step does not reach the path target",
+    );
+  }
+}
+export function validateAreaGraph(graph) {
+  const issues = [];
+  const collections = [
+    ["areas", graph.areas],
+    ["controls", graph.controls],
+    ["actions", graph.actions],
+    ["effects", graph.effects],
+    ["edges", graph.edges],
+    ["externalEndpoints", graph.externalEndpoints],
+    ["entryPoints", graph.entryPoints],
+    ["paths", graph.paths],
+    ["unresolved", graph.unresolved],
+  ];
+  collections.forEach(([path, values]) => duplicateIds(values, path, issues));
+  const areaById = new Map(graph.areas.map((area) => [area.id, area]));
+  const controlById = new Map(
+    graph.controls.map((control) => [control.id, control]),
+  );
+  const actionById = new Map(
+    graph.actions.map((action) => [action.id, action]),
+  );
+  const effectById = new Map(
+    graph.effects.map((effect) => [effect.id, effect]),
+  );
+  const externalIds = new Set(
+    graph.externalEndpoints.map((endpoint) => endpoint.id),
+  );
+  const unresolvedById = new Map(
+    graph.unresolved.map((item) => [item.id, item]),
+  );
+  const unresolvedIds = new Set(unresolvedById.keys());
+  const pathById = new Map(graph.paths.map((path) => [path.id, path]));
+  graph.areas.forEach((area, areaIndex) => {
+    area.controlRefs.forEach((controlRef) => {
+      const control = controlById.get(controlRef);
+      if (!control || control.areaRef !== area.id) {
+        issue(
+          issues,
+          "AREA_CONTROL_BACKREF_INVALID",
+          `/areas/${areaIndex}/controlRefs`,
+          `Area ${area.id} has invalid control ${controlRef}`,
+        );
+      }
+    });
+    if (area.canonicalPathRef) {
+      const path = pathById.get(area.canonicalPathRef);
+      if (
+        !path ||
+        path.targetAreaRef !== area.id ||
+        (path.kind !== "canonical" && path.kind !== "unreachable")
+      ) {
+        issue(
+          issues,
+          "AREA_CANONICAL_PATH_INVALID",
+          `/areas/${areaIndex}/canonicalPathRef`,
+          `Area ${area.id} has invalid canonical path`,
+        );
+      }
+    }
+  });
+  graph.controls.forEach((control, controlIndex) => {
+    const owner = areaById.get(control.areaRef);
+    if (!owner || !owner.controlRefs.includes(control.id)) {
+      issue(
+        issues,
+        "CONTROL_AREA_BACKREF_INVALID",
+        `/controls/${controlIndex}/areaRef`,
+        `Control ${control.id} has invalid Area owner`,
+      );
+    }
+    control.actionRefs.forEach((actionRef) => {
+      const action = actionById.get(actionRef);
+      if (!action || action.controlRef !== control.id) {
+        issue(
+          issues,
+          "CONTROL_ACTION_BACKREF_INVALID",
+          `/controls/${controlIndex}/actionRefs`,
+          `Control ${control.id} has invalid action ${actionRef}`,
+        );
+      }
+    });
+    if (control.enabled?.status === "resolved") {
+      if (typeof control.enabled.value !== "boolean") {
+        issue(
+          issues,
+          "CONTROL_ENABLED_VALUE_INVALID",
+          `/controls/${controlIndex}/enabled/value`,
+          "A resolved Control enabled value must be boolean",
+        );
+      }
+    } else if (
+      control.enabled?.status === "unresolved" &&
+      !unresolvedIds.has(control.enabled.unresolvedRef)
+    ) {
+      issue(
+        issues,
+        "CONTROL_ENABLED_UNRESOLVED_MISSING",
+        `/controls/${controlIndex}/enabled/unresolvedRef`,
+        `Unknown unresolved item ${control.enabled.unresolvedRef}`,
+      );
+    }
+  });
+  graph.actions.forEach((action, actionIndex) => {
+    const owner = controlById.get(action.controlRef);
+    if (!owner || !owner.actionRefs.includes(action.id)) {
+      issue(
+        issues,
+        "ACTION_CONTROL_BACKREF_INVALID",
+        `/actions/${actionIndex}/controlRef`,
+        `Action ${action.id} has invalid Control owner`,
+      );
+    }
+    if (action.effectRefs.length === 0) {
+      issue(
+        issues,
+        "ACTION_EFFECT_MISSING",
+        `/actions/${actionIndex}/effectRefs`,
+        `Action ${action.id} must reference at least one Effect`,
+      );
+    }
+    action.effectRefs.forEach((effectRef) => {
+      const effect = effectById.get(effectRef);
+      if (!effect || effect.actionRef !== action.id) {
+        issue(
+          issues,
+          "ACTION_EFFECT_BACKREF_INVALID",
+          `/actions/${actionIndex}/effectRefs`,
+          `Action ${action.id} has invalid effect ${effectRef}`,
+        );
+      }
+    });
+    if (action.preconditionAlternatives) {
+      const common =
+        action.preconditionAlternatives.length === 0
+          ? []
+          : action.preconditionAlternatives[0].conditionRefs
+              .filter((conditionRef) =>
+                action.preconditionAlternatives?.every((alternative) =>
+                  alternative.conditionRefs.includes(conditionRef),
+                ),
+              )
+              .sort();
+      if (
+        JSON.stringify(common) !==
+        JSON.stringify([...action.preconditionRefs].sort())
+      ) {
+        issue(
+          issues,
+          "ACTION_PRECONDITION_ALTERNATIVES_INVALID",
+          `/actions/${actionIndex}/preconditionAlternatives`,
+          "Action preconditionRefs must be the intersection of its alternatives",
+        );
+      }
+    }
+  });
+  graph.effects.forEach((effect, effectIndex) => {
+    const owner = actionById.get(effect.actionRef);
+    if (!owner || !owner.effectRefs.includes(effect.id)) {
+      issue(
+        issues,
+        "EFFECT_ACTION_BACKREF_INVALID",
+        `/effects/${effectIndex}/actionRef`,
+        `Effect ${effect.id} has invalid Action owner`,
+      );
+    }
+    if (effect.kind === "unknown") {
+      const descriptionRef =
+        effect.description.status === "unresolved"
+          ? effect.description.unresolvedRef
+          : undefined;
+      const unresolvedItem = descriptionRef
+        ? unresolvedById.get(descriptionRef)
+        : undefined;
+      if (
+        !descriptionRef ||
+        !effect.unresolvedRefs?.includes(descriptionRef) ||
+        !unresolvedItem ||
+        (unresolvedItem.ownerRef !== effect.id &&
+          unresolvedItem.ownerRef !== effect.actionRef)
+      ) {
+        issue(
+          issues,
+          "UNKNOWN_EFFECT_UNRESOLVED_MISSING",
+          `/effects/${effectIndex}/unresolvedRefs`,
+          `Unknown Effect ${effect.id} must reference its owning unresolved item`,
+        );
+      }
+    }
+    for (const [field, value] of [
+      ["stateKey", effect.stateKey],
+      ["value", effect.value],
+    ]) {
+      if (
+        value?.status === "unresolved" &&
+        !unresolvedIds.has(value.unresolvedRef)
+      ) {
+        issue(
+          issues,
+          "EFFECT_VALUE_UNRESOLVED_MISSING",
+          `/effects/${effectIndex}/${field}/unresolvedRef`,
+          `Unknown unresolved item ${value.unresolvedRef}`,
+        );
+      }
+    }
+  });
+  graph.edges.forEach((edge, edgeIndex) => {
+    const control = controlById.get(edge.controlRef);
+    const action = actionById.get(edge.actionRef);
+    if (
+      !areaById.has(edge.sourceAreaRef) ||
+      !control ||
+      control.areaRef !== edge.sourceAreaRef ||
+      !action ||
+      action.controlRef !== control.id ||
+      !control.actionRefs.includes(action.id)
+    ) {
+      issue(
+        issues,
+        "EDGE_OWNER_CHAIN_INVALID",
+        `/edges/${edgeIndex}`,
+        `Edge ${edge.id} does not preserve Area→Control→Action ownership`,
+      );
+    }
+    const hasTransitionEffect =
+      action?.effectRefs.some((effectRef) => {
+        const effect = effectById.get(effectRef);
+        return (
+          effect?.actionRef === action.id &&
+          (effect.kind === "navigate-area" ||
+            effect.kind === "open-external" ||
+            effect.kind === "business-action" ||
+            effect.kind === "show-surface" ||
+            effect.kind === "close-surface")
+        );
+      }) ?? false;
+    if (!hasTransitionEffect) {
+      issue(
+        issues,
+        "EDGE_ACTION_NAVIGATION_EFFECT_MISSING",
+        `/edges/${edgeIndex}/actionRef`,
+        `Edge ${edge.id} Action has no Area transition or external Effect`,
+      );
+    }
+    if ("status" in edge.target) {
+      if (!unresolvedIds.has(edge.target.unresolvedRef)) {
+        issue(
+          issues,
+          "EDGE_UNRESOLVED_MISSING",
+          `/edges/${edgeIndex}/target`,
+          `Unknown unresolved item ${edge.target.unresolvedRef}`,
+        );
+      }
+    } else if (
+      (edge.target.kind === "area" && !areaById.has(edge.target.ref)) ||
+      (edge.target.kind === "external" && !externalIds.has(edge.target.ref))
+    ) {
+      issue(
+        issues,
+        "EDGE_TARGET_MISSING",
+        `/edges/${edgeIndex}/target`,
+        `Unknown ${edge.target.kind} target ${edge.target.ref}`,
+      );
+    }
+    if (
+      edge.conditionAlternatives?.some((alternative) =>
+        alternative.conditionRefs.some(
+          (conditionRef) => !edge.conditions.includes(conditionRef),
+        ),
+      )
+    ) {
+      issue(
+        issues,
+        "EDGE_CONDITION_ALTERNATIVES_INVALID",
+        `/edges/${edgeIndex}/conditionAlternatives`,
+        "Every alternative condition must also appear in Edge conditions",
+      );
+    }
+  });
+  graph.entryPoints.forEach((entry, entryIndex) => {
+    entry.rootAreaRefs.forEach((areaRef) => {
+      if (!areaById.has(areaRef)) {
+        issue(
+          issues,
+          "ENTRY_ROOT_MISSING",
+          `/entryPoints/${entryIndex}/rootAreaRefs`,
+          `Unknown entry root ${areaRef}`,
+        );
+      }
+    });
+    if (
+      entry.launcherAreaRef !== undefined &&
+      !areaById.has(entry.launcherAreaRef)
+    ) {
+      issue(
+        issues,
+        "ENTRY_LAUNCHER_AREA_MISSING",
+        `/entryPoints/${entryIndex}/launcherAreaRef`,
+        `Unknown launcher shell Area ${entry.launcherAreaRef}`,
+      );
+    }
+  });
+  graph.paths.forEach((path, index) =>
+    validatePath(graph, path, index, issues),
+  );
+  return { ok: issues.length === 0, issues };
+}

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

@@ -0,0 +1,7 @@
+export { validateReqText } from "./req-text.js";
+export { validateAreaGraph } from "./area-graph.js";
+export { validateReqModel } from "./req-model.js";
+export {
+  compareAreaGraphSemantics,
+  projectAreaGraphSemantics,
+} from "./semantic-area-graph.js";