android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/source-facts/builder.js

@@ -0,0 +1,350 @@
+import { createStableId } from "../../core/stable-id.js";
+const confidenceOrder = {
+  low: 0,
+  medium: 1,
+  high: 2,
+};
+function normalizePath(path) {
+  const normalized = path
+    .trim()
+    .replaceAll("\\", "/")
+    .replace(/^\.\/+/u, "")
+    .replace(/\/{2,}/gu, "/");
+  if (
+    normalized.length === 0 ||
+    normalized.startsWith("/") ||
+    /^[A-Za-z]:\//u.test(normalized) ||
+    normalized.split("/").includes("..")
+  ) {
+    throw new Error(`Evidence path must be project-relative: ${path}`);
+  }
+  return normalized;
+}
+function normalizeLocation(location) {
+  const startLine = Math.max(1, location.range.startLine);
+  const endLine = Math.max(startLine, location.range.endLine);
+  const startColumn = location.range.startColumn;
+  const endColumn = location.range.endColumn;
+  return {
+    sourceKind: location.sourceKind,
+    path: normalizePath(location.path),
+    anchor: location.anchor.trim(),
+    range: {
+      startLine,
+      endLine,
+      ...(startColumn !== undefined && startColumn >= 1 ? { startColumn } : {}),
+      ...(endColumn !== undefined && endColumn >= 1 ? { endColumn } : {}),
+    },
+    ...(location.symbol?.trim() ? { symbol: location.symbol.trim() } : {}),
+  };
+}
+function sortStrings(values) {
+  return [...new Set(values)].sort((left, right) =>
+    left.localeCompare(right, "en"),
+  );
+}
+function supportKey(support) {
+  return `${support.evidenceRef}\u0000${support.role}`;
+}
+function mergeSupports(left, right) {
+  const map = new Map();
+  [...left, ...right].forEach((support) => {
+    map.set(supportKey(support), support);
+  });
+  const result = [...map.values()].sort((a, b) =>
+    supportKey(a).localeCompare(supportKey(b), "en"),
+  );
+  if (result.length === 0) {
+    throw new Error("A source fact must have at least one support link");
+  }
+  return result;
+}
+function mergeData(existing, incoming) {
+  return {
+    ...existing,
+    ...incoming,
+  };
+}
+function factSortKey(fact) {
+  return `${fact.kind}\u0000${fact.id}`;
+}
+function strongFactRefs(fact) {
+  switch (fact.kind) {
+    case "component":
+    case "resource-value":
+      return [];
+    case "component-variant":
+      return [
+        fact.data.componentKey,
+        ...fact.data.conditionKeys,
+        ...fact.data.entryCallbackKeys,
+        ...(fact.data.visibleElementKeys ?? []),
+      ];
+    case "entry-point":
+      return [
+        fact.data.componentKey,
+        ...fact.data.conditionKeys,
+        ...(fact.data.preconditionKeys ?? []),
+        ...(fact.data.parentEntryKey ? [fact.data.parentEntryKey] : []),
+      ];
+    case "ui-element":
+    case "ui-property":
+    case "callback":
+    case "condition":
+      return [fact.data.ownerKey];
+    case "container-binding":
+      return [
+        fact.data.hostKey,
+        ...fact.data.contentKeys,
+        ...(fact.data.initialContentKey ? [fact.data.initialContentKey] : []),
+      ];
+    case "interaction-binding":
+      return [fact.data.elementKey, fact.data.callbackKey];
+    case "callback-flow":
+      return [
+        fact.data.fromCallbackKey,
+        fact.data.toCallbackKey,
+        ...(fact.data.conditionKeys ?? []),
+      ];
+    case "behavior-effect":
+      return [
+        fact.data.callbackKey,
+        ...(fact.data.targetKey ? [fact.data.targetKey] : []),
+        ...(fact.data.conditionKeys ?? []),
+      ];
+    case "navigation-target":
+      return [
+        fact.data.effectKey,
+        ...(fact.data.targetKey ? [fact.data.targetKey] : []),
+      ];
+  }
+}
+export class SourceFactsBuilder {
+  caseId;
+  analysisContext;
+  evidenceById = new Map();
+  factsById = new Map();
+  unresolvedById = new Map();
+  constructor(caseId, analysisContext) {
+    this.caseId = caseId;
+    this.analysisContext = analysisContext;
+  }
+  stableId(namespace, entityKind, identity) {
+    return createStableId({
+      namespace,
+      caseId: this.caseId,
+      entityKind,
+      identity,
+    });
+  }
+  addEvidence(location) {
+    const normalized = normalizeLocation(location);
+    if (normalized.anchor.length === 0) {
+      throw new Error(`Evidence anchor must not be blank: ${normalized.path}`);
+    }
+    const identity = [
+      { kind: "resource", value: normalized.path },
+      { kind: "semantic-key", value: normalized.anchor },
+      /*
+       * Evidence is a physical citation, not a product entity. Repeated,
+       * textually identical calls can legitimately share the same semantic
+       * anchor and symbol, so the exact normalized span must distinguish
+       * their citations. Fact IDs remain independent of source position.
+       */
+      {
+        kind: "semantic-position",
+        value: JSON.stringify({
+          sourceKind: normalized.sourceKind,
+          range: normalized.range,
+        }),
+      },
+      ...(normalized.symbol
+        ? [{ kind: "symbol", value: normalized.symbol }]
+        : []),
+    ];
+    const id = this.stableId("evidence", "source", identity);
+    const existing = this.evidenceById.get(id);
+    if (!existing) {
+      this.evidenceById.set(id, { id, ...normalized });
+    }
+    return id;
+  }
+  addFact(kind, input) {
+    const id = this.stableId("fact", kind, input.identity);
+    const support = input.support.map(({ location, role }) => ({
+      evidenceRef: this.addEvidence(location),
+      role,
+    }));
+    const existing = this.factsById.get(id);
+    const confidence =
+      existing &&
+      confidenceOrder[existing.confidence] > confidenceOrder[input.confidence]
+        ? existing.confidence
+        : input.confidence;
+    const fact = {
+      id,
+      kind,
+      confidence,
+      support: existing ? mergeSupports(existing.support, support) : support,
+      data: existing ? mergeData(existing.data, input.data) : input.data,
+      ...((existing?.relatedFactRefs?.length ?? 0) > 0 ||
+      (input.relatedFactRefs?.length ?? 0) > 0
+        ? {
+            relatedFactRefs: sortStrings([
+              ...(existing?.relatedFactRefs ?? []),
+              ...(input.relatedFactRefs ?? []),
+            ]),
+          }
+        : {}),
+      ...(existing?.unresolvedRefs?.length
+        ? { unresolvedRefs: existing.unresolvedRefs }
+        : {}),
+    };
+    this.factsById.set(id, fact);
+    return id;
+  }
+  addUnresolved(input) {
+    const evidenceRefs = sortStrings(input.evidenceRefs ?? []);
+    const identity = [
+      { kind: "semantic-key", value: input.ownerRef },
+      { kind: "semantic-key", value: input.fieldPath },
+      { kind: "semantic-key", value: input.reasonCode },
+      ...(input.originRef
+        ? [{ kind: "semantic-key", value: input.originRef }]
+        : []),
+    ];
+    const id = this.stableId("unresolved", "source", identity);
+    const item = {
+      id,
+      ownerRef: input.ownerRef,
+      fieldPath: input.fieldPath,
+      reasonCode: input.reasonCode,
+      message: input.message,
+      evidenceRefs,
+      candidates: input.candidates ?? [],
+      impact: sortStrings(input.impact),
+      ...(input.originRef ? { originRef: input.originRef } : {}),
+    };
+    this.unresolvedById.set(id, item);
+    const fact = this.factsById.get(input.ownerRef);
+    if (fact) {
+      this.factsById.set(input.ownerRef, {
+        ...fact,
+        unresolvedRefs: sortStrings([...(fact.unresolvedRefs ?? []), id]),
+      });
+    }
+    return id;
+  }
+  fact(id) {
+    return this.factsById.get(id);
+  }
+  mergeFactData(kind, id, patch) {
+    const fact = this.factsById.get(id);
+    if (!fact || fact.kind !== kind) {
+      throw new Error(`Cannot update missing ${kind} source fact ${id}`);
+    }
+    this.factsById.set(id, {
+      ...fact,
+      data: {
+        ...fact.data,
+        ...patch,
+      },
+    });
+  }
+  removeUnresolvedOwnedBy(ownerRef, reasonCodes) {
+    const removed = new Set(
+      [...this.unresolvedById.values()].flatMap((item) =>
+        item.ownerRef === ownerRef && reasonCodes.has(item.reasonCode)
+          ? [item.id]
+          : [],
+      ),
+    );
+    if (removed.size === 0) return;
+    for (const id of removed) this.unresolvedById.delete(id);
+    const owner = this.factsById.get(ownerRef);
+    if (!owner?.unresolvedRefs) return;
+    const retained = owner.unresolvedRefs.filter((id) => !removed.has(id));
+    this.factsById.set(ownerRef, {
+      ...owner,
+      ...(retained.length > 0
+        ? { unresolvedRefs: retained }
+        : {
+            unresolvedRefs: undefined,
+          }),
+    });
+  }
+  facts(kind) {
+    return [...this.factsById.values()]
+      .filter((fact) => kind === undefined || fact.kind === kind)
+      .sort((left, right) =>
+        factSortKey(left).localeCompare(factSortKey(right), "en"),
+      );
+  }
+  finish() {
+    const facts = this.facts();
+    const factIds = new Set(facts.map((fact) => fact.id));
+    for (const fact of facts) {
+      for (const reference of [
+        ...(fact.relatedFactRefs ?? []),
+        ...strongFactRefs(fact),
+      ]) {
+        if (!factIds.has(reference)) {
+          throw new Error(
+            `Source fact ${fact.id} has missing strong reference ${reference}`,
+          );
+        }
+      }
+      for (const support of fact.support) {
+        if (!this.evidenceById.has(support.evidenceRef)) {
+          throw new Error(
+            `Source fact ${fact.id} has missing evidence ${support.evidenceRef}`,
+          );
+        }
+      }
+      for (const unresolvedRef of fact.unresolvedRefs ?? []) {
+        if (!this.unresolvedById.has(unresolvedRef)) {
+          throw new Error(
+            `Source fact ${fact.id} has missing unresolved ${unresolvedRef}`,
+          );
+        }
+      }
+    }
+    for (const unresolved of this.unresolvedById.values()) {
+      if (!factIds.has(unresolved.ownerRef)) {
+        throw new Error(
+          `Unresolved item ${unresolved.id} has missing owner ${unresolved.ownerRef}`,
+        );
+      }
+      for (const evidenceRef of unresolved.evidenceRefs) {
+        if (!this.evidenceById.has(evidenceRef)) {
+          throw new Error(
+            `Unresolved item ${unresolved.id} has missing evidence ${evidenceRef}`,
+          );
+        }
+      }
+      for (const candidate of unresolved.candidates) {
+        for (const evidenceRef of candidate.supportRefs) {
+          if (!this.evidenceById.has(evidenceRef)) {
+            throw new Error(
+              `Unresolved item ${unresolved.id} candidate has missing ` +
+                `evidence ${evidenceRef}`,
+            );
+          }
+        }
+      }
+    }
+    return {
+      schemaVersion: "1.0.0",
+      artifactKind: "source-facts",
+      caseId: this.caseId,
+      analysisContext: this.analysisContext,
+      evidence: [...this.evidenceById.values()].sort((left, right) =>
+        left.id.localeCompare(right.id, "en"),
+      ),
+      facts,
+      unresolved: [...this.unresolvedById.values()].sort((left, right) =>
+        left.id.localeCompare(right.id, "en"),
+      ),
+    };
+  }
+}