@koda-sl/baker-cli 0.442.0 → 0.443.0-dev.043c1d4ac

package/dist/normalize-CD4PQRYY.js

@@ -0,0 +1,138 @@
+import {
+  flowDataPath,
+  listFlowSlugs,
+  readFlowTree,
+  walkNodes,
+  writeFlowTree
+} from "./chunk-RSW6QJPH.js";
+import {
+  looksLikeUnresolvedVariable,
+  parseEmailRecipients
+} from "./chunk-XWH7CCBL.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-WYCVJIHD.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-XML7AJM3.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/flows/normalize.ts
+import { defineCommand } from "citty";
+var OPTIONAL_STRINGS = ["oauthProviderId"];
+var ARRAY_FIELDS = [
+  "fieldMapping",
+  "columnMapping",
+  "payloadKeys",
+  "eventParams",
+  "eventProperties",
+  "dataLayerParams",
+  "goalParams",
+  "fields",
+  "tagIds"
+];
+var ARRAY_OWNERS = ["", "body"];
+function dropUnsetOptionals(sideEffect, path) {
+  return OPTIONAL_STRINGS.flatMap((key) => {
+    if (!(key in sideEffect) || sideEffect[key] !== null && sideEffect[key] !== "") return [];
+    delete sideEffect[key];
+    return [{ path, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
+  });
+}
+function fillNulledArrays(target, prefix, path) {
+  return ARRAY_FIELDS.flatMap((key) => {
+    if (!(key in target) || target[key] !== null) return [];
+    target[key] = [];
+    return [{ path, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
+  });
+}
+function tidyEmailRecipients(sideEffect, path) {
+  if (sideEffect.type !== "email") return [];
+  const config = sideEffect.encryptedConfig;
+  if (!config || typeof config !== "object" || Array.isArray(config)) return [];
+  const raw = config.email;
+  if (typeof raw !== "string" || looksLikeUnresolvedVariable(raw)) return [];
+  const { to, invalid } = parseEmailRecipients(raw);
+  if (invalid.length > 0 || to.length === 0) return [];
+  const tidied = to.join(", ");
+  if (tidied === raw) return [];
+  config.email = tidied;
+  return [{ path, change: "tidied the recipient list's spacing and separators" }];
+}
+function sideEffectsOf(node) {
+  if (!Array.isArray(node.sideEffects)) return [];
+  return node.sideEffects.filter(
+    (sideEffect) => Boolean(sideEffect) && typeof sideEffect === "object"
+  );
+}
+function normalizeSideEffect(sideEffect, where) {
+  const path = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
+  const arrays = ARRAY_OWNERS.flatMap((owner) => {
+    const target = owner ? sideEffect[owner] : sideEffect;
+    if (!target || typeof target !== "object") return [];
+    return fillNulledArrays(target, owner ? `${owner}.` : "", path);
+  });
+  return [...dropUnsetOptionals(sideEffect, path), ...arrays, ...tidyEmailRecipients(sideEffect, path)];
+}
+function normalizeFlowTree(tree) {
+  const changes = [];
+  for (const node of walkNodes(tree)) {
+    const where = typeof node.name === "string" && node.name ? String(node.name) : String(node.id ?? "node");
+    if (!("condition" in node)) {
+      node.condition = null;
+      changes.push({ path: where, change: "added the missing `condition: null`" });
+    }
+    for (const sideEffect of sideEffectsOf(node)) {
+      changes.push(...normalizeSideEffect(sideEffect, where));
+    }
+  }
+  return changes;
+}
+registerSchema({
+  command: "flows.normalize",
+  description: "Fix the shapes a form file is allowed to get slightly wrong: a nulled optional string, a nulled array, a missing condition. Runs automatically before a commit; you rarely need to call it.",
+  args: {
+    slug: { type: "positional", description: "Form slug. Omit to check every form.", required: false },
+    write: {
+      type: "boolean",
+      description: "Apply the fixes. Without it, reports and changes nothing",
+      required: false
+    }
+  }
+});
+var normalizeCommand = defineCommand({
+  meta: {
+    name: "normalize",
+    description: "Repair the shapes a form file is allowed to get slightly wrong. Example: baker flows normalize contact --write"
+  },
+  args: {
+    // `required: false` matters: citty makes a positional required by default,
+    // so without it the documented bare `baker flows normalize` printed a wall
+    // of usage text and exited 1 instead of checking every form.
+    slug: { type: "positional", description: "Form slug (omit for every form)", required: false },
+    write: { type: "boolean", description: "Apply the fixes" }
+  },
+  run: ({ args }) => {
+    const slugs = args.slug ? [String(args.slug)] : listFlowSlugs();
+    const forms = slugs.flatMap((slug) => {
+      const tree = readFlowTree(slug);
+      const changes = normalizeFlowTree(tree);
+      if (changes.length === 0) return [];
+      if (args.write === true) writeFlowTree(slug, tree);
+      return [{ slug, path: flowDataPath(slug), changes }];
+    });
+    const total = forms.reduce((sum, form) => sum + form.changes.length, 0);
+    writeJson({
+      ok: true,
+      data: { forms, changed: total, written: args.write === true },
+      hints: total === 0 ? ["Nothing to fix."] : args.write === true ? [`Fixed ${total} field(s).`] : [`${total} field(s) can be fixed. Re-run with --write.`]
+    });
+  }
+});
+export {
+  normalizeCommand,
+  normalizeFlowTree
+};
+//# sourceMappingURL=normalize-CD4PQRYY.js.map

package/dist/normalize-CD4PQRYY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/flows/normalize.ts"],"sourcesContent":["/**\n * Make a form file valid without making the agent memorise a rule.\n *\n * `oauthProviderId` is typed `oauthProviderId?: string`. Writing `null` there is\n * the natural thing to do — every sibling confidential field is authored as\n * `null` — and it is a type error at the next build. Three separate passages in\n * the flow-builder skill existed only to teach that one exception, and the agent\n * paid for them on every turn that touched a form.\n *\n * So the system absorbs it instead: an unset optional is dropped, a nulled array\n * becomes an empty one, a missing `condition` becomes the explicit `null` the\n * schema wants. This runs as a pre-commit fixer, so writing `null` is simply not\n * a mistake any more, and the prose that taught the rule is gone.\n *\n * Pure — `normalizeFlowTree` mutates a decoded tree and reports what it changed,\n * so the command and the tests share one implementation.\n */\n\nimport { looksLikeUnresolvedVariable, parseEmailRecipients } from \"@baker/api\";\nimport { defineCommand } from \"citty\";\nimport { writeJson } from \"../../output.ts\";\nimport { registerSchema } from \"../../schemas.ts\";\nimport { flowDataPath, listFlowSlugs, readFlowTree, walkNodes, writeFlowTree } from \"./shared.ts\";\n\ntype AnyRecord = Record<string, unknown>;\n\n/** Optional string fields where \"unset\" must be an absent key, never `null` or `\"\"`. */\nconst OPTIONAL_STRINGS = [\"oauthProviderId\"] as const;\n/**\n * Fields typed as arrays, where `null` means \"none yet\".\n *\n * Every `PayloadKey[]` slot the engine defines is here, not just the common\n * ones: this list is what makes \"a nulled array is not a mistake\" true, so a\n * slot missing from it is a rule the agent is told it no longer has to\n * remember, and then fails a build for forgetting. `flows-normalize-coverage`\n * in `normalize.test.ts` pins it against `MAPPING_SLOTS`.\n */\nconst ARRAY_FIELDS = [\n  \"fieldMapping\",\n  \"columnMapping\",\n  \"payloadKeys\",\n  \"eventParams\",\n  \"eventProperties\",\n  \"dataLayerParams\",\n  \"goalParams\",\n  \"fields\",\n  \"tagIds\",\n] as const;\n\nexport type Normalization = { path: string; change: string };\n\n/**\n * Objects that can carry a mappable array, relative to the side effect.\n *\n * An email's keys live at `body.fields`, one level down, and `null` there is the\n * same type error as `payloadKeys: null` is at the top. Repairing only the top\n * level would leave the one nested slot as a rule the agent still has to know.\n */\nconst ARRAY_OWNERS = [\"\", \"body\"] as const;\n\n/** Drop an optional string that was authored as `null` or `\"\"`. */\nfunction dropUnsetOptionals(sideEffect: AnyRecord, path: string): Normalization[] {\n  return OPTIONAL_STRINGS.flatMap((key) => {\n    if (!(key in sideEffect) || (sideEffect[key] !== null && sideEffect[key] !== \"\")) return [];\n    delete sideEffect[key];\n    return [{ path, change: `dropped \\`${key}\\` (an optional string is absent, never null)` }];\n  });\n}\n\n/** Turn every nulled array on one object into an empty one. */\nfunction fillNulledArrays(target: AnyRecord, prefix: string, path: string): Normalization[] {\n  return ARRAY_FIELDS.flatMap((key) => {\n    if (!(key in target) || target[key] !== null) return [];\n    target[key] = [];\n    return [{ path, change: `\\`${prefix}${key}: null\\` → \\`[]\\`` }];\n  });\n}\n\n/**\n * Tidy an email destination's recipient list, or null when there is nothing to\n * tidy — and, just as importantly, when tidying would hide something.\n *\n * The field is one string holding a list, so it collects the marks of having\n * been typed: a leading space, a trailing comma, a semicolon where a comma was\n * meant, the same address twice. None changes who receives the mail —\n * `parseEmailRecipients` reads all of them the same way at send time — so this\n * is a shape repair rather than a judgement call, which is what keeps it here.\n *\n * It refuses where a rewrite would be one. A `{{…}}` that was never substituted\n * and a fragment that is not an address both belong to\n * `validate-flow-email-recipients`, which quotes them back verbatim; a tidied\n * copy would put words in the author's mouth on the screen where they are\n * trying to recognise their own mistake.\n */\nfunction tidyEmailRecipients(sideEffect: AnyRecord, path: string): Normalization[] {\n  if (sideEffect.type !== \"email\") return [];\n  const config = sideEffect.encryptedConfig;\n  // A string is the dashboard-configured half, encrypted; an object is the\n  // agent-authored half, which is the only one anybody can read.\n  if (!config || typeof config !== \"object\" || Array.isArray(config)) return [];\n  const raw = (config as AnyRecord).email;\n  if (typeof raw !== \"string\" || looksLikeUnresolvedVariable(raw)) return [];\n  const { to, invalid } = parseEmailRecipients(raw);\n  if (invalid.length > 0 || to.length === 0) return [];\n  const tidied = to.join(\", \");\n  if (tidied === raw) return [];\n  (config as AnyRecord).email = tidied;\n  return [{ path, change: \"tidied the recipient list's spacing and separators\" }];\n}\n\n/** Side effects of one node, skipping anything that is not an object to patch. */\nfunction sideEffectsOf(node: AnyRecord): AnyRecord[] {\n  if (!Array.isArray(node.sideEffects)) return [];\n  return (node.sideEffects as unknown[]).filter(\n    (sideEffect): sideEffect is AnyRecord => Boolean(sideEffect) && typeof sideEffect === \"object\",\n  );\n}\n\n/** Repairs to one side effect, reported against the step that owns it. */\nfunction normalizeSideEffect(sideEffect: AnyRecord, where: string): Normalization[] {\n  const path = `${where} → ${String(sideEffect.id ?? \"side effect\")}`;\n  const arrays = ARRAY_OWNERS.flatMap((owner) => {\n    const target = owner ? (sideEffect[owner] as AnyRecord | undefined) : sideEffect;\n    if (!target || typeof target !== \"object\") return [];\n    return fillNulledArrays(target, owner ? `${owner}.` : \"\", path);\n  });\n  return [...dropUnsetOptionals(sideEffect, path), ...arrays, ...tidyEmailRecipients(sideEffect, path)];\n}\n\n/** Fix a decoded tree in place. Returns one line per change, empty when already clean. */\nexport function normalizeFlowTree(tree: AnyRecord): Normalization[] {\n  const changes: Normalization[] = [];\n\n  for (const node of walkNodes(tree)) {\n    const where = typeof node.name === \"string\" && node.name ? String(node.name) : String(node.id ?? \"node\");\n\n    // The root node has no condition by definition; every other node needs the\n    // key present so a reader can tell \"always runs\" from \"nobody set this\".\n    if (!(\"condition\" in node)) {\n      node.condition = null;\n      changes.push({ path: where, change: \"added the missing `condition: null`\" });\n    }\n\n    // Filtered, not `?? []`: a hand-authored `sideEffects` can hold a null or a\n    // string, and reading `.id` off one throws inside the command that exists to\n    // repair a form file that is already slightly wrong.\n    for (const sideEffect of sideEffectsOf(node)) {\n      changes.push(...normalizeSideEffect(sideEffect, where));\n    }\n  }\n\n  return changes;\n}\n\nregisterSchema({\n  command: \"flows.normalize\",\n  description:\n    \"Fix the shapes a form file is allowed to get slightly wrong: a nulled optional string, a nulled array, a missing condition. Runs automatically before a commit; you rarely need to call it.\",\n  args: {\n    slug: { type: \"positional\", description: \"Form slug. Omit to check every form.\", required: false },\n    write: {\n      type: \"boolean\",\n      description: \"Apply the fixes. Without it, reports and changes nothing\",\n      required: false,\n    },\n  },\n});\n\nexport const normalizeCommand = defineCommand({\n  meta: {\n    name: \"normalize\",\n    description:\n      \"Repair the shapes a form file is allowed to get slightly wrong. Example: baker flows normalize contact --write\",\n  },\n  args: {\n    // `required: false` matters: citty makes a positional required by default,\n    // so without it the documented bare `baker flows normalize` printed a wall\n    // of usage text and exited 1 instead of checking every form.\n    slug: { type: \"positional\", description: \"Form slug (omit for every form)\", required: false },\n    write: { type: \"boolean\", description: \"Apply the fixes\" },\n  },\n  run: ({ args }) => {\n    const slugs = args.slug ? [String(args.slug)] : listFlowSlugs();\n    const forms = slugs.flatMap((slug) => {\n      const tree = readFlowTree(slug);\n      const changes = normalizeFlowTree(tree);\n      if (changes.length === 0) return [];\n      if (args.write === true) writeFlowTree(slug, tree);\n      return [{ slug, path: flowDataPath(slug), changes }];\n    });\n\n    const total = forms.reduce((sum, form) => sum + form.changes.length, 0);\n    writeJson({\n      ok: true,\n      data: { forms, changed: total, written: args.write === true },\n      hints:\n        total === 0\n          ? [\"Nothing to fix.\"]\n          : args.write === true\n            ? [`Fixed ${total} field(s).`]\n            : [`${total} field(s) can be fixed. Re-run with --write.`],\n    });\n  },\n});\n"],"mappings":"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","names":[]}