@abelxiaoxing/cadence 1.8.3 → 2.0.0

package/src/candidate-patch.ts

@@ -1,271 +0,0 @@
-import { lstatSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { generateUnifiedPatch } from "@earendil-works/pi-coding-agent";
-import { compareCanonicalStrings } from "./canonical.ts";
-
-import { isValidRelativePath } from "./contracts.ts";
-import { observeSafePath } from "./safe-path.ts";
-
-export type CandidatePatchOperation =
-  | {
-      kind: "replace";
-      path: string;
-      oldText: string;
-      newText: string;
-    }
-  | { kind: "rewrite"; path: string; content: string }
-  | {
-      kind: "create";
-      path: string;
-      content: string;
-      mode: "regular" | "executable";
-    }
-  | { kind: "delete"; path: string };
-
-interface CandidateFileState {
-  path: string;
-  base: string | null;
-  current: string | null;
-  mode: "100644" | "100755";
-}
-
-function exactKeys(value: object, expected: readonly string[]): boolean {
-  const actual = Object.keys(value).sort();
-  return (
-    actual.length === expected.length &&
-    [...expected].sort().every((key, index) => actual[index] === key)
-  );
-}
-
-function safeText(value: unknown, maxBytes: number): value is string {
-  if (typeof value !== "string" || value.includes("\0")) return false;
-  const encoded = Buffer.from(value, "utf8");
-  return encoded.byteLength <= maxBytes && encoded.toString("utf8") === value;
-}
-
-function renderFileDiff(state: CandidateFileState): string {
-  if (state.base === state.current) return "";
-  if (state.base === null && state.current === "") {
-    throw new Error("candidate-empty-file-create-unsupported");
-  }
-  if (state.current === null && state.base === "") {
-    throw new Error("candidate-empty-file-delete-unsupported");
-  }
-  const output: string[] = [`diff --git a/${state.path} b/${state.path}`];
-  if (state.base === null) output.push(`new file mode ${state.mode}`);
-  if (state.current === null) output.push(`deleted file mode ${state.mode}`);
-  const generated = generateUnifiedPatch(
-    state.path,
-    state.base ?? "",
-    state.current ?? "",
-    3,
-  );
-  const generatedHeaders = `--- ${state.path}\n+++ ${state.path}\n`;
-  if (!generated.startsWith(generatedHeaders)) {
-    throw new Error("candidate-patch-diff-invalid");
-  }
-  output.push(state.base === null ? "--- /dev/null" : `--- a/${state.path}`);
-  output.push(state.current === null ? "+++ /dev/null" : `+++ b/${state.path}`);
-  return `${output.join("\n")}\n${generated.slice(generatedHeaders.length)}`;
-}
-
-function occurrenceCount(value: string, search: string): number {
-  let count = 0;
-  let offset = 0;
-  for (;;) {
-    const found = value.indexOf(search, offset);
-    if (found < 0) return count;
-    count += 1;
-    if (count > 1) return count;
-    offset = found + 1;
-  }
-}
-
-export function compileCandidatePatch(input: {
-  root: string;
-  writePaths: readonly string[];
-  deletePaths: readonly string[];
-  operations: readonly CandidatePatchOperation[];
-  maxBytes: number;
-}): string {
-  if (
-    !path.isAbsolute(input.root) ||
-    !Number.isSafeInteger(input.maxBytes) ||
-    input.maxBytes < 1 ||
-    !Array.isArray(input.operations) ||
-    input.operations.length < 1 ||
-    input.operations.length > 128
-  ) {
-    throw new Error("candidate-patch-invalid");
-  }
-  const writePaths = new Set(input.writePaths);
-  const deletePaths = new Set(input.deletePaths);
-  const states = new Map<string, CandidateFileState>();
-
-  const requirePath = (relative: unknown): string => {
-    if (
-      !isValidRelativePath(relative) ||
-      relative === "." ||
-      relative.trim() !== relative ||
-      /[\r\n\t]/u.test(relative)
-    ) {
-      throw new Error("candidate-patch-path-invalid");
-    }
-    return relative;
-  };
-  const load = (relative: string): CandidateFileState => {
-    const existing = states.get(relative);
-    if (existing) return existing;
-    const observation = observeSafePath(input.root, relative);
-    if (observation.kind === "directory" || observation.kind === "unsafe") {
-      throw new Error("candidate-patch-path-unsafe");
-    }
-    let base: string | null = null;
-    let mode: CandidateFileState["mode"] = "100644";
-    if (observation.kind === "file") {
-      const target = path.join(input.root, relative);
-      const stat = lstatSync(target);
-      if (stat.size > input.maxBytes) {
-        throw new Error("candidate-patch-source-too-large");
-      }
-      const bytes = readFileSync(target);
-      try {
-        base = new TextDecoder("utf-8", {
-          fatal: true,
-          ignoreBOM: true,
-        }).decode(bytes);
-      } catch {
-        throw new Error("candidate-patch-source-invalid");
-      }
-      if (base.includes("\0")) {
-        throw new Error("candidate-patch-source-invalid");
-      }
-      mode = stat.mode & 0o111 ? "100755" : "100644";
-    }
-    const state = { path: relative, base, current: base, mode };
-    states.set(relative, state);
-    return state;
-  };
-
-  for (const [operationIndex, operation] of input.operations.entries()) {
-    if (
-      !operation ||
-      typeof operation !== "object" ||
-      Array.isArray(operation)
-    ) {
-      throw new Error("candidate-patch-operation-invalid");
-    }
-    switch (operation.kind) {
-      case "replace": {
-        if (
-          !exactKeys(operation, ["kind", "path", "oldText", "newText"]) ||
-          !safeText(operation.oldText, input.maxBytes) ||
-          operation.oldText.length === 0 ||
-          !safeText(operation.newText, input.maxBytes)
-        ) {
-          throw new Error("candidate-patch-replace-invalid");
-        }
-        const relative = requirePath(operation.path);
-        const reject = (reason: string, hint: string): never => {
-          throw new Error(
-            JSON.stringify({
-              code: "candidate-patch-replace-invalid",
-              operationIndex,
-              ...(relative.length <= 512 && !/[\p{Cc}\p{Cf}]/u.test(relative)
-                ? { path: relative }
-                : {}),
-              reason,
-              hint,
-            }),
-          );
-        };
-        if (!writePaths.has(relative)) {
-          reject(
-            "path-not-authorized",
-            "Use only approved write paths; request context instead of widening authority.",
-          );
-        }
-        const state = load(relative);
-        const current =
-          state.current ??
-          reject(
-            "file-not-found",
-            "Use create for a new approved file, or correct the path.",
-          );
-        const occurrences = occurrenceCount(current, operation.oldText);
-        if (occurrences !== 1) {
-          reject(
-            occurrences === 0 ? "old-text-not-found" : "old-text-ambiguous",
-            "Read the approved file and supply exact unique oldText, including enough surrounding context. Operations are applied in order.",
-          );
-        }
-        state.current = current.replace(operation.oldText, operation.newText);
-        break;
-      }
-      case "rewrite": {
-        if (
-          !exactKeys(operation, ["kind", "path", "content"]) ||
-          !safeText(operation.content, input.maxBytes)
-        ) {
-          throw new Error("candidate-patch-rewrite-invalid");
-        }
-        const relative = requirePath(operation.path);
-        if (!writePaths.has(relative)) {
-          throw new Error("candidate-patch-rewrite-invalid");
-        }
-        const state = load(relative);
-        if (state.current === null) {
-          throw new Error("candidate-patch-rewrite-invalid");
-        }
-        state.current = operation.content;
-        break;
-      }
-      case "create": {
-        if (
-          !exactKeys(operation, ["kind", "path", "content", "mode"]) ||
-          !safeText(operation.content, input.maxBytes) ||
-          operation.content.length === 0 ||
-          (operation.mode !== "regular" && operation.mode !== "executable")
-        ) {
-          throw new Error("candidate-patch-create-invalid");
-        }
-        const relative = requirePath(operation.path);
-        if (!writePaths.has(relative)) {
-          throw new Error("candidate-patch-create-invalid");
-        }
-        const state = load(relative);
-        if (state.base !== null || state.current !== null) {
-          throw new Error("candidate-patch-create-invalid");
-        }
-        state.current = operation.content;
-        state.mode = operation.mode === "executable" ? "100755" : "100644";
-        break;
-      }
-      case "delete": {
-        if (!exactKeys(operation, ["kind", "path"])) {
-          throw new Error("candidate-patch-delete-invalid");
-        }
-        const relative = requirePath(operation.path);
-        if (!deletePaths.has(relative)) {
-          throw new Error("candidate-patch-delete-invalid");
-        }
-        const state = load(relative);
-        if (state.base === null || state.current === null) {
-          throw new Error("candidate-patch-delete-invalid");
-        }
-        state.current = null;
-        break;
-      }
-      default:
-        throw new Error("candidate-patch-operation-invalid");
-    }
-  }
-
-  const diff = [...states.values()]
-    .filter((state) => state.base !== state.current)
-    .sort((left, right) => compareCanonicalStrings(left.path, right.path))
-    .map(renderFileDiff)
-    .join("");
-  if (diff.length === 0) throw new Error("candidate-patch-empty");
-  return diff;
-}

package/src/candidate-workspace.ts

@@ -1,80 +0,0 @@
-import { spawn } from "node:child_process";
-import { lstatSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { observeSafePath } from "./safe-path.ts";
-
-export function runGitApply(
-  root: string,
-  diff: Uint8Array,
-  checkOnly: boolean,
-  signal: AbortSignal,
-): Promise<"ok" | "failed" | "cancelled"> {
-  if (signal.aborted) return Promise.resolve("cancelled");
-  return new Promise((resolve) => {
-    let settled = false;
-    const settle = (value: "ok" | "failed" | "cancelled") => {
-      if (settled) return;
-      settled = true;
-      signal.removeEventListener("abort", abort);
-      resolve(value);
-    };
-    const child = spawn(
-      "git",
-      [
-        // Candidate patches bind exact bytes, independent of host checkout
-        // preferences. Git's Windows autocrlf default must not rewrite them.
-        "-c",
-        "core.autocrlf=false",
-        "-c",
-        "core.eol=lf",
-        "apply",
-        ...(checkOnly ? ["--check"] : []),
-        "--recount",
-        "--whitespace=nowarn",
-        "-",
-      ],
-      { cwd: root, shell: false, stdio: ["pipe", "ignore", "ignore"] },
-    );
-    const abort = () => {
-      child.kill("SIGTERM");
-      settle("cancelled");
-    };
-    signal.addEventListener("abort", abort, { once: true });
-    child.once("error", () => settle(signal.aborted ? "cancelled" : "failed"));
-    child.once("close", (code) =>
-      settle(signal.aborted ? "cancelled" : code === 0 ? "ok" : "failed"),
-    );
-    child.stdin.on("error", () => undefined);
-    child.stdin.end(Buffer.from(diff));
-  });
-}
-export function revisionChanges(
-  root: string,
-  paths: readonly string[],
-): Record<
-  string,
-  { kind: "absent" } | { kind: "file"; bytes: Uint8Array; mode: number }
-> {
-  const changes: Record<
-    string,
-    { kind: "absent" } | { kind: "file"; bytes: Uint8Array; mode: number }
-  > = {};
-  for (const relative of [...new Set(paths)].sort()) {
-    const observation = observeSafePath(root, relative);
-    if (observation.kind === "absent") {
-      changes[relative] = { kind: "absent" };
-      continue;
-    }
-    if (observation.kind !== "file") {
-      throw new Error("workflow-candidate-path-unsafe");
-    }
-    const target = path.join(root, ...relative.split("/"));
-    const stat = lstatSync(target);
-    changes[relative] = {
-      kind: "file",
-      bytes: readFileSync(target),
-      mode: stat.mode & 0o777,
-    };
-  }
-  return changes;
-}

package/src/canonical.ts

@@ -1,16 +0,0 @@
-/** Canonical identity ordering is UTF-16 code-unit order, never host collation. */
-export function compareCanonicalStrings(left: string, right: string): number {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-
-export function canonicalJson(value: unknown): string {
-  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-  if (value && typeof value === "object") {
-    return `{${Object.entries(value as Record<string, unknown>)
-      .filter(([, entry]) => entry !== undefined)
-      .sort(([left], [right]) => compareCanonicalStrings(left, right))
-      .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`)
-      .join(",")}}`;
-  }
-  return JSON.stringify(value) ?? "null";
-}

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);
-}