@zaip-ai/cli 6.2.0 → 7.5.0

package/templates/.agents/skills/zaip-skill-lead-measurement/scripts/check-questionnaire.mjs

@@ -0,0 +1,314 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  ast,
+  checkSchema,
+  equal,
+  keys,
+  LIMITS,
+  object,
+  own,
+  requireThat,
+  safeCode,
+  scalar,
+  schema,
+  shape,
+  validDate,
+} from "./questionnaire-validation.mjs";
+
+export { checkSchema, LIMITS } from "./questionnaire-validation.mjs";
+export function validateQuestionnaire(doc) {
+  shape(doc, schema);
+  requireThat(safeCode(doc.company.code) && safeCode(doc.policy.code), "code", "company/policy");
+  requireThat(validDate(doc.approval.date), "approval_date", "approval");
+  requireThat(
+    doc.policy.questionnaire_version === doc.versions.questionnaire,
+    "version_mismatch",
+    "questionnaire",
+  );
+  const codes = new Set();
+  let branches = 0;
+  doc.questions.forEach((q, index) => {
+    requireThat(safeCode(q.code) && !codes.has(q.code), "question_code", q.code);
+    codes.add(q.code);
+    const choice = ["single_choice", "multi_choice"].includes(q.type);
+    requireThat(choice === own(q, "options"), "question_options", q.code);
+    if (choice)
+      requireThat(
+        q.options.every((o) => safeCode(o.code)) &&
+          new Set(q.options.map((o) => o.code)).size === q.options.length,
+        "option_code",
+        q.code,
+      );
+    requireThat(
+      (q.type === "multi_choice") === own(q, "max_selections"),
+      "selection_limit",
+      q.code,
+    );
+    requireThat((q.type === "text") === own(q, "max_length"), "text_limit", q.code);
+    requireThat(
+      (q.type === "number") === (own(q, "minimum") && own(q, "maximum")) &&
+        (q.type === "number" || (!own(q, "minimum") && !own(q, "maximum"))),
+      "number_limits",
+      q.code,
+    );
+    if (q.type === "number")
+      requireThat(
+        q.minimum <= q.maximum && typeof q.unit === "string" && q.unit.trim(),
+        "number_unit",
+        q.code,
+      );
+    if (own(q, "currency"))
+      requireThat(q.type === "number" && /^[A-Z]{3}$/.test(q.currency), "currency", q.code);
+    if (q.required_when) {
+      requireThat(++branches <= LIMITS.branches, "branch_limit", q.code);
+      ast(q.required_when, doc.questions.slice(0, index));
+    }
+  });
+  ast(doc.policy.expression_ast, doc.questions);
+  if (doc.aliases) {
+    keys(doc.aliases, ["field", "event_prefix", "authority_types"], "aliases");
+    const { field, event_prefix, authority_types } = doc.aliases;
+    requireThat(
+      Object.keys(doc.aliases).length === 3 &&
+        object(field) &&
+        Object.keys(field).length === 1 &&
+        own(field, "autority") &&
+        field.autority === "authority" &&
+        object(event_prefix) &&
+        Object.keys(event_prefix).length === 1 &&
+        own(event_prefix, "Autority_") &&
+        event_prefix.Autority_ === "authority" &&
+        equal(authority_types, ["sole", "shared", "researcher", "owner_approval"]),
+      "alias_contract",
+      "aliases",
+    );
+    requireThat(codes.has("authority"), "alias_target", "authority");
+  }
+  const kinds = new Set(doc.cases.map((c) => c.kind));
+  requireThat(
+    ["positive", "negative", "boundary", "override"].every((k) => kinds.has(k)),
+    "case_coverage",
+    doc.policy.code,
+  );
+  requireThat(
+    new Set(doc.cases.map((c) => c.id)).size === doc.cases.length,
+    "case_id",
+    doc.policy.code,
+  );
+  return true;
+}
+function validateAnswers(doc, answers) {
+  keys(
+    answers,
+    doc.questions.map((q) => q.code),
+    "answers",
+  );
+  for (const [code, a] of Object.entries(answers)) {
+    keys(a, ["state", "value"], code);
+    requireThat(
+      own(a, "state") &&
+        own(a, "value") &&
+        ["answered", "unknown", "not_applicable", "withheld"].includes(a.state),
+      "answer_state",
+      code,
+    );
+    if (a.state !== "answered") {
+      requireThat(a.value === null, "answer_null", code);
+      continue;
+    }
+    const q = doc.questions.find((x) => x.code === code);
+    if (q.type === "multi_choice")
+      requireThat(
+        Array.isArray(a.value) &&
+          a.value.length > 0 &&
+          a.value.length <= q.max_selections &&
+          new Set(a.value).size === a.value.length &&
+          a.value.every((v) => q.options.some((o) => o.code === v)),
+        "answer_multi",
+        code,
+      );
+    else requireThat(scalar(q, a.value), "answer_type", code);
+  }
+}
+function expression(node, answers) {
+  if (node.args) {
+    const parts = node.args.map((n) => expression(n, answers));
+    const reasons = parts.flatMap((p) => p.reasons);
+    if (reasons.length) return { value: null, reasons };
+    const values = parts.map((p) => p.value);
+    return {
+      value:
+        node.op === "all"
+          ? values.every(Boolean)
+          : node.op === "any"
+            ? values.some(Boolean)
+            : !values[0],
+      reasons: [],
+    };
+  }
+  const a = answers[node.question];
+  if (!a || a.state !== "answered")
+    return { value: null, reasons: [{ question: node.question, state: a?.state ?? "missing" }] };
+  const v = a.value;
+  const results = {
+    eq: () => v === node.value,
+    in: () => node.value.includes(v),
+    contains: () => v.includes(node.value),
+    gte: () => v >= node.value,
+    lte: () => v <= node.value,
+  };
+  return { value: results[node.op](), reasons: [] };
+}
+export function evaluate(doc, input) {
+  validateQuestionnaire(doc);
+  keys(input, ["answers", "receipt_accepted", "manual_override", "authority_type"], "input");
+  requireThat(typeof input.receipt_accepted === "boolean", "receipt_type", "receipt_accepted");
+  if (own(input, "authority_type"))
+    requireThat(
+      ["sole", "shared", "researcher", "owner_approval"].includes(input.authority_type),
+      "authority_type",
+      "input",
+    );
+  validateAnswers(doc, input.answers);
+  let profile = true;
+  const reasons = [];
+  for (const q of doc.questions) {
+    const branch = q.required_when
+      ? expression(q.required_when, input.answers)
+      : { value: true, reasons: [] };
+    const a = input.answers[q.code];
+    if (branch.value === false) {
+      requireThat(a?.state !== "answered", "inactive_answer", q.code);
+      continue;
+    }
+    if (q.required && (branch.value === null || a?.state !== "answered")) {
+      profile = false;
+      reasons.push(...branch.reasons, { question: q.code, state: a?.state ?? "missing" });
+    }
+  }
+  const result = expression(doc.policy.expression_ast, input.answers);
+  const automatic =
+    !input.receipt_accepted || !profile || result.value === null
+      ? "pending"
+      : result.value
+        ? "qualified"
+        : "not_qualified";
+  let outcome = automatic;
+  let override = null;
+  if (input.manual_override) {
+    const o = input.manual_override;
+    keys(o, ["id", "owner", "reason", "rule_version", "outcome", "simulated"], "override");
+    requireThat(
+      safeCode(o.id) &&
+        typeof o.owner === "string" &&
+        o.owner.trim().length > 0 &&
+        o.owner.length <= 100 &&
+        typeof o.reason === "string" &&
+        o.reason.trim().length > 0 &&
+        o.reason.length <= 500 &&
+        o.simulated === true &&
+        o.rule_version === doc.versions.rule &&
+        ["qualified", "not_qualified", "human_review"].includes(o.outcome),
+      "override_invalid",
+      "override",
+    );
+    requireThat(input.receipt_accepted, "override_receipt", "override");
+    override = { ...o };
+    outcome = o.outcome;
+  }
+  return {
+    cadastro: input.receipt_accepted,
+    profile,
+    outcome,
+    automatic,
+    uncertainty: [...reasons, ...result.reasons],
+    versions: { ...doc.versions },
+    override,
+  };
+}
+export function checkFixture(doc) {
+  validateQuestionnaire(doc);
+  for (const c of doc.cases) {
+    const { id, kind, expected, ...input } = c;
+    const result = evaluate(doc, input);
+    requireThat(
+      Object.entries(expected).every(([k, v]) => result[k] === v),
+      "case_expected",
+      id,
+    );
+    if (kind === "override") requireThat(Boolean(result.override), "case_override", id);
+  }
+  return doc.cases.length;
+}
+export function checkMoradigna(doc) {
+  const expected = {
+    budget: ["5k", "10k", "20k", "30k", "40k", "50k", "over_50k"],
+    timing: ["7d", "15d", "30d", "60d", "90d", "180d", "over_180d"],
+    need: ["1", "2", "3", "4", "5", "over_5"],
+    authority: ["yes", "no"],
+  };
+  requireThat(
+    doc.questions.length === 4 && doc.company.code === "moradigna_regression_synthetic",
+    "moradigna_questions",
+    "fixture",
+  );
+  for (const [code, options] of Object.entries(expected))
+    requireThat(
+      equal(
+        doc.questions.find((q) => q.code === code)?.options.map((o) => o.code),
+        options,
+      ),
+      "moradigna_options",
+      code,
+    );
+  requireThat(Boolean(doc.aliases), "moradigna_aliases", "fixture");
+  requireThat(
+    doc.cases.some(
+      (c) =>
+        c.authority_type === "shared" &&
+        c.answers.authority?.value === "no" &&
+        c.expected.outcome === "qualified",
+    ),
+    "moradigna_shared",
+    "fixture",
+  );
+}
+export function main(args = process.argv.slice(2)) {
+  requireThat(equal(args, ["--check"]), "usage", "check-questionnaire.mjs --check");
+  checkSchema();
+  const folder = new URL("../references/examples/", import.meta.url);
+  const files = readdirSync(folder)
+    .filter((f) => f.endsWith(".json"))
+    .sort();
+  requireThat(
+    ["solar.json", "escola.json", "moradigna-regression.json"].every((f) => files.includes(f)),
+    "fixture_missing",
+    "examples",
+  );
+  let cases = 0;
+  for (const file of files) {
+    const doc = JSON.parse(readFileSync(new URL(file, folder), "utf8"));
+    cases += checkFixture(doc);
+    if (file === "moradigna-regression.json") checkMoradigna(doc);
+  }
+  console.log(
+    JSON.stringify({
+      status: "passed",
+      schema: 2,
+      fixtures: files.length,
+      cases,
+      activation: false,
+    }),
+  );
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    main();
+  } catch (e) {
+    console.error(e.message);
+    process.exitCode = 1;
+  }
+}

package/templates/.agents/skills/zaip-skill-lead-measurement/scripts/check-questionnaire.test.mjs

@@ -0,0 +1,338 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  checkFixture,
+  checkMoradigna,
+  checkSchema,
+  evaluate,
+  validateQuestionnaire,
+} from "./check-questionnaire.mjs";
+import { registerQuestionnaireAstCases } from "./questionnaire-ast-cases.mjs";
+import {
+  answer,
+  copy,
+  input,
+  load,
+  rejectAnswer,
+  rejectDoc,
+  run,
+} from "./questionnaire-test-support.mjs";
+
+test("schema and all synthetic policies execute positive/negative/boundary/override cases", () => {
+  assert.equal(checkSchema(), true);
+  for (const name of ["solar", "escola", "moradigna-regression"]) {
+    const d = load(name);
+    assert.equal(checkFixture(d), name === "moradigna-regression" ? 4 : 5);
+    assert.equal(run(d).outcome, "qualified");
+    assert.equal(
+      run(
+        d,
+        d.cases.find((c) => c.kind === "negative"),
+      ).outcome,
+      "not_qualified",
+    );
+    assert.equal(
+      run(
+        d,
+        d.cases.find((c) => c.kind === "boundary"),
+      ).outcome,
+      "qualified",
+    );
+    const o = run(
+      d,
+      d.cases.find((c) => c.kind === "override"),
+    );
+    assert.equal(o.outcome, "human_review");
+    assert.equal(o.automatic, "pending");
+  }
+});
+test("different company counts, units and independent versions do not collapse", () => {
+  const a = load("solar"),
+    b = load("escola");
+  assert.equal(a.questions.length, 5);
+  assert.equal(b.questions.length, 6);
+  assert.equal(a.questions[0].unit, "BRL/projeto");
+  assert.equal(b.questions[0].unit, "BRL/mês");
+  assert.notDeepEqual(a.versions, b.versions);
+  const result = run(a);
+  assert.deepEqual(result.versions, a.versions);
+  result.versions.mapping = 99;
+  assert.equal(a.versions.mapping, 1);
+});
+test("draft opt-in and simulated commercial review cannot authorize adoption", () => {
+  for (const [key, value] of [
+    ["status", "active"],
+    ["synthetic", false],
+    ["opt_in", false],
+    ["adoption_authorized", true],
+  ]) {
+    rejectDoc((d) => {
+      d[key] = value;
+    }, /const/);
+  }
+  rejectDoc((d) => {
+    d.approval.simulated = false;
+  }, /const/);
+  rejectDoc((d) => {
+    delete d.approval.reviewer;
+  }, /required/);
+  rejectDoc((d) => {
+    d.approval.date = "2026-02-30";
+  }, /approval_date/);
+});
+test("Moradigna preserves all 22 codes, aliases and authority types; shared no qualifies", () => {
+  const d = load("moradigna-regression");
+  checkMoradigna(d);
+  assert.deepEqual(
+    d.questions.map((q) => q.options.length),
+    [7, 7, 6, 2],
+  );
+  assert.equal(
+    d.questions.reduce((n, q) => n + q.options.length, 0),
+    22,
+  );
+  assert.equal(d.aliases.field.autority, "authority");
+  assert.equal(d.aliases.event_prefix.Autority_, "authority");
+  for (const authority_type of ["sole", "shared", "researcher", "owner_approval"]) {
+    const i = input(d.cases[0]);
+    i.authority_type = authority_type;
+    assert.equal(evaluate(d, i).outcome, "qualified");
+  }
+  const changed = copy(d);
+  changed.questions[0].options.pop();
+  assert.throws(() => checkMoradigna(changed), /moradigna_options/);
+  delete d.aliases;
+  assert.throws(() => checkMoradigna(d), /moradigna_aliases/);
+});
+test("alias dictionary property permutations preserve the same valid contract", () => {
+  for (const order of [
+    ["authority_types", "event_prefix", "field"],
+    ["event_prefix", "field", "authority_types"],
+    ["field", "authority_types", "event_prefix"],
+  ]) {
+    const d = load("moradigna-regression");
+    d.aliases = Object.fromEntries(order.map((k) => [k, d.aliases[k]]));
+    assert.equal(validateQuestionnaire(d), true);
+    assert.equal(checkFixture(d), 4);
+    assert.equal(run(d).outcome, "qualified");
+  }
+});
+test("alias values, exact keys and ordered four authority types remain enforced", () => {
+  for (const mutate of [
+    (a) => {
+      a.field.autority = "wrong";
+    },
+    (a) => {
+      a.event_prefix.Autority_ = "wrong";
+    },
+    (a) => {
+      a.extra = "authority";
+    },
+    (a) => {
+      a.field.extra = "authority";
+    },
+    (a) => {
+      a.event_prefix.extra = "authority";
+    },
+    (a) => {
+      delete a.field;
+    },
+    (a) => {
+      a.field = { authority: "authority" };
+    },
+    (a) => {
+      a.event_prefix = { Authority_: "authority" };
+    },
+    (a) => {
+      a.authority_types.reverse();
+    },
+    (a) => {
+      a.authority_types.pop();
+    },
+    (a) => {
+      a.authority_types.push("other");
+    },
+  ]) {
+    const d = load("moradigna-regression");
+    mutate(d.aliases);
+    assert.throws(() => validateQuestionnaire(d), /alias_contract|keys/);
+  }
+});
+test("numeric boundaries discriminate threshold and units without coercion", () => {
+  const d = load("solar"),
+    i = input(d.cases[2]);
+  for (const [budget, timing, expected] of [
+    [10000, 60, "qualified"],
+    [9999, 60, "not_qualified"],
+    [10000, 61, "not_qualified"],
+    [10001, 59, "qualified"],
+  ]) {
+    i.answers.budget = answer(budget);
+    i.answers.timing = answer(timing);
+    assert.equal(evaluate(d, i).outcome, expected);
+  }
+  for (const value of ["10000", true, null, NaN, Infinity, -1, 1000001])
+    rejectAnswer((i) => {
+      i.answers.budget = answer(value);
+    }, /answer_type/);
+});
+test("all nonanswered states retain typed uncertainty; absence is missing", () => {
+  const d = load("solar");
+  for (const state of ["unknown", "not_applicable", "withheld", "missing"]) {
+    const i = input(d.cases[0]);
+    if (state === "missing") delete i.answers.budget;
+    else i.answers.budget = { state, value: null };
+    const result = evaluate(d, i);
+    assert.equal(result.outcome, "pending");
+    assert.equal(result.profile, false);
+    assert.ok(result.uncertainty.some((r) => r.question === "budget" && r.state === state));
+  }
+  for (const state of ["unknown", "not_applicable", "withheld"])
+    rejectAnswer((i) => {
+      i.answers.budget = { state, value: 0 };
+    }, /answer_null/);
+  rejectAnswer((i) => {
+    i.answers.budget = { state: "absent", value: null };
+  }, /answer_state/);
+});
+test("multi_choice validates enum, unique values, type, count and positive containment", () => {
+  for (const value of [
+    "solar",
+    [],
+    ["solar", "solar"],
+    ["injected"],
+    ["solar", "maintenance", "third"],
+  ]) {
+    rejectAnswer((i) => {
+      i.answers.need = answer(value);
+    }, /answer_multi/);
+  }
+  const d = load("solar"),
+    i = input(d.cases[0]);
+  i.answers.need = answer(["maintenance"]);
+  i.answers.capacity = { state: "not_applicable", value: null };
+  assert.equal(evaluate(d, i).outcome, "not_qualified");
+});
+test("branch is prior-only, inactive answered invalid, false branch permits not applicable", () => {
+  const d = load("escola");
+  assert.equal(run(d, d.cases[1]).profile, true);
+  const i = input(d.cases[1]);
+  i.answers.start = answer("2027-01-01");
+  assert.throws(() => evaluate(d, i), /inactive_answer/);
+  rejectDoc((d) => {
+    d.questions[0].required_when = { op: "gte", question: "capacity", value: 1 };
+  }, /ast_reference/);
+  rejectDoc((d) => {
+    d.questions[4].required_when = { op: "gte", question: "capacity", value: 1 };
+  }, /ast_reference/);
+});
+test("unknown branch is pending and cannot bypass a required answer", () => {
+  const d = load("solar"),
+    i = input(d.cases[0]);
+  i.answers.need = { state: "unknown", value: null };
+  i.answers.capacity = { state: "not_applicable", value: null };
+  const result = evaluate(d, i);
+  assert.equal(result.profile, false);
+  assert.equal(result.outcome, "pending");
+  assert.ok(result.uncertainty.some((r) => r.question === "need" && r.state === "unknown"));
+});
+test("cadastro receipt, profile and commercial outcome are independent facts", () => {
+  const d = load("solar"),
+    i = input(d.cases[0]);
+  i.receipt_accepted = false;
+  assert.deepEqual(Object.fromEntries(Object.entries(evaluate(d, i)).slice(0, 3)), {
+    cadastro: false,
+    profile: true,
+    outcome: "pending",
+  });
+  i.receipt_accepted = true;
+  delete i.answers.capacity;
+  const result = evaluate(d, i);
+  assert.equal(result.cadastro, true);
+  assert.equal(result.profile, false);
+  assert.equal(result.outcome, "pending");
+  rejectAnswer((i) => {
+    i.receipt_accepted = "true";
+  }, /receipt_type/);
+});
+test("versions fail closed and approval cannot be inferred from defaults", () => {
+  rejectDoc((d) => {
+    d.versions.contract = 1;
+  }, /const/);
+  rejectDoc((d) => {
+    d.versions.rule = 0;
+  }, /minimum/);
+  rejectDoc((d) => {
+    d.policy.questionnaire_version++;
+  }, /version_mismatch/);
+  rejectDoc((d) => {
+    delete d.versions.consent;
+  }, /required/);
+  rejectDoc((d) => {
+    d.questions[0].default = 10000;
+  }, /keys/);
+});
+registerQuestionnaireAstCases();
+
+test("date validation distinguishes calendar dates including leap years", () => {
+  const d = load("escola"),
+    i = input(d.cases[0]);
+  for (const value of ["2027-02-29", "2028-02-30", "2027-13-01", "2027-1-01", 20270101]) {
+    i.answers.start = answer(value);
+    assert.throws(() => evaluate(d, i), /answer_type/);
+  }
+  i.answers.start = answer("2028-02-29");
+  assert.equal(evaluate(d, i).outcome, "qualified");
+});
+test("override is versioned, explicit, simulated and cannot repair invalid contract", () => {
+  const d = load("solar"),
+    c = d.cases.find((c) => c.kind === "override");
+  for (const change of [
+    (o) => {
+      o.owner = "";
+    },
+    (o) => {
+      o.reason = "";
+    },
+    (o) => {
+      o.rule_version++;
+    },
+    (o) => {
+      o.outcome = "yes";
+    },
+    (o) => {
+      o.simulated = false;
+    },
+  ]) {
+    const i = input(c);
+    change(i.manual_override);
+    assert.throws(() => evaluate(d, i), /override_invalid/);
+  }
+  const i = input(c);
+  i.receipt_accepted = false;
+  assert.throws(() => evaluate(d, i), /override_receipt/);
+  d.policy.expression_ast = { op: "eval", question: "budget", value: 10000 };
+  assert.throws(() => run(d, c), /ast_operator/);
+});
+test("evaluation and override preserve immutable input snapshots", () => {
+  const d = load("solar"),
+    i = input(d.cases[3]),
+    before = JSON.stringify({ d, i });
+  const first = evaluate(d, i);
+  const second = evaluate(d, i);
+  assert.deepEqual(first, second);
+  assert.equal(JSON.stringify({ d, i }), before);
+  first.override.reason = "changed";
+  first.uncertainty.push({ state: "changed" });
+  assert.equal(JSON.stringify({ d, i }), before);
+  assert.notDeepEqual(first, second);
+});
+test("static fixture checking detects incorrect expected policy outcome and missing case categories", () => {
+  const d = load("solar");
+  d.cases[0].expected.outcome = "not_qualified";
+  assert.throws(() => checkFixture(d), /case_expected/);
+  rejectDoc((d) => {
+    d.cases = d.cases.filter((c) => c.kind !== "boundary");
+  }, /case_coverage/);
+  assert.throws(() => checkSchema({ type: "object", patternProperties: {} }), /keys/);
+});