@abelxiaoxing/cadence 1.8.4 → 2.0.1

package/src/change-contract-schema.ts

@@ -1,191 +0,0 @@
-import { Type } from "typebox";
-import { Value } from "typebox/value";
-import {
-  isValidRelativePath,
-  VERIFICATION_LIMITS,
-  validateVerificationContract,
-} from "./contracts.ts";
-import type { DesignPlanDiagnostic } from "./design-diagnostics.ts";
-
-const text = Type.String({ minLength: 1, maxLength: 8192, pattern: "\\S" });
-const id = Type.String({ pattern: "^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$" });
-const object = <T extends Parameters<typeof Type.Object>[0]>(properties: T) =>
-  Type.Object(properties, { additionalProperties: false });
-const managers = Type.Union([
-  Type.Literal("bun"),
-  Type.Literal("npm"),
-  Type.Literal("pnpm"),
-  Type.Literal("yarn"),
-]);
-const packageRunner = {
-  kind: Type.Literal("package-script"),
-  packageManager: managers,
-  script: text,
-  command: text,
-};
-const executable = Type.Union([
-  object(packageRunner),
-  object({ kind: Type.Literal("local-binary"), executable: text }),
-  object({
-    kind: Type.Literal("npx"),
-    executable: text,
-    noInstall: Type.Literal(true),
-  }),
-]);
-const classification = Type.Union([
-  Type.Literal("expected-red"),
-  Type.Literal("expected-green"),
-  Type.Literal("expected-refactor"),
-]);
-const base = {
-  id,
-  classification,
-  expectedFailure: Type.Optional(Type.String({ minLength: 1, maxLength: 512 })),
-  executionBindings: Type.Optional(
-    Type.Record(Type.String(), Type.Union([Type.String(), Type.Null()])),
-  ),
-};
-const args = Type.Array(Type.String(), { maxItems: 128 });
-export const ATOMIC_VERIFICATION_SCHEMAS = {
-  vitest: object({
-    ...base,
-    kind: Type.Literal("vitest"),
-    runner: executable,
-    testFiles: Type.Array(text, {
-      minItems: VERIFICATION_LIMITS.minTestFiles,
-      maxItems: VERIFICATION_LIMITS.maxTestFiles,
-      uniqueItems: true,
-    }),
-    args,
-    minTests: Type.Integer({ minimum: 1 }),
-  }),
-  "package-script": object({ ...base, ...packageRunner, args }),
-  "static-check": object({
-    ...base,
-    kind: Type.Literal("static-check"),
-    runner: Type.Union([
-      executable,
-      object({ kind: Type.Literal("node"), script: text }),
-    ]),
-    args,
-  }),
-};
-const atomic = Type.Union(Object.values(ATOMIC_VERIFICATION_SCHEMAS));
-const steps = object({
-  kind: Type.Literal("steps"),
-  id,
-  classification,
-  steps: Type.Array(atomic, {
-    minItems: VERIFICATION_LIMITS.minSteps,
-    maxItems: VERIFICATION_LIMITS.maxSteps,
-  }),
-});
-export const VERIFICATION_SCHEMA = Type.Union([atomic, steps]);
-export const CHANGE_CONTRACT_SCHEMA = object({
-  goal: text,
-  acceptance: Type.Array(
-    object({ id, statement: text, verification: VERIFICATION_SCHEMA }),
-    { minItems: 1, maxItems: 256 },
-  ),
-  constraints: Type.Array(object({ id, statement: text }), { maxItems: 256 }),
-  policy: object({
-    writeRoots: Type.Array(text, {
-      minItems: 1,
-      maxItems: 256,
-      uniqueItems: true,
-    }),
-    dependencies: Type.Array(text, { maxItems: 256, uniqueItems: true }),
-    verificationModes: Type.Array(
-      Type.Union([
-        Type.Literal("behavior"),
-        Type.Literal("mechanical"),
-        Type.Literal("refactor"),
-      ]),
-      { minItems: 1, maxItems: 256, uniqueItems: true },
-    ),
-  }),
-});
-function record(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-const schemaFields = new Set([
-  "goal",
-  "acceptance",
-  "id",
-  "statement",
-  "verification",
-  "constraints",
-  "policy",
-  "writeRoots",
-  "dependencies",
-  "verificationModes",
-  "classification",
-  "expectedFailure",
-  "executionBindings",
-  "kind",
-  "runner",
-  "packageManager",
-  "script",
-  "command",
-  "executable",
-  "noInstall",
-  "testFiles",
-  "args",
-  "minTests",
-  "steps",
-]);
-function diagnosticField(pointer: string): string {
-  const fields = ["contract"];
-  for (const part of pointer.split("/").slice(1)) {
-    if (!schemaFields.has(part) && !/^(0|[1-9][0-9]{0,5})$/u.test(part)) break;
-    fields.push(part);
-    // Binding keys are author data, even when they happen to look like schema fields.
-    if (part === "executionBindings") break;
-  }
-  return fields.join(".");
-}
-
-/** Shared shape, bounded field-only diagnostics; never return submitted values or parser messages. */
-export function changeContractDiagnostics(
-  value: unknown,
-): DesignPlanDiagnostic[] {
-  const diagnostics: DesignPlanDiagnostic[] = Value.Errors(
-    CHANGE_CONTRACT_SCHEMA,
-    value,
-  )
-    .slice(0, 32)
-    .map((error) => ({
-      code: "change-contract-field-invalid",
-      field: diagnosticField(error.instancePath),
-      category: error.keyword,
-    }));
-  if (!record(value)) return diagnostics;
-  if (Array.isArray(value.acceptance))
-    value.acceptance.slice(0, 256).forEach((item, index) => {
-      if (!record(item)) return;
-      const verification = item.verification;
-      if (!validateVerificationContract(verification).ok) {
-        const field = `contract.acceptance.${index}.verification`;
-        if (
-          record(verification) &&
-          verification.classification === "expected-red" &&
-          typeof verification.expectedFailure !== "string"
-        )
-          diagnostics.push({
-            code: "change-contract-field-invalid",
-            field: `${field}.expectedFailure`,
-          });
-        else diagnostics.push({ code: "change-contract-field-invalid", field });
-      }
-    });
-  if (record(value.policy) && Array.isArray(value.policy.writeRoots))
-    value.policy.writeRoots.slice(0, 256).forEach((root, index) => {
-      if (root !== "." && !isValidRelativePath(root))
-        diagnostics.push({
-          code: "change-contract-field-invalid",
-          field: `contract.policy.writeRoots.${index}`,
-        });
-    });
-  return diagnostics.slice(0, 32);
-}

package/src/change-contract.ts

@@ -1,324 +0,0 @@
-import { changeContractDiagnostics } from "./change-contract-schema.ts";
-import {
-  type ImplementTaskBoundary,
-  isValidRelativePath,
-  type StructuredVerificationContract,
-  validateVerificationContract,
-  verificationInputPaths,
-} from "./contracts.ts";
-import {
-  type DesignPlanDiagnostic,
-  DesignPlanValidationError,
-} from "./design-diagnostics.ts";
-import { canonicalJson } from "./run-state.ts";
-
-export interface ChangeContract {
-  goal: string;
-  acceptance: Array<{
-    id: string;
-    statement: string;
-    verification: StructuredVerificationContract;
-  }>;
-  constraints: Array<{ id: string; statement: string }>;
-  policy: {
-    writeRoots: string[];
-    dependencies: string[];
-    verificationModes: Array<"behavior" | "mechanical" | "refactor">;
-  };
-}
-
-function record(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function keys(value: Record<string, unknown>, expected: string[]) {
-  return (
-    canonicalJson(Object.keys(value).sort()) === canonicalJson(expected.sort())
-  );
-}
-function text(value: unknown): value is string {
-  return (
-    typeof value === "string" && value.trim().length > 0 && value.length <= 8192
-  );
-}
-const identifier = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/u;
-
-export function normalizeChangeContract(value: unknown): ChangeContract {
-  const diagnostics = changeContractDiagnostics(value);
-  if (diagnostics.length)
-    throw new DesignPlanValidationError("change-contract-invalid", diagnostics);
-  if (
-    !record(value) ||
-    !keys(value, ["goal", "acceptance", "constraints", "policy"]) ||
-    !text(value.goal) ||
-    !Array.isArray(value.acceptance) ||
-    value.acceptance.length < 1 ||
-    value.acceptance.length > 256 ||
-    !Array.isArray(value.constraints) ||
-    value.constraints.length > 256 ||
-    !record(value.policy)
-  )
-    throw new Error("change-contract-invalid");
-  const entries = (values: unknown[], acceptance: boolean) =>
-    values
-      .map((entry) => {
-        if (
-          !record(entry) ||
-          !keys(
-            entry,
-            acceptance
-              ? ["id", "statement", "verification"]
-              : ["id", "statement"],
-          ) ||
-          typeof entry.id !== "string" ||
-          !identifier.test(entry.id) ||
-          !text(entry.statement)
-        )
-          throw new Error("change-contract-invalid");
-        const verification = acceptance
-          ? validateVerificationContract(entry.verification)
-          : undefined;
-        if (verification && !verification.ok)
-          throw new Error("change-contract-invalid");
-        return {
-          id: entry.id,
-          statement: entry.statement.replace(/\r\n?/gu, "\n").trim(),
-          ...(verification?.ok ? { verification: verification.value } : {}),
-        };
-      })
-      .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-  const acceptance = entries(value.acceptance, true);
-  const constraints = entries(value.constraints, false);
-  for (const group of [acceptance, constraints])
-    if (new Set(group.map((item) => item.id)).size !== group.length)
-      throw new Error("change-contract-invalid");
-  const policy = value.policy;
-  if (!keys(policy, ["writeRoots", "dependencies", "verificationModes"]))
-    throw new Error("change-contract-invalid");
-  for (const key of ["writeRoots", "dependencies", "verificationModes"])
-    if (
-      !Array.isArray(policy[key]) ||
-      policy[key].length > 256 ||
-      !policy[key].every(text) ||
-      new Set(policy[key]).size !== policy[key].length
-    )
-      throw new Error("change-contract-invalid");
-  const roots = policy.writeRoots as string[];
-  const modes = policy.verificationModes as string[];
-  if (
-    !roots.length ||
-    !roots.every((root) => root === "." || isValidRelativePath(root)) ||
-    !modes.length ||
-    !modes.every((mode) =>
-      ["behavior", "mechanical", "refactor"].includes(mode),
-    )
-  )
-    throw new Error("change-contract-invalid");
-  const result = {
-    goal: value.goal.replace(/\r\n?/gu, "\n").trim(),
-    acceptance,
-    constraints,
-    policy: {
-      writeRoots: [...roots].sort(),
-      dependencies: [...(policy.dependencies as string[])].sort(),
-      verificationModes: [...modes].sort(),
-    },
-  } as ChangeContract;
-  if (Buffer.byteLength(canonicalJson(result)) > 64 * 1024)
-    throw new Error("change-contract-invalid");
-  return result;
-}
-
-/** Display identities and fresh input bindings do not change a verification obligation. */
-export function verificationObligation(
-  value: StructuredVerificationContract,
-): string {
-  const strip = (item: unknown): unknown =>
-    Array.isArray(item)
-      ? item.map(strip)
-      : record(item)
-        ? Object.fromEntries(
-            Object.entries(item)
-              .filter(([key]) => !["id", "executionBindings"].includes(key))
-              .map(([key, child]) => [key, strip(child)]),
-          )
-        : item;
-  return canonicalJson(strip(value));
-}
-
-export function assertPlanWithinChangeContract(
-  contract: ChangeContract,
-  tasks: readonly (ImplementTaskBoundary & {
-    verificationMode?: string;
-    affectedVerification: StructuredVerificationContract;
-    repairVerification: StructuredVerificationContract;
-  })[],
-  verifications: readonly StructuredVerificationContract[],
-): void {
-  const candidates = [
-    ...verifications,
-    ...tasks.flatMap((task) => [
-      task.affectedVerification,
-      ...Object.entries(task.phases)
-        .filter(
-          ([phase]) =>
-            phase !== "red" ||
-            !task.verificationMode ||
-            task.verificationMode === "behavior",
-        )
-        .map(([, phase]) => phase.verification),
-    ]),
-  ];
-  const available = new Set(candidates.map(verificationObligation));
-  const diagnostics: DesignPlanDiagnostic[] = [];
-  for (const [index, accepted] of contract.acceptance.entries()) {
-    if (available.has(verificationObligation(accepted.verification))) continue;
-    // Only attribute a mismatch when the display ID selects one distinct
-    // obligation. Never guess a "closest" verifier or echo command/argument bytes.
-    const matching = [
-      ...new Set(
-        candidates
-          .filter((candidate) => candidate.id === accepted.verification.id)
-          .map(verificationObligation),
-      ),
-    ];
-    const expected = JSON.parse(verificationObligation(accepted.verification));
-    const actual =
-      matching.length === 1 && matching[0]
-        ? JSON.parse(matching[0])
-        : undefined;
-    diagnostics.push({
-      code: "change-contract-acceptance-missing",
-      acceptanceId: accepted.id,
-      verificationId: accepted.verification.id,
-      field: `changeContract.acceptance.${index}.verification`,
-      ...(actual
-        ? {
-            mismatchedFields: [
-              "kind",
-              "runner",
-              "packageManager",
-              "script",
-              "command",
-              "args",
-              "testFiles",
-              "minTests",
-              "classification",
-              "expectedFailure",
-              "steps",
-            ]
-              .filter(
-                (key) =>
-                  canonicalJson(expected[key] ?? null) !==
-                  canonicalJson(actual[key] ?? null),
-              )
-              .sort(),
-          }
-        : {}),
-    });
-  }
-  if (diagnostics.length)
-    throw new DesignPlanValidationError(
-      "change-contract-acceptance-missing",
-      diagnostics,
-    );
-  for (const task of tasks) {
-    if (
-      !contract.policy.verificationModes.includes(
-        (task.verificationMode ?? "behavior") as "behavior",
-      )
-    )
-      throw new Error("change-contract-verification-mode");
-    if (
-      task.approvedDependencies.some(
-        (name) => !contract.policy.dependencies.includes(name),
-      )
-    )
-      throw new Error("change-contract-dependency-outside-policy");
-    if (
-      task.agents &&
-      task.agents.impact !== "none" &&
-      !contract.policy.writeRoots.includes(task.agents.target ?? "")
-    )
-      throw new Error("change-contract-agents-outside-policy");
-    const mode = task.verificationMode ?? "behavior";
-    const writes = Object.entries(task.phases)
-      .filter(([phase]) => phase !== "red" || mode === "behavior")
-      .flatMap(([, phase]) => [...phase.write, ...phase.delete]);
-    if (
-      mode !== "behavior" &&
-      task.impactClosure?.changedSurfaces.some((surface) => surface !== "none")
-    )
-      throw new Error("change-contract-behavior-requires-red");
-    if (
-      mode === "mechanical" &&
-      writes.some((file) => !/\.(?:md|txt|json|ya?ml|toml|lock)$/iu.test(file))
-    )
-      throw new Error("change-contract-mechanical-path");
-    if (
-      mode === "refactor" &&
-      contract.acceptance.some((accepted) =>
-        verificationInputPaths(accepted.verification).some((file) =>
-          writes.includes(file),
-        ),
-      )
-    )
-      throw new Error("change-contract-refactor-verification-mutation");
-    for (const phase of Object.values(task.phases))
-      for (const file of [...phase.write, ...phase.delete])
-        if (
-          !contract.policy.writeRoots.some(
-            (root) =>
-              root === "." || file === root || file.startsWith(`${root}/`),
-          )
-        )
-          throw new Error("change-contract-write-outside-policy");
-  }
-}
-
-export function retainedChangeContract(plan: {
-  changeContract?: ChangeContract;
-  changeId: string;
-  tasks: readonly (ImplementTaskBoundary & {
-    affectedVerification: StructuredVerificationContract;
-  })[];
-  verification: {
-    change: {
-      fullSuite: StructuredVerificationContract;
-      postApply: StructuredVerificationContract;
-    };
-  };
-}): ChangeContract {
-  if (plan.changeContract) return normalizeChangeContract(plan.changeContract);
-  return normalizeChangeContract({
-    goal: plan.changeId,
-    acceptance: [
-      plan.verification.change.fullSuite,
-      plan.verification.change.postApply,
-      ...plan.tasks.map((task) => task.affectedVerification),
-    ].map((verification, index) => ({
-      id: `legacy-${index}`,
-      statement: "Retained verification obligation",
-      verification,
-    })),
-    constraints: [],
-    policy: {
-      writeRoots: [
-        ...new Set(
-          plan.tasks.flatMap((task) => [
-            ...(task.agents.impact !== "none" && task.agents.target
-              ? [task.agents.target]
-              : []),
-            ...Object.values(task.phases).flatMap((phase) => [
-              ...phase.write,
-              ...phase.delete,
-            ]),
-          ]),
-        ),
-      ],
-      dependencies: [
-        ...new Set(plan.tasks.flatMap((task) => task.approvedDependencies)),
-      ],
-      verificationModes: ["behavior"],
-    },
-  });
-}