@abelxiaoxing/cadence 1.0.1 → 1.0.2

package/src/parent-provider.ts

@@ -7,6 +7,31 @@ import {
   type ExtensionContext,
   ModelRuntime,
 } from "@earendil-works/pi-coding-agent";
+import type {
+  ParentPayloadBridge,
+  ParentPayloadCallback,
+  ParentPayloadCapture,
+} from "./parent-payload-bridge.ts";
+
+export interface PhasePayloadBridge {
+  readonly bridge: ParentPayloadBridge;
+  readonly capture: ParentPayloadCapture;
+}
+
+function phasePayloadCallback(
+  payloadBridge: PhasePayloadBridge,
+  childOnPayload: ParentPayloadCallback | undefined,
+  signal: AbortSignal | undefined,
+): ParentPayloadCallback {
+  return (payload, model) =>
+    payloadBridge.bridge.composePayload(
+      payloadBridge.capture,
+      payload,
+      model,
+      childOnPayload,
+      signal,
+    );
+}
 
 export async function runtimeForProvider(
   provider: Provider,
@@ -35,6 +60,7 @@ export function phaseProvider(
     baseUrl?: string;
     env?: Record<string, string>;
   },
+  payloadBridge: PhasePayloadBridge,
 ): Provider {
   return {
     ...parent,
@@ -54,47 +80,100 @@ export function phaseProvider(
       },
     },
     stream(model, context, options) {
+      const onPayload = phasePayloadCallback(
+        payloadBridge,
+        options?.onPayload as ParentPayloadCallback | undefined,
+        options?.signal,
+      );
       return parent.stream(model, context, {
         ...options,
         apiKey: auth.apiKey,
-        headers: { ...auth.headers, ...options?.headers },
-        env: { ...auth.env, ...options?.env },
+        headers: { ...options?.headers, ...auth.headers },
+        env: { ...options?.env, ...auth.env },
         maxRetries: 0,
+        onPayload,
       } as never);
     },
     streamSimple(model, context, options) {
+      const onPayload = phasePayloadCallback(
+        payloadBridge,
+        options?.onPayload as ParentPayloadCallback | undefined,
+        options?.signal,
+      );
       return parent.streamSimple(model, context, {
         ...options,
         apiKey: auth.apiKey,
-        headers: { ...auth.headers, ...options?.headers },
-        env: { ...auth.env, ...options?.env },
+        headers: { ...options?.headers, ...auth.headers },
+        env: { ...options?.env, ...auth.env },
         maxRetries: 0,
+        onPayload,
       });
     },
   };
 }
 
+function modelKeyFor(model: Model<string>) {
+  return {
+    provider: model.provider,
+    id: model.id,
+    api: model.api,
+    baseUrl: model.baseUrl,
+  };
+}
+
+function sameSelectedModel(
+  left: Model<string>,
+  right: ReturnType<typeof modelKeyFor>,
+): boolean {
+  return (
+    left.provider === right.provider &&
+    left.id === right.id &&
+    left.api === right.api &&
+    left.baseUrl === right.baseUrl
+  );
+}
+
 export async function runtimeFromContext(
   ctx: Pick<ExtensionContext, "model" | "modelRegistry">,
+  payloadBridge: ParentPayloadBridge,
   signal?: AbortSignal,
 ): Promise<{ modelRuntime: ModelRuntime; model: Model<string> }> {
   signal?.throwIfAborted();
   if (!ctx.model) throw new Error("parent model is unavailable");
-  const parent = ctx.modelRegistry.getProvider(ctx.model.provider);
-  if (!parent) throw new Error("parent Provider is unavailable");
+  const selectedModel = ctx.model;
+  const selectedModelKey = modelKeyFor(selectedModel);
   const resolved = await abortable(
-    ctx.modelRegistry.getApiKeyAndHeaders(ctx.model),
+    ctx.modelRegistry.getApiKeyAndHeaders(selectedModel),
     signal,
   );
   if (!resolved.ok) throw new Error(resolved.error);
   signal?.throwIfAborted();
-  const provider = phaseProvider(parent, resolved);
-  const modelRuntime = await runtimeForProvider(provider, signal);
-  signal?.throwIfAborted();
   const model = {
-    ...ctx.model,
-    baseUrl: resolved.baseUrl ?? ctx.model.baseUrl,
+    ...selectedModel,
+    baseUrl: resolved.baseUrl ?? selectedModel.baseUrl,
   } as Model<string>;
+  const effectiveModelKey = modelKeyFor(model);
+  const capture = payloadBridge.capture(effectiveModelKey, ctx.modelRegistry);
+  if (!capture) throw new Error("parent payload bridge is unavailable");
+  const requireReadyCapture = () => {
+    if (
+      !ctx.model ||
+      !sameSelectedModel(ctx.model, selectedModelKey) ||
+      payloadBridge.capture(effectiveModelKey, ctx.modelRegistry) !== capture
+    ) {
+      throw new Error("parent payload bridge is unavailable");
+    }
+  };
+  requireReadyCapture();
+  const delegate = capture.delegate;
+  if (!delegate) throw new Error("parent Provider is unavailable");
+  const provider = phaseProvider(delegate, resolved, {
+    bridge: payloadBridge,
+    capture,
+  });
+  const modelRuntime = await runtimeForProvider(provider, signal);
+  signal?.throwIfAborted();
+  requireReadyCapture();
   return { modelRuntime, model };
 }
 

package/src/patch.ts

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { preflightCandidate } from "./candidate-preflight.ts";
 import { diffWritePaths } from "./contracts.ts";
 import { isCurrent } from "./file-snapshot.ts";
 import type { ResultStore } from "./result-store.ts";
@@ -7,48 +8,75 @@ interface CommandResult {
   code: number;
   stdout: Buffer;
   stderr: Buffer;
+  cancelled: boolean;
 }
 
 async function git(
   root: string,
   args: string[],
   input: Buffer,
+  signal?: AbortSignal,
 ): Promise<CommandResult> {
   return new Promise((resolve, reject) => {
     const child = spawn("git", args, {
       cwd: root,
       shell: false,
       stdio: ["pipe", "pipe", "pipe"],
+      ...(signal ? { signal } : {}),
     });
     const stdout: Buffer[] = [];
     const stderr: Buffer[] = [];
+    let settled = false;
+    const finish = (result: CommandResult) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
     child.stdout.on("data", (b: Buffer) => stdout.push(b));
     child.stderr.on("data", (b: Buffer) => stderr.push(b));
-    child.on("error", reject);
+    child.on("error", (error) => {
+      if (signal?.aborted || error.name === "AbortError") {
+        finish({
+          code: 1,
+          stdout: Buffer.concat(stdout),
+          stderr: Buffer.concat(stderr),
+          cancelled: true,
+        });
+      } else {
+        reject(error);
+      }
+    });
     child.on("close", (code) =>
-      resolve({
+      finish({
         code: code ?? 1,
         stdout: Buffer.concat(stdout),
         stderr: Buffer.concat(stderr),
+        cancelled: signal?.aborted ?? false,
       }),
     );
     child.stdin.end(input);
   });
 }
 
+function cancellationFailure(): { ok: false; error: string } {
+  return { ok: false, error: "candidate application cancelled" };
+}
+
 export async function applyRetainedPatch(input: {
   root: string;
   id: string;
   store: ResultStore;
+  signal?: AbortSignal;
 }): Promise<
   | { ok: true; targets: string[]; checkExitCode: 0; applyExitCode: 0 }
   | { ok: false; error: string }
 > {
+  if (input.signal?.aborted) return cancellationFailure();
   const retained = input.store.get(input.id);
   if (!retained) return { ok: false, error: "retained result not found" };
   if (retained.root !== input.root)
     return { ok: false, error: "retained result root mismatch" };
-  if (!isCurrent(input.root, retained.snapshot))
+  if (!retained.verification && !isCurrent(input.root, retained.snapshot))
     return { ok: false, error: "stale file snapshot" };
 
   let targets: string[];
@@ -64,11 +92,48 @@ export async function applyRetainedPatch(input: {
     };
   }
 
+  if (retained.verification) {
+    if (
+      !retained.packageManifest ||
+      !retained.lockfile ||
+      !retained.dependencyTarget
+    ) {
+      return {
+        ok: false,
+        error: "retained candidate preflight inputs are incomplete",
+      };
+    }
+    const preflight = await preflightCandidate({
+      root: input.root,
+      diff: retained.diff,
+      writeSet: retained.writeSet,
+      snapshot: retained.snapshot,
+      baseline: retained.baseline,
+      verification: retained.verification,
+      packageManifest: retained.packageManifest,
+      lockfile: retained.lockfile,
+      dependencyTarget: retained.dependencyTarget,
+      signal: input.signal,
+    });
+    if (!preflight.ok) {
+      return {
+        ok: false,
+        error: `candidate preflight rejected: ${preflight.class}:${preflight.code}`,
+      };
+    }
+    if (!isCurrent(input.root, retained.snapshot)) {
+      return { ok: false, error: "stale file snapshot after preflight" };
+    }
+  }
+  if (input.signal?.aborted) return cancellationFailure();
+
   const numstat = await git(
     input.root,
     ["apply", "--numstat", "-z", "--recount", "-"],
     retained.diff,
+    input.signal,
   );
+  if (numstat.cancelled || input.signal?.aborted) return cancellationFailure();
   if (numstat.code !== 0 || numstat.stdout.includes(Buffer.from("-\t-\t"))) {
     return {
       ok: false,
@@ -79,7 +144,9 @@ export async function applyRetainedPatch(input: {
     input.root,
     ["apply", "--summary", "--recount", "-"],
     retained.diff,
+    input.signal,
   );
+  if (summary.cancelled || input.signal?.aborted) return cancellationFailure();
   if (
     summary.code !== 0 ||
     /rename|copy|mode change|create mode 160000/i.test(
@@ -92,12 +159,15 @@ export async function applyRetainedPatch(input: {
     input.root,
     ["apply", "--check", "--recount", "--whitespace=nowarn", "-"],
     retained.diff,
+    input.signal,
   );
+  if (check.cancelled || input.signal?.aborted) return cancellationFailure();
   if (check.code !== 0)
     return {
       ok: false,
       error: `git apply --check failed: ${check.stderr.toString("utf8")}`,
     };
+  if (input.signal?.aborted) return cancellationFailure();
   const apply = await git(
     input.root,
     ["apply", "--recount", "--whitespace=nowarn", "-"],

package/src/result-store.ts

@@ -1,5 +1,9 @@
 import { randomUUID } from "node:crypto";
-import type { Bound } from "./file-snapshot.ts";
+import type {
+  BaselineEntry,
+  VerificationContract,
+} from "./candidate-preflight.ts";
+import type { Bound, DirBound, FileBound } from "./file-snapshot.ts";
 import { snapshotFiles } from "./file-snapshot.ts";
 
 export interface RetainedResult {
@@ -8,19 +12,52 @@ export interface RetainedResult {
   writeSet: string[];
   root: string;
   snapshot: Bound;
+  baseline: BaselineEntry[];
+  verification?: VerificationContract;
+  packageManifest?: FileBound;
+  lockfile?: FileBound;
+  dependencyTarget?: FileBound | DirBound;
 }
 
 export class ResultStore {
   private readonly results = new Map<string, RetainedResult>();
 
-  retain(input: { diff: string; writeSet: string[]; root: string }): string {
+  retain(input: {
+    diff: string;
+    writeSet: string[];
+    root: string;
+    snapshot?: Bound;
+    baseline?: BaselineEntry[];
+    verification?: VerificationContract;
+    packageManifest?: FileBound;
+    lockfile?: FileBound;
+    dependencyTarget?: FileBound | DirBound;
+  }): string {
     const id = randomUUID();
     this.results.set(id, {
       id,
       diff: Buffer.from(input.diff, "utf8"),
       writeSet: [...new Set(input.writeSet)],
       root: input.root,
-      snapshot: snapshotFiles(input.root, input.writeSet),
+      snapshot: input.snapshot ?? snapshotFiles(input.root, input.writeSet),
+      baseline: (input.baseline ?? []).map((entry) => ({ ...entry })),
+      ...(input.verification === undefined
+        ? {}
+        : {
+            verification: {
+              ...input.verification,
+              argv: [...input.verification.argv],
+            },
+          }),
+      ...(input.packageManifest === undefined
+        ? {}
+        : { packageManifest: { ...input.packageManifest } }),
+      ...(input.lockfile === undefined
+        ? {}
+        : { lockfile: { ...input.lockfile } }),
+      ...(input.dependencyTarget === undefined
+        ? {}
+        : { dependencyTarget: { ...input.dependencyTarget } }),
     });
     return id;
   }