@abelxiaoxing/cadence 1.4.1 → 1.5.1

package/src/single-task-draft.ts

@@ -0,0 +1,142 @@
+import { DesignPlanValidationError } from "./design-diagnostics.ts";
+import type {
+  DraftVerification,
+  PlanDraft,
+  PlanTaskInput,
+} from "./plan-draft.ts";
+
+/** Small author input. Evidence, scope and the complete suite remain explicit. */
+export interface SingleTaskDraft {
+  changeId: string;
+  changeContract?: PlanDraft["changeContract"];
+  singleTask: {
+    taskId: string;
+    objective: string;
+    context: PlanTaskInput["context"];
+    roots: string[];
+    read: string[];
+    greenWrite: string[];
+    redWrite?: string[];
+    expectedFailure?: string;
+    verificationMode?: "behavior" | "mechanical" | "refactor";
+    verification: DraftVerification;
+    fullSuite: DraftVerification;
+    impactClosure: PlanTaskInput["impactClosure"];
+    agents: PlanTaskInput["agents"];
+    recovery?: { artifactAttempts: number; repairAttempts: number };
+  };
+}
+
+function invalid(code: string, field = "singleTask"): never {
+  throw new DesignPlanValidationError(code, [{ code, field }]);
+}
+
+function record(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** Mechanical expansion only; the ordinary compiler validates all resulting fields. */
+export function expandSingleTaskDraft(value: unknown): unknown {
+  if (!record(value) || !Object.hasOwn(value, "singleTask")) return value;
+  if (
+    Object.keys(value).some(
+      (key) => !["changeId", "changeContract", "singleTask"].includes(key),
+    ) ||
+    !record(value.singleTask)
+  )
+    invalid("single-task-draft-invalid");
+  const input = value.singleTask;
+  const required = [
+    "taskId",
+    "objective",
+    "context",
+    "roots",
+    "read",
+    "greenWrite",
+    "verification",
+    "fullSuite",
+    "impactClosure",
+    "agents",
+  ];
+  const optional = [
+    "redWrite",
+    "expectedFailure",
+    "verificationMode",
+    "recovery",
+  ];
+  if (
+    required.some((key) => !Object.hasOwn(input, key)) ||
+    Object.keys(input).some((key) => ![...required, ...optional].includes(key))
+  )
+    invalid("single-task-draft-invalid");
+  const task = structuredClone(
+    input,
+  ) as unknown as SingleTaskDraft["singleTask"];
+  const mode = task.verificationMode ?? "behavior";
+  if (mode === "behavior" && (!task.redWrite?.length || !task.expectedFailure))
+    invalid("single-task-red-required");
+  if (
+    mode !== "behavior" &&
+    (task.redWrite !== undefined || task.expectedFailure !== undefined)
+  )
+    invalid("single-task-red-unexpected");
+  if (
+    Object.hasOwn(input, "recovery") &&
+    (!record(task.recovery) ||
+      !Object.hasOwn(task.recovery, "artifactAttempts") ||
+      !Object.hasOwn(task.recovery, "repairAttempts") ||
+      Object.keys(task.recovery).some(
+        (key) => !["artifactAttempts", "repairAttempts"].includes(key),
+      ))
+  )
+    invalid("single-task-recovery-invalid");
+  return {
+    changeId: value.changeId,
+    ...(value.changeContract === undefined
+      ? {}
+      : { changeContract: value.changeContract }),
+    tasks: [
+      {
+        taskId: task.taskId,
+        objective: task.objective,
+        context: task.context,
+        roots: task.roots,
+        read: task.read,
+        dependsOn: [],
+        verificationMode: mode,
+        phases: {
+          ...(mode === "behavior"
+            ? {
+                red: {
+                  write: task.redWrite,
+                  delete: [],
+                  verification: {
+                    ...task.verification,
+                    expectedFailure: task.expectedFailure,
+                  },
+                },
+              }
+            : {}),
+          green: {
+            write: task.greenWrite,
+            delete: [],
+            verification: task.verification,
+          },
+        },
+        affectedVerification: task.fullSuite,
+        repairVerification: task.fullSuite,
+        scheduling: { conflicts: [], resources: [] },
+        agents: task.agents,
+        approvedDependencies: [],
+        impactClosure: task.impactClosure,
+      },
+    ],
+    outputs: [],
+    verification: {
+      baseline: { fullSuite: task.fullSuite },
+      change: { fullSuite: task.fullSuite, postApply: task.fullSuite },
+      artifactCorrection: { maxAttempts: task.recovery?.artifactAttempts ?? 2 },
+      repair: { maxAttempts: task.recovery?.repairAttempts ?? 1 },
+    },
+  };
+}

package/src/transport-budget.ts

@@ -28,5 +28,25 @@ export function isTransportTimeoutCode(
 export function transportFailureError(code: string): Error {
   return isTransportTimeoutCode(code)
     ? new TransportTimeout(code)
-    : new Error("transport-failure");
+    : new Error(
+        code === "child-provider-rate-limited" ? code : "transport-failure",
+      );
+}
+
+/** Snapshot at the start of each request; Workers cannot override these values. */
+export function requestBounds(env: NodeJS.ProcessEnv = process.env) {
+  const read = (name: string, fallback: number) => {
+    const value = Number(env[name] ?? fallback);
+    if (!Number.isSafeInteger(value) || value < 1 || value > 1_200_000)
+      throw new Error("request-budget-invalid");
+    return value;
+  };
+  return {
+    ...REQUEST_BOUNDS,
+    firstProgressMs: read(
+      "ABEL_FIRST_PROGRESS_MS",
+      REQUEST_BOUNDS.firstProgressMs,
+    ),
+    streamIdleMs: read("ABEL_STREAM_IDLE_MS", REQUEST_BOUNDS.streamIdleMs),
+  };
 }

package/src/verification-capability.ts

@@ -16,6 +16,7 @@ import {
   verificationInputPaths,
   verificationSteps,
 } from "./contracts.ts";
+import { executionProfile } from "./execution-profile.ts";
 import {
   type Bound,
   isCurrent,
@@ -828,9 +829,10 @@ function validateAtomicCapability(
       continue;
     if (
       lstatSync(path.join(root, relative)).size > 64 * 1024 ||
-      unsupportedExecutionConfiguration(
-        readFileSync(path.join(root, relative), "utf8"),
-      )
+      (executionProfile().mode !== "local-trusted" &&
+        unsupportedExecutionConfiguration(
+          readFileSync(path.join(root, relative), "utf8"),
+        ))
     ) {
       return adapterFailure(
         step.id,

package/src/verification-diagnostics.ts

@@ -0,0 +1,76 @@
+import type {
+  VerificationFailureSummary,
+  VerificationObservation,
+} from "./contracts.ts";
+
+/** Diagnostic text is evidence for repair, never a failure identity or authority. */
+
+export function diagnosticText(value: string, maximum = 4096): string {
+  const clean = value
+    .replace(
+      new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, "gu"),
+      "",
+    )
+    .replace(/(Bearer\s+)\S+/giu, "$1[redacted]")
+    .replace(
+      /((?:api[_-]?key|token|password|secret)\s*[:=]\s*)[^\s,;]+/giu,
+      "$1[redacted]",
+    )
+    .replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/giu, "$1[redacted]@");
+  return clean.length <= maximum
+    ? clean
+    : `${clean.slice(0, Math.floor(maximum / 2))}\n…[truncated]…\n${clean.slice(-Math.floor(maximum / 2))}`;
+}
+
+/** Bounded operation-local feedback; no raw transcripts or global cross-run cache. */
+export class VerificationFeedback {
+  readonly #entries = new Map<string, VerificationFailureSummary>();
+  observe(result: VerificationObservation): void {
+    if (result.kind === "cancelled") return;
+    const id =
+      result.kind === "unavailable"
+        ? result.verificationId
+        : result.evidence.id;
+    this.#entries.delete(id);
+    if (result.kind === "accepted") return;
+    const summary = result.diagnostic ?? {
+      verificationId: id,
+      code: result.code,
+      failures: [],
+      stdout: "",
+      stderr: "",
+      truncated: false,
+      nextStep:
+        "Repair the verification environment or adapter before changing product code.",
+    };
+    this.#entries.set(id, structuredClone(summary));
+    const oldest = this.#entries.keys().next().value;
+    if (this.#entries.size > 32 && oldest !== undefined)
+      this.#entries.delete(oldest);
+  }
+  current(): VerificationFailureSummary[] {
+    const result: VerificationFailureSummary[] = [];
+    let bytes = 0;
+    for (const entry of [...this.#entries.values()].reverse()) {
+      const summary = {
+        ...entry,
+        failures: entry.failures
+          .slice(0, 4)
+          .map((text) => diagnosticText(text, 256)),
+        stdout: diagnosticText(entry.stdout, 512),
+        stderr: diagnosticText(entry.stderr, 1024),
+        truncated:
+          entry.truncated ||
+          entry.failures.length > 4 ||
+          entry.failures.some((text) => text.length > 256) ||
+          entry.stdout.length > 512 ||
+          entry.stderr.length > 1024,
+      };
+      const size = Buffer.byteLength(JSON.stringify(summary), "utf8");
+      if (bytes + size > 6000) break;
+      result.push(summary);
+      bytes += size;
+    }
+    return structuredClone(result.reverse());
+  }
+}

package/src/verification-environment-io.ts

@@ -0,0 +1,280 @@
+import {
+  constants,
+  cpSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+import type { ExecutionProfile } from "./execution-profile.ts";
+import type { IsolationMount } from "./isolation-backend.ts";
+import type { VerificationRunnerBinding } from "./verification-capability.ts";
+
+const CACHES = [".vite", ".vite-temp"];
+function within(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return (
+    relative !== ".." &&
+    !relative.startsWith(`..${path.sep}`) &&
+    !path.isAbsolute(relative)
+  );
+}
+
+/** A disposable dependency view: immutable packages and independently writable caches. */
+export function prepareVerificationEnvironmentIo(
+  root: string,
+  dependencyOwner: string,
+  runnerBindings: readonly VerificationRunnerBinding[],
+  profile: ExecutionProfile,
+  environment: NodeJS.ProcessEnv,
+  checkCancelled: () => void,
+  privateRoot: string,
+) {
+  const cleanup = () => rmSync(privateRoot, { recursive: true, force: true });
+  try {
+    const local = profile.mode === "local-trusted";
+    if (local && realpathSync(root) === realpathSync(dependencyOwner))
+      throw new Error("trusted-candidate-required");
+    const mounts: IsolationMount[] = [
+      { source: privateRoot, target: "/cadence", writable: true },
+    ];
+    for (const directory of [
+      "home",
+      "cache",
+      "tmp",
+      "reports",
+      "dependencies",
+    ]) {
+      mkdirSync(path.join(privateRoot, directory), { mode: 0o700 });
+    }
+    writeFileSync(path.join(privateRoot, "home/user.npmrc"), "");
+    writeFileSync(path.join(privateRoot, "home/global.npmrc"), "");
+    const dependencies = path.join(dependencyOwner, "node_modules");
+    const stat = lstatSync(dependencies, { throwIfNoEntry: false });
+    if (stat) {
+      const target = path.join(root, "node_modules");
+      const targetStat = lstatSync(target, { throwIfNoEntry: false });
+      if (
+        !stat.isDirectory() ||
+        stat.isSymbolicLink() ||
+        (targetStat &&
+          (!targetStat.isDirectory() || targetStat.isSymbolicLink()))
+      ) {
+        throw new Error("dependency-path-unsafe");
+      }
+      if (!targetStat) mkdirSync(target, { mode: 0o700 });
+      const view = path.join(privateRoot, "dependencies");
+      mounts.push({ source: view, target: "/workspace/node_modules" });
+      const entries = readdirSync(dependencies);
+      if (entries.length > 20_000) throw new Error("dependency-view-too-large");
+      const canonical = realpathSync(dependencies);
+      let viewEntries = 0;
+      const projectEntry = (name: string) => {
+        checkCancelled();
+        if (++viewEntries > 20_000)
+          throw new Error("dependency-view-too-large");
+        if (CACHES.includes(name)) return;
+        const source = path.join(dependencies, name);
+        const placeholder = path.join(view, name);
+        const entry = lstatSync(source);
+        if (entry.isSymbolicLink()) {
+          const resolved = realpathSync(source);
+          if (within(canonical, resolved)) {
+            symlinkSync(
+              path.relative(path.dirname(source), resolved),
+              placeholder,
+            );
+          } else if (within(realpathSync(dependencyOwner), resolved)) {
+            const relative = path.relative(
+              realpathSync(dependencyOwner),
+              resolved,
+            );
+            const candidate = path.join(root, relative);
+            if (!lstatSync(candidate, { throwIfNoEntry: false }))
+              throw new Error("workspace-dependency-missing");
+            symlinkSync(
+              local
+                ? candidate
+                : `/workspace/${relative.split(path.sep).join("/")}`,
+              placeholder,
+            );
+          } else throw new Error("dependency-path-unsafe");
+        } else if (
+          entry.isDirectory() &&
+          name.startsWith("@") &&
+          !name.includes(path.sep)
+        ) {
+          mkdirSync(placeholder);
+          for (const child of readdirSync(source))
+            projectEntry(path.join(name, child));
+        } else {
+          if (entry.isDirectory()) mkdirSync(placeholder);
+          else if (entry.isFile()) writeFileSync(placeholder, "");
+          else throw new Error("dependency-path-unsafe");
+          mounts.push({
+            source,
+            target: `/workspace/node_modules/${name.split(path.sep).join("/")}`,
+          });
+        }
+      };
+      for (const name of entries) projectEntry(name);
+      for (const cache of CACHES) {
+        mkdirSync(path.join(view, cache));
+        const source = path.join(privateRoot, "cache", cache);
+        mkdirSync(source);
+        mounts.push({
+          source,
+          target: `/workspace/node_modules/${cache}`,
+          writable: true,
+        });
+      }
+    }
+    if (local && stat) {
+      // Private copies keep package caches/writes away from consumer dependencies.
+      const copyEntry = (name: string) => {
+        checkCancelled();
+        const source = path.join(dependencies, name);
+        const destination = path.join(root, "node_modules", name);
+        if (CACHES.includes(name)) {
+          mkdirSync(destination, { recursive: true });
+          return;
+        }
+        removeEntry(destination, checkCancelled);
+        const stat = lstatSync(source);
+        if (stat.isSymbolicLink()) {
+          const resolved = realpathSync(source);
+          const translated = within(canonicalRoot(dependencyOwner), resolved)
+            ? path.join(
+                root,
+                path.relative(canonicalRoot(dependencyOwner), resolved),
+              )
+            : resolved;
+          symlinkSync(translated, destination);
+        } else if (
+          stat.isDirectory() &&
+          name.startsWith("@") &&
+          !name.includes(path.sep)
+        ) {
+          mkdirSync(destination);
+          for (const child of readdirSync(source))
+            copyEntry(path.join(name, child));
+        } else
+          cpSync(source, destination, {
+            recursive: true,
+            filter: () => {
+              checkCancelled();
+              return true;
+            },
+            mode: constants.COPYFILE_FICLONE,
+            verbatimSymlinks: true,
+          });
+      };
+      for (const name of readdirSync(path.join(privateRoot, "dependencies")))
+        copyEntry(name);
+    }
+
+    const sources = new Map<string, string>();
+    const bindings = runnerBindings.map((binding) => {
+      if (local || !binding.mountSource) return { ...binding };
+      const source = path.resolve(binding.mountSource);
+      const stat = lstatSync(source);
+      const executable = realpathSync(binding.executablePath);
+      if (
+        !stat.isDirectory() ||
+        stat.isSymbolicLink() ||
+        !within(source, executable)
+      ) {
+        throw new Error("runner-mount-unavailable");
+      }
+      let target = sources.get(source);
+      if (!target) {
+        target = `/cadence-runners/${sources.size}`;
+        sources.set(source, target);
+        mounts.push({ source, target });
+      }
+      const translate = (file: string) =>
+        path.posix.join(target, ...path.relative(source, file).split(path.sep));
+      return {
+        ...binding,
+        executablePath: translate(executable),
+        ...(binding.fixedArgs
+          ? {
+              fixedArgs: binding.fixedArgs.map((arg) =>
+                path.isAbsolute(arg) && within(source, arg)
+                  ? translate(arg)
+                  : arg,
+              ),
+            }
+          : {}),
+      };
+    });
+    checkCancelled();
+    return {
+      privateRoot,
+      mounts,
+      bindings,
+      reportRoot: local ? privateRoot : "/cadence",
+      environment: {
+        ...(local
+          ? Object.fromEntries(
+              profile.inheritEnvironment.flatMap((name) =>
+                environment[name] === undefined
+                  ? []
+                  : [[name, environment[name] ?? ""]],
+              ),
+            )
+          : {}),
+        CI: "1",
+        HOME: local ? path.join(privateRoot, "home") : "/cadence/home",
+        XDG_CACHE_HOME: local
+          ? path.join(privateRoot, "cache")
+          : "/cadence/cache",
+        TMPDIR: local ? path.join(privateRoot, "tmp") : "/cadence/tmp",
+        npm_config_cache: local
+          ? path.join(privateRoot, "cache/npm")
+          : "/cadence/cache/npm",
+        npm_config_userconfig: local
+          ? path.join(privateRoot, "home/user.npmrc")
+          : "/cadence/home/user.npmrc",
+        npm_config_globalconfig: local
+          ? path.join(privateRoot, "home/global.npmrc")
+          : "/cadence/home/global.npmrc",
+        PATH: [
+          ...new Set(
+            // Honor explicitly resolved private runtimes before system fallbacks.
+            [
+              ...bindings.filter((binding) => binding.mountSource),
+              ...bindings.filter((binding) => !binding.mountSource),
+            ].map((binding) => path.posix.dirname(binding.executablePath)),
+          ),
+          ...(local ? (environment.PATH ?? "").split(path.delimiter) : []),
+          "/usr/local/bin",
+          "/usr/bin",
+          "/bin",
+        ].join(":"),
+      },
+    };
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+}
+
+function canonicalRoot(root: string): string {
+  return realpathSync(root);
+}
+
+/** Per-entry cancellation, including replacement of an earlier dependency view. */
+function removeEntry(file: string, checkCancelled: () => void): void {
+  checkCancelled();
+  const stat = lstatSync(file, { throwIfNoEntry: false });
+  if (!stat) return;
+  if (stat.isDirectory())
+    for (const name of readdirSync(file))
+      removeEntry(path.join(file, name), checkCancelled);
+  rmSync(file, { recursive: stat.isDirectory(), force: true });
+}