@mandujs/core 0.54.32 → 0.55.0-beta.1

package/src/agent/__tests__/apply.test.ts

@@ -0,0 +1,224 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import {
+  buildAgentApplyReport,
+  buildExecutableAgentPlan,
+  rollbackAgentApply,
+} from "../apply";
+import { writeAgentPlan } from "../plan";
+
+async function writeFile(root: string, relativePath: string, content: string): Promise<void> {
+  const absolute = path.join(root, relativePath);
+  await fs.mkdir(path.dirname(absolute), { recursive: true });
+  await fs.writeFile(absolute, content, "utf8");
+}
+
+async function readFile(root: string, relativePath: string): Promise<string> {
+  return fs.readFile(path.join(root, relativePath), "utf8");
+}
+
+describe("typed agent apply", () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), "mandu-typed-apply-"));
+    await writeFile(root, "package.json", JSON.stringify({ name: "typed-apply-app" }));
+  });
+
+  afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true });
+  });
+
+  it("previews, applies, verifies, and replays a route.create idempotently", async () => {
+    const content = "export default function Dashboard() { return <main>Dashboard</main>; }\n";
+    const plan = await buildExecutableAgentPlan(root, {
+      intent: "add dashboard page",
+      idempotencyKey: "dashboard-v1",
+      operations: [
+        {
+          kind: "route.create",
+          target: "app/dashboard/page.tsx",
+          effect: { type: "write", content, encoding: "utf8" },
+        },
+      ],
+    });
+    await writeAgentPlan(root, plan);
+
+    const preview = await buildAgentApplyReport(root);
+    expect(preview.ok).toBe(true);
+    expect(preview.status).toBe("preview");
+    expect(preview.operations[0]?.status).toBe("planned");
+    expect(await fs.stat(path.join(root, "app/dashboard/page.tsx")).catch(() => null)).toBeNull();
+
+    const receipt = await buildAgentApplyReport(root, { dryRun: false });
+    expect(receipt.ok).toBe(true);
+    expect(receipt.status).toBe("applied");
+    expect(receipt.replayed).toBe(false);
+    expect(receipt.changedFiles).toEqual(["app/dashboard/page.tsx"]);
+    expect(receipt.verification[0]?.kind).toBe("agent.verify");
+    expect(receipt.verification[0]?.ok).toBe(true);
+    expect(receipt.rollback.id).toStartWith("rollback-");
+    expect(await readFile(root, "app/dashboard/page.tsx")).toBe(content);
+
+    await writeFile(root, "app/dashboard/page.tsx", "// user changed after apply\n");
+    const replay = await buildAgentApplyReport(root, { dryRun: false });
+    expect(replay.replayed).toBe(true);
+    expect(replay.receiptId).toBe(receipt.receiptId);
+    expect(await readFile(root, "app/dashboard/page.tsx")).toBe("// user changed after apply\n");
+  });
+
+  it("blocks a stale content hash without overwriting the user change", async () => {
+    await writeFile(root, "spec/contracts/user.contract.ts", "export const version = 1;\n");
+    const plan = await buildExecutableAgentPlan(root, {
+      intent: "update user contract",
+      operations: [
+        {
+          kind: "contract.update",
+          target: "spec/contracts/user.contract.ts",
+          effect: {
+            type: "write",
+            content: "export const version = 2;\n",
+            encoding: "utf8",
+          },
+        },
+      ],
+    });
+    await writeAgentPlan(root, plan);
+    await writeFile(root, "spec/contracts/user.contract.ts", "// user's newer edit\n");
+
+    const receipt = await buildAgentApplyReport(root, { dryRun: false });
+    expect(receipt.ok).toBe(false);
+    expect(receipt.status).toBe("blocked");
+    expect(receipt.warnings.some((warning) => warning.includes("content hash precondition mismatch"))).toBe(true);
+    expect(receipt.rollback.id).toBeNull();
+    expect(await readFile(root, "spec/contracts/user.contract.ts")).toBe("// user's newer edit\n");
+  });
+
+  it("rejects a target moved outside the approved scope", async () => {
+    const plan = await buildExecutableAgentPlan(root, {
+      intent: "add safe file",
+      operations: [
+        {
+          kind: "file.create",
+          target: "src/safe.ts",
+          effect: { type: "write", content: "export {};\n", encoding: "utf8" },
+        },
+      ],
+    });
+    plan.operations[0]!.target = "src/outside.ts";
+    await writeAgentPlan(root, plan);
+
+    const receipt = await buildAgentApplyReport(root, { dryRun: false });
+    expect(receipt.ok).toBe(false);
+    expect(receipt.status).toBe("blocked");
+    expect(receipt.warnings).toContain("op-1: target is outside plan scope");
+    expect(await fs.stat(path.join(root, "src/outside.ts")).catch(() => null)).toBeNull();
+  });
+
+  it("rejects a typed plan whose bound effect was changed after review", async () => {
+    const plan = await buildExecutableAgentPlan(root, {
+      intent: "add reviewed source file",
+      operations: [
+        {
+          kind: "file.create",
+          target: "src/reviewed.ts",
+          effect: { type: "write", content: "export const reviewed = true;\n", encoding: "utf8" },
+        },
+      ],
+    });
+    plan.operations[0]!.effect.content = "export const tampered = true;\n";
+    await writeAgentPlan(root, plan);
+
+    const receipt = await buildAgentApplyReport(root, { dryRun: false });
+    expect(receipt.status).toBe("blocked");
+    expect(receipt.warnings).toContain(
+      "plan content does not match plan.id; bind a fresh executable plan",
+    );
+    expect(await fs.stat(path.join(root, "src/reviewed.ts")).catch(() => null)).toBeNull();
+  });
+
+  it("rolls back every applied file after an injected mid-apply failure", async () => {
+    await writeFile(root, "src/existing.ts", "export const value = 1;\n");
+    const plan = await buildExecutableAgentPlan(root, {
+      intent: "apply two related source changes",
+      operations: [
+        {
+          kind: "file.patch-with-hash",
+          target: "src/existing.ts",
+          effect: {
+            type: "write",
+            content: "export const value = 2;\n",
+            encoding: "utf8",
+          },
+        },
+        {
+          kind: "file.create",
+          target: "src/new.ts",
+          effect: { type: "write", content: "export const added = true;\n", encoding: "utf8" },
+        },
+      ],
+    });
+    await writeAgentPlan(root, plan);
+
+    const receipt = await buildAgentApplyReport(root, {
+      dryRun: false,
+      failureAfterOperations: 2,
+    });
+    expect(receipt.ok).toBe(false);
+    expect(receipt.status).toBe("rolled_back");
+    expect(receipt.rollback.attempted).toBe(true);
+    expect(receipt.rollback.ok).toBe(true);
+    expect(receipt.rollback.restoredFiles.sort()).toEqual(["src/existing.ts", "src/new.ts"]);
+    expect(await readFile(root, "src/existing.ts")).toBe("export const value = 1;\n");
+    expect(await fs.stat(path.join(root, "src/new.ts")).catch(() => null)).toBeNull();
+  });
+
+  it("supports explicit rollback while preserving later conflicting edits", async () => {
+    await writeFile(root, "src/value.ts", "export const value = 1;\n");
+    const plan = await buildExecutableAgentPlan(root, {
+      intent: "update value",
+      operations: [
+        {
+          kind: "file.patch-with-hash",
+          target: "src/value.ts",
+          effect: {
+            type: "write",
+            content: "export const value = 2;\n",
+            encoding: "utf8",
+          },
+        },
+      ],
+    });
+    await writeAgentPlan(root, plan);
+    const receipt = await buildAgentApplyReport(root, { dryRun: false });
+    expect(receipt.rollback.id).not.toBeNull();
+
+    const rolledBack = await rollbackAgentApply(root, receipt.rollback.id!);
+    expect(rolledBack.ok).toBe(true);
+    expect(await readFile(root, "src/value.ts")).toBe("export const value = 1;\n");
+
+    const secondPlan = await buildExecutableAgentPlan(root, {
+      intent: "update value again",
+      operations: [
+        {
+          kind: "file.patch-with-hash",
+          target: "src/value.ts",
+          effect: {
+            type: "write",
+            content: "export const value = 3;\n",
+            encoding: "utf8",
+          },
+        },
+      ],
+    });
+    await writeAgentPlan(root, secondPlan);
+    const secondReceipt = await buildAgentApplyReport(root, { dryRun: false });
+    await writeFile(root, "src/value.ts", "// later user edit\n");
+    const conflict = await rollbackAgentApply(root, secondReceipt.rollback.id!);
+    expect(conflict.ok).toBe(false);
+    expect(conflict.conflicts[0]).toContain("no longer matches");
+    expect(await readFile(root, "src/value.ts")).toBe("// later user edit\n");
+  });
+});

package/src/agent/__tests__/context.test.ts

@@ -10,11 +10,10 @@ import {
 } from "../context";
 import {
   agentPlanPath,
-  buildAgentApplyReport,
   buildAgentPlan,
-  writeAgentApplyReport,
   writeAgentPlan,
 } from "../plan";
+import { buildAgentApplyReport, writeAgentApplyReport } from "../apply";
 import {
   agentRepairReportPath,
   buildAgentRepairReport,
@@ -59,40 +58,40 @@ describe("agent context", () => {
     await writeFile(root, "package.json", JSON.stringify({
       name: "agent-app",
       version: "1.2.3",
-      packageManager: "bun@1.3.14",
+      packageManager: "bun@1.4.0",
     }));
     await writeFile(root, ".mandu/routes.manifest.json", JSON.stringify({
       version: 1,
       routes: [
-        {
-          id: "home",
-          pattern: "/",
-          kind: "page",
-          module: "app/page.tsx",
-          componentModule: "app/page.tsx",
-          layoutChain: [],
-          hydration: { strategy: "island", priority: "visible", preload: false },
-          boundaries: [
-            {
-              id: "home--0",
-              routeId: "home",
-              module: "src/client/HomeWidget.client.tsx",
-              importSpecifier: "@/client/HomeWidget.client",
-              exportName: "HomeWidget",
-              localName: "HomeWidget",
-              hydrate: "visible",
-              ordinal: 0,
-              propsSource: "inline",
-              propsKeys: ["user"],
-              hasSpreadProps: false,
-              source: {
-                file: "app/page.tsx",
-                line: 5,
-                column: 12,
-              },
-            },
-          ],
-        },
+        {
+          id: "home",
+          pattern: "/",
+          kind: "page",
+          module: "app/page.tsx",
+          componentModule: "app/page.tsx",
+          layoutChain: [],
+          hydration: { strategy: "island", priority: "visible", preload: false },
+          boundaries: [
+            {
+              id: "home--0",
+              routeId: "home",
+              module: "src/client/HomeWidget.client.tsx",
+              importSpecifier: "@/client/HomeWidget.client",
+              exportName: "HomeWidget",
+              localName: "HomeWidget",
+              hydrate: "visible",
+              ordinal: 0,
+              propsSource: "inline",
+              propsKeys: ["user"],
+              hasSpreadProps: false,
+              source: {
+                file: "app/page.tsx",
+                line: 5,
+                column: 12,
+              },
+            },
+          ],
+        },
         {
           id: "api-ping",
           pattern: "/api/ping",
@@ -122,27 +121,27 @@ describe("agent context", () => {
 
     expect(context.framework).toBe("mandu");
     expect(context.project.name).toBe("agent-app");
-    expect(context.project.packageManager).toBe("bun@1.3.14");
-    expect(context.routeSource).toBe("manifest");
-    expect(context.routes).toHaveLength(2);
-    expect(context.pages.map((r) => r.id)).toEqual(["home"]);
-    expect(context.pages[0]?.boundaryCount).toBe(1);
-    expect(context.pages[0]?.boundaries?.[0]).toMatchObject({
-      id: "home--0",
-      module: "src/client/HomeWidget.client.tsx",
-      importSpecifier: "@/client/HomeWidget.client",
-      exportName: "HomeWidget",
-      localName: "HomeWidget",
-      ordinal: 0,
-      hydrate: "visible",
-      propsKeys: ["user"],
-      source: {
-        file: "app/page.tsx",
-        line: 5,
-        column: 12,
-      },
-    });
-    expect(context.apis.map((r) => r.id)).toEqual(["api-ping"]);
+    expect(context.project.packageManager).toBe("bun@1.4.0");
+    expect(context.routeSource).toBe("manifest");
+    expect(context.routes).toHaveLength(2);
+    expect(context.pages.map((r) => r.id)).toEqual(["home"]);
+    expect(context.pages[0]?.boundaryCount).toBe(1);
+    expect(context.pages[0]?.boundaries?.[0]).toMatchObject({
+      id: "home--0",
+      module: "src/client/HomeWidget.client.tsx",
+      importSpecifier: "@/client/HomeWidget.client",
+      exportName: "HomeWidget",
+      localName: "HomeWidget",
+      ordinal: 0,
+      hydrate: "visible",
+      propsKeys: ["user"],
+      source: {
+        file: "app/page.tsx",
+        line: 5,
+        column: 12,
+      },
+    });
+    expect(context.apis.map((r) => r.id)).toEqual(["api-ping"]);
     expect(context.apis[0]?.hasContractModule).toBe(true);
     expect(context.partials.map((p) => p.path)).toEqual(["app/dashboard/counter.partial.tsx"]);
     expect(context.islands.map((p) => p.path)).toEqual(["app/dashboard/chart.island.tsx"]);
@@ -162,11 +161,11 @@ describe("agent context", () => {
 
     expect(result.path).toBe(agentManifestPath(root));
     const manifest = await readAgentManifest(root);
-    expect(manifest?.schemaVersion).toBe(1);
-    expect(manifest?.project.name).toBe("agent-app");
-    expect(manifest?.routes[0]?.boundaries?.[0]?.id).toBe("home--0");
-    expect(manifest?.agentWorkflow.canonical).toEqual(["context", "plan", "apply", "verify", "repair"]);
-  });
+    expect(manifest?.schemaVersion).toBe(1);
+    expect(manifest?.project.name).toBe("agent-app");
+    expect(manifest?.routes[0]?.boundaries?.[0]?.id).toBe("home--0");
+    expect(manifest?.agentWorkflow.canonical).toEqual(["context", "plan", "apply", "verify", "repair"]);
+  });
 
   it("builds a deterministic agent plan from intent", () => {
     const plan = buildAgentPlan({
@@ -240,9 +239,9 @@ describe("agent context", () => {
     expect(parsed.project.name).toBe("agent-app");
   });
 
-  it("records changed file reasons and warns on internal API edits", async () => {
-    const version = await runGit(root, ["--version"]);
-    if (!version.ok) return;
+  it("records changed file reasons and warns on internal API edits", async () => {
+    const version = await runGit(root, ["--version"]);
+    if (!version.ok) return;
 
     expect((await runGit(root, ["init"])).ok).toBe(true);
     await runGit(root, ["config", "user.email", "agent@example.com"]);
@@ -264,43 +263,43 @@ describe("agent context", () => {
     expect(reason?.internalApi).toBe(true);
     expect(reason?.recommendedChecks).toContain("bun run check:public-api && bun run check:target-boundaries");
     expect(report.diagnostics.some((diag) => diag.code === "MANDU_VERIFY_INTERNAL_API_EDIT")).toBe(true);
-    expect(report.suggestedCommands.map((cmd) => cmd.command)).toContain(
-      "bun run check:public-api && bun run check:target-boundaries",
-    );
-  });
-
-  it("recommends hydration gates for hydration-sensitive runtime edits", async () => {
-    const version = await runGit(root, ["--version"]);
-    if (!version.ok) return;
-
-    expect((await runGit(root, ["init"])).ok).toBe(true);
-    await runGit(root, ["config", "user.email", "agent@example.com"]);
-    await runGit(root, ["config", "user.name", "Agent"]);
-    expect((await runGit(root, ["add", "."])).ok).toBe(true);
-    expect((await runGit(root, ["commit", "-m", "initial"])).ok).toBe(true);
-
-    await writeFile(root, "packages/core/src/bundler/build.ts", "export const changed = true;\n");
-
-    const report = await buildAgentVerifyReport(root, {
-      includeDiagnose: false,
-      includeGuard: false,
-      includeContract: false,
-    });
-
-    const reason = report.changedFileReasons.find(
-      (entry) => entry.file === "packages/core/src/bundler/build.ts",
-    );
-    expect(reason?.recommendedChecks).toContain("bun run test:hydration-boundary");
-    expect(reason?.recommendedChecks).toContain("bun run test:hydration-e2e");
-    expect(reason?.recommendedChecks).toContain("bun run check:publish");
-
-    const suggestedCommands = report.suggestedCommands.map((cmd) => cmd.command);
-    expect(suggestedCommands).toContain("bun run test:hydration-boundary");
-    expect(suggestedCommands).toContain("bun run test:hydration-e2e");
-    expect(suggestedCommands).toContain("bun run check:publish");
-  });
-
-  it("turns a verify report into repair actions", async () => {
+    expect(report.suggestedCommands.map((cmd) => cmd.command)).toContain(
+      "bun run check:public-api && bun run check:target-boundaries",
+    );
+  });
+
+  it("recommends hydration gates for hydration-sensitive runtime edits", async () => {
+    const version = await runGit(root, ["--version"]);
+    if (!version.ok) return;
+
+    expect((await runGit(root, ["init"])).ok).toBe(true);
+    await runGit(root, ["config", "user.email", "agent@example.com"]);
+    await runGit(root, ["config", "user.name", "Agent"]);
+    expect((await runGit(root, ["add", "."])).ok).toBe(true);
+    expect((await runGit(root, ["commit", "-m", "initial"])).ok).toBe(true);
+
+    await writeFile(root, "packages/core/src/bundler/build.ts", "export const changed = true;\n");
+
+    const report = await buildAgentVerifyReport(root, {
+      includeDiagnose: false,
+      includeGuard: false,
+      includeContract: false,
+    });
+
+    const reason = report.changedFileReasons.find(
+      (entry) => entry.file === "packages/core/src/bundler/build.ts",
+    );
+    expect(reason?.recommendedChecks).toContain("bun run test:hydration-boundary");
+    expect(reason?.recommendedChecks).toContain("bun run test:hydration-e2e");
+    expect(reason?.recommendedChecks).toContain("bun run check:publish");
+
+    const suggestedCommands = report.suggestedCommands.map((cmd) => cmd.command);
+    expect(suggestedCommands).toContain("bun run test:hydration-boundary");
+    expect(suggestedCommands).toContain("bun run test:hydration-e2e");
+    expect(suggestedCommands).toContain("bun run check:publish");
+  });
+
+  it("turns a verify report into repair actions", async () => {
     await writeAgentVerifyReport(root, {
       schemaVersion: 1,
       framework: "mandu",