create-agdf 0.7.3 → 0.8.1

package/lib/interaction-presentation.js

@@ -0,0 +1,169 @@
+const REQUIRED_GATES = ["UR", "PRD", "SD", "TP", "QA", "UAT"];
+const ARTEFACT_ORDER = ["UR", "PRD", "SD", "TP"];
+const OUTCOMES = new Set(["approve", "revise", "decline", "cancel", "no_response", "timeout", "empty", "invalid", "stale"]);
+
+function plainObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value);
+}
+
+function flattenKeys(value, prefix = "") {
+  const keys = [];
+  for (const [key, child] of Object.entries(value ?? {})) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (plainObject(child)) keys.push(...flattenKeys(child, path));
+    else keys.push(path);
+  }
+  return keys.sort();
+}
+
+function visibleStrings(value, prefix = "") {
+  const entries = [];
+  for (const [key, child] of Object.entries(value ?? {})) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (plainObject(child)) entries.push(...visibleStrings(child, path));
+    else if (typeof child === "string") entries.push([path, child]);
+  }
+  return entries;
+}
+
+export function canonicalizeLanguageTag(value) {
+  const raw = String(value ?? "").trim().replaceAll("_", "-").replace(/\.(.+)$/, "");
+  if (!raw || !/^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/.test(raw)) return "";
+  try {
+    return Intl.getCanonicalLocales(raw)[0]?.toLowerCase() ?? "";
+  } catch {
+    return "";
+  }
+}
+
+export function validateLocaleRegistry(registry) {
+  const errors = [];
+  if (!plainObject(registry) || registry.schemaVersion !== 1) errors.push("schema_version");
+  const fallback = canonicalizeLanguageTag(registry?.fallbackLocale);
+  const locales = registry?.locales;
+  if (!fallback || !plainObject(locales) || !plainObject(locales[fallback])) errors.push("fallback_locale");
+  const baseline = plainObject(locales?.[fallback]) ? flattenKeys(locales[fallback]) : [];
+  const budgets = registry?.lengthBudgets ?? {};
+  for (const [locale, pack] of Object.entries(locales ?? {})) {
+    if (!canonicalizeLanguageTag(locale) || !plainObject(pack)) {
+      errors.push(`invalid_locale:${locale}`);
+      continue;
+    }
+    const keys = flattenKeys(pack);
+    if (JSON.stringify(keys) !== JSON.stringify(baseline)) errors.push(`incomplete_locale:${locale}`);
+    for (const [key, value] of visibleStrings(pack)) {
+      if (!value.trim()) errors.push(`empty_copy:${locale}:${key}`);
+      const budget = key.startsWith("gateTitles.") ? budgets.title
+        : key.includes("Description") || key.startsWith("primary.actions.") || key.startsWith("primary.afterApproval.") || key === "primary.quality"
+          ? budgets.description
+          : budgets.label;
+      if (Number.isInteger(budget) && value.length > budget) errors.push(`length_budget:${locale}:${key}`);
+    }
+    for (const key of REQUIRED_GATES) {
+      if (typeof pack.gateTitles?.[key] !== "string" || !pack.gateTitles[key].trim()) errors.push(`missing_gate_title:${locale}:${key}`);
+    }
+  }
+  if (JSON.stringify(registry?.optionOrder) !== JSON.stringify(["approve", "revise", "decline", "cancel"])) errors.push("option_order");
+  return { valid: errors.length === 0, errors };
+}
+
+export function resolvePresentationLocale(registry, requestedLocale) {
+  const validation = validateLocaleRegistry(registry);
+  if (!validation.valid) throw new Error(`Invalid AGDF interaction locale registry: ${validation.errors.join(",")}`);
+  const fallback = canonicalizeLanguageTag(registry.fallbackLocale);
+  const requested = canonicalizeLanguageTag(requestedLocale);
+  if (requested && registry.locales[requested]) return requested;
+  const language = requested.split("-")[0];
+  if (language && registry.locales[language]) return language;
+  return fallback;
+}
+
+export function localePack(registry, requestedLocale) {
+  return registry.locales[resolvePresentationLocale(registry, requestedLocale)];
+}
+
+export function gateTitle(registry, requestedLocale, gate) {
+  return localePack(registry, requestedLocale).gateTitles[gate] || String(gate || "");
+}
+
+function stripMarkdown(value) {
+  return String(value ?? "")
+    .replace(/^#+\s*/, "")
+    .replace(/[`*_]/g, "")
+    .trim();
+}
+
+function section(content, heading) {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return content.match(new RegExp(`(?:^|\\n)## ${escaped}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`))?.[1]?.trim() ?? "";
+}
+
+export function normalizedRunTitle(runId) {
+  const words = String(runId ?? "")
+    .replace(/[._-]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  return words ? words.replace(/\b\p{L}/gu, (letter) => letter.toUpperCase()) : "AGDF run";
+}
+
+export function resolveHumanRunTitle({ currentArtefactHeading, urHeading, runContent, runId }) {
+  const objective = section(String(runContent ?? ""), "Objective").split(/\r?\n/).map(stripMarkdown).find(Boolean) ?? "";
+  return [currentArtefactHeading, urHeading, objective].map(stripMarkdown).find(Boolean) || normalizedRunTitle(runId);
+}
+
+function safeArtefactPath(value) {
+  const path = String(value ?? "").replace(/^`|`$/g, "").trim();
+  if (!path || !/^[A-Za-z0-9._/-]+$/.test(path) || /^([a-z]+:|\/)/i.test(path)) return "";
+  const parts = path.replaceAll("\\", "/").split("/");
+  if (parts.includes("..")) return "";
+  return path;
+}
+
+export function buildArtefactRefs(artefacts, registry, requestedLocale, { pathExists } = {}) {
+  const pack = localePack(registry, requestedLocale);
+  return ARTEFACT_ORDER.map((type) => {
+    const artefact = artefacts instanceof Map ? artefacts.get(type) : artefacts?.[type];
+    const candidatePath = safeArtefactPath(artefact?.path);
+    const path = candidatePath && (!pathExists || pathExists(candidatePath, type)) ? candidatePath : "";
+    return {
+      type,
+      exists: Boolean(path),
+      status: String(artefact?.status ?? ""),
+      path,
+      label: type,
+      missingLabel: `${type} (${pack.artefacts.notYetCreated})`,
+    };
+  });
+}
+
+export function formatArtefactRefs(refs) {
+  return refs.map((ref) => ref.exists ? `[${ref.label}](${ref.path})` : ref.missingLabel).join(" · ");
+}
+
+export function gateOptions(registry, requestedLocale, gate, { includeCancel = false } = {}) {
+  const pack = localePack(registry, requestedLocale);
+  const options = [
+    { outcome: "approve", label: `Approval: ${gate}`, description: pack.interaction.approveDescription, value: `Approval: ${gate}`, authorizes: true },
+    { outcome: "revise", label: pack.interaction.reviseLabel, description: pack.interaction.reviseDescription, value: "revise", authorizes: false },
+    { outcome: "decline", label: pack.interaction.declineLabel, description: pack.interaction.declineDescription, value: "decline", authorizes: false },
+  ];
+  if (includeCancel) options.push({ outcome: "cancel", label: pack.interaction.cancelLabel, description: pack.interaction.cancelDescription, value: "cancel", authorizes: false });
+  return options;
+}
+
+export function normalizeInteractionOutcome(value, { expectedApproval, stale = false, timedOut = false, noResponse = false } = {}) {
+  if (stale) return "stale";
+  if (timedOut) return "timeout";
+  if (noResponse || value === undefined || value === null) return "no_response";
+  if (typeof value !== "string") return "invalid";
+  const normalized = value.trim();
+  if (!normalized) return "empty";
+  if (normalized === expectedApproval) return "approve";
+  if (OUTCOMES.has(normalized) && normalized !== "approve") return normalized;
+  return "invalid";
+}
+
+export const interactionPresentationConstants = Object.freeze({
+  artefactOrder: Object.freeze([...ARTEFACT_ORDER]),
+  outcomes: Object.freeze([...OUTCOMES]),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-agdf",
-  "version": "0.7.3",
+  "version": "0.8.1",
   "description": "Bootstrap AGDF repository-local plugin files, Copilot/OpenCode instructions, skills, control files and machine-readable checks.",
   "type": "module",
   "files": [
@@ -25,11 +25,12 @@
     "test:delivery-path-search-unit": "node ./scripts/delivery-path-search-unit-test.js",
     "test:delivery-path-search-generator": "node ./scripts/delivery-path-search-generator-test.js",
     "test:control-state": "node ./scripts/control-state-test.js",
+    "test:interaction-presentation": "node ./scripts/interaction-presentation-test.js",
     "test:verified-change": "node ./scripts/verified-change-test.js",
     "test:runtime-integrity-negative": "node ./scripts/runtime-integrity-negative-test.js",
     "test:release-bootstrap": "node ./scripts/release-bootstrap-smoke-test.js",
     "test:routing": "npm run sync-package-assets && node ./scripts/test-routing.js",
-    "smoke-test": "npm run sync-package-assets && npm run test:control-state && npm run test:verified-change && npm run test:runtime-integrity-negative && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && npm run test:delivery-path-search-generator && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
+    "smoke-test": "npm run sync-package-assets && npm run test:control-state && npm run test:interaction-presentation && npm run test:verified-change && npm run test:runtime-integrity-negative && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && npm run test:delivery-path-search-generator && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
     "prepack": "npm run sync-package-assets"
   },
   "keywords": [