@fungi.computer/bonsai 0.0.0-stage → 0.0.1

package/test/merge-conflict.test.ts

@@ -0,0 +1,337 @@
+/**
+ * The demo's multi-agent shape on real Git: three agent forks of one
+ * repository, merged in order by the owner while main moves under the later
+ * ones. A fork that edits the same lines as an earlier merge must settle a
+ * typed conflict (never a throw), mergeability must then say so, and the
+ * author's ordinary resolution (merge main into the fork, push) must land.
+ */
+import * as z from "zod";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { commitFiles } from "@fungi.computer/agar/git-commit";
+import { countingGit } from "@fungi.computer/agar/read-copy";
+import type { GitBinding } from "@fungi.computer/agar/git";
+import {
+  backgroundContext,
+  backgroundOriginKey,
+  sealBackgroundOrigin,
+  admitClaimedOrigin,
+  type BackgroundBinding,
+} from "@fungi.computer/puffball/background-replay";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { realGit } from "@fungi.computer/agar/test-kit/git";
+import { appBackend } from "../backend/methods.js";
+import { gitStore } from "../backend/git.js";
+import { getRepoDetail } from "../backend/repository-copy.js";
+import { observePush } from "../backend/service.js";
+import { ensureBonsaiTables, BonsaiState } from "../backend/state.js";
+import { changeDetail, mergeResult } from "../shared/contract.js";
+
+const testKey = backgroundOriginKey("bonsai-merge-conflict-test-key");
+const instanceId = "bonsai-test-instance";
+const author = { name: "Owner", email: "owner@test.invalid" };
+const owner = (name: string) => ({
+  actor: { kind: "member" as const, memberId: name },
+  computerId: null,
+  role: "owner" as const,
+});
+const agent = (name: string) => ({
+  actor: { kind: "agent" as const, agentId: name },
+  computerId: null,
+  role: "member" as const,
+});
+const replay: BackgroundBinding = {
+  admit: async (origin) =>
+    admitClaimedOrigin(
+      await testKey,
+      { instanceId, lane: "member:Levi", admitted: ["changes.merge"] },
+      origin,
+    ),
+};
+const changePage = z.object({
+  changes: z.array(z.object({ number: z.number(), sourceRepo: z.string() })),
+});
+const text = (value: string) => new TextEncoder().encode(value);
+
+async function pond() {
+  const provider = realGit();
+  const bare = async (name: string) =>
+    fileURLToPath(await provider.git.cloneUrl(name));
+  // Agar's provider fork: a full copy of the source under the new name.
+  const git: GitBinding = {
+    ...provider.git,
+    fork: async (source, name) => {
+      const from = await bare(source);
+      const to = from.replace(/[^/]+\.git$/u, `${name}.git`);
+      execFileSync("git", ["clone", "-q", "--bare", from, to]);
+      execFileSync("git", [
+        `--git-dir=${to}`,
+        "config",
+        "http.receivepack",
+        "true",
+      ]);
+      return { name, defaultBranch: "main", lastPushAt: null, source };
+    },
+  };
+  const lifetime = new AbortController();
+  const counted = countingGit(git, {
+    limit: 10_000,
+    signal: lifetime.signal,
+  });
+  const database = new DatabaseSync(":memory:");
+  const sqlite = fromNodeSqlite(database);
+  ensureBonsaiTables(sqlite.sql);
+  const bonsai = {
+    state: new BonsaiState(sqlite.sql, sqlite.transactionSync),
+    store: gitStore(counted.git),
+    events: { emit: () => Promise.resolve() },
+  };
+  const fresh = () => ({
+    ...bonsai,
+    state: new BonsaiState(sqlite.sql, sqlite.transactionSync),
+  });
+  await provider.git.create("pond");
+  bonsai.state.registerRepo({
+    name: "pond",
+    description: null,
+    parent: null,
+    owner: null,
+  });
+  const started = await commitFiles(provider.git, {
+    repository: "pond",
+    branch: "main",
+    expectedHead: null,
+    author,
+    message: "Start",
+    changes: [{ path: "main.ts", content: text("pond()\n") }],
+  });
+  if (started.kind !== "committed")
+    throw new Error("Fixture base did not commit");
+  const base = started.commit;
+  await getRepoDetail(bonsai, "pond");
+  let mainHead = base;
+
+  async function observeForkPush(
+    repository: string,
+    name: string,
+    before: string,
+    after: string,
+  ) {
+    await observePush(bonsai, {
+      eventId: `push-${repository}-${after}`,
+      repository,
+      writer: { kind: "actor", actor: { kind: "agent", agentId: name } },
+      updates: [{ ref: "refs/heads/main", before, after }],
+    });
+  }
+
+  /** One agent forks, pushes one commit, and the push opens its Change. */
+  async function forkAndPush(name: string, path: string, content: string) {
+    const fork = z
+      .object({ name: z.string() })
+      .parse(
+        await appBackend.call(
+          "repos.fork",
+          { repo: "pond" },
+          { bonsai },
+          agent(name),
+        ),
+      ).name;
+    const pushed = await commitFiles(provider.git, {
+      repository: fork,
+      branch: "main",
+      expectedHead: base,
+      author,
+      message: `${name} work`,
+      changes: [{ path, content: text(content) }],
+    });
+    if (pushed.kind !== "committed") throw new Error("Fork push failed");
+    await observeForkPush(fork, name, base, pushed.commit);
+    const found = changePage
+      .parse(
+        await appBackend.call(
+          "changes.list",
+          { repo: "pond" },
+          { bonsai },
+          owner("Levi"),
+        ),
+      )
+      .changes.find((change) => change.sourceRepo === fork);
+    if (found === undefined) throw new Error(`No Change for ${fork}`);
+    return { fork, number: found.number, head: pushed.commit };
+  }
+
+  const detail = async (number: number) =>
+    changeDetail.parse(
+      await appBackend.call(
+        "changes.get",
+        { repo: "pond", number },
+        { bonsai },
+        owner("Levi"),
+      ),
+    ).change;
+
+  /** The owner's queued merge, drained the way host wakes drain it. */
+  async function merge(
+    number: number,
+    head: string,
+    key: string,
+    options: { staleTargetCopy?: boolean } = {},
+  ) {
+    const origin = await sealBackgroundOrigin(await testKey, {
+      instanceId,
+      lane: "member:Levi",
+      method: "changes.merge",
+    });
+    const accepted = mergeResult.parse(
+      await appBackend.call(
+        "changes.merge",
+        { repo: "pond", number, head },
+        { bonsai },
+        backgroundContext(
+          { ...owner("Levi"), idempotencyKey: key },
+          [],
+          { name: "changes.merge", effect: "write" },
+          origin,
+        ),
+      ),
+    );
+    // A screen copy rebuilding while the job runs must not cost its outcome.
+    if (options.staleTargetCopy === true)
+      bonsai.state.repositoryCopies.stale("pond");
+    for (let frame = 0; frame < 24; frame++) {
+      if (bonsai.state.requireChange("pond", number).state !== "merging") break;
+      await appBackend.call(
+        "sync",
+        {},
+        { bonsai: fresh(), env: { BACKGROUND: replay } },
+        { ...owner("Levi"), idempotencyKey: `${key}-${String(frame)}` },
+      );
+    }
+    const row = bonsai.state.requireChange("pond", number);
+    // The canonical push of a landed merge reaches Bonsai like any push.
+    if (row.state === "merged" && row.mergedCommit !== null) {
+      await observePush(bonsai, {
+        eventId: `main-${row.mergedCommit}`,
+        repository: "pond",
+        writer: { kind: "actor", actor: { kind: "member", memberId: "Levi" } },
+        updates: [
+          { ref: "refs/heads/main", before: mainHead, after: row.mergedCommit },
+        ],
+      });
+      mainHead = row.mergedCommit;
+    }
+    // The next repository read rebuilds the copy this test made stale.
+    if (options.staleTargetCopy === true) await getRepoDetail(bonsai, "pond");
+    return { accepted, row };
+  }
+
+  /** The demo's resolve pass: merge upstream main, keep both sides, push. */
+  async function resolve(
+    change: { fork: string; head: string },
+    name: string,
+    content: string,
+  ) {
+    const work = mkdtempSync(join(tmpdir(), "bonsai-resolve-"));
+    const git = (...args: string[]) =>
+      execFileSync(
+        "git",
+        ["-c", "user.name=agent", "-c", "user.email=a@test.invalid", ...args],
+        { cwd: work, encoding: "utf8", stdio: "pipe" },
+      ).trim();
+    try {
+      git("clone", "-q", await bare(change.fork), ".");
+      const upstream = await bare("pond");
+      // The same conflict Bonsai reported: Git stops the upstream merge.
+      expect(() =>
+        git("pull", "-q", "--no-rebase", "--no-edit", upstream, "main"),
+      ).toThrow();
+      writeFileSync(join(work, "main.ts"), content);
+      git("add", "main.ts");
+      git("commit", "-q", "--no-edit");
+      git("push", "-q", "origin", "main");
+      const after = git("rev-parse", "HEAD");
+      await observeForkPush(change.fork, name, change.head, after);
+      return after;
+    } finally {
+      rmSync(work, { recursive: true, force: true });
+    }
+  }
+  return {
+    forkAndPush,
+    detail,
+    merge,
+    resolve,
+    close() {
+      lifetime.abort();
+      database.close();
+      provider.close();
+    },
+  };
+}
+
+it("settles a typed conflict with its paths for a fork behind main, merges behind-but-clean forks, and lands the author's resolution", async () => {
+  const f = await pond();
+  try {
+    const enoki = await f.forkAndPush("enoki", "issues.md", "Resize\n");
+    const morel = await f.forkAndPush("morel", "main.ts", "pond()\nfood()\n");
+    const chanterelle = await f.forkAndPush(
+      "chanterelle",
+      "main.ts",
+      "pond()\nripples()\n",
+    );
+
+    expect(
+      (
+        await f.merge(enoki.number, enoki.head, "enoki", {
+          staleTargetCopy: true,
+        })
+      ).row.state,
+    ).toBe("merged");
+    // Behind main by enoki's merge, on a different path: still merges.
+    expect((await f.detail(morel.number)).behind).toBe(1);
+    expect((await f.merge(morel.number, morel.head, "morel")).row.state).toBe(
+      "merged",
+    );
+
+    expect((await f.detail(chanterelle.number)).behind).toBe(2);
+    const conflicted = await f.merge(
+      chanterelle.number,
+      chanterelle.head,
+      "chanterelle",
+    );
+    expect(conflicted.accepted).toEqual({ kind: "merging" });
+    expect(conflicted.row).toMatchObject({
+      state: "open",
+      lease: null,
+      conflict: { head: chanterelle.head, paths: ["main.ts"] },
+    });
+    expect(conflicted.row.mergeFailure).toBeUndefined();
+    const blocked = await f.detail(chanterelle.number);
+    expect(blocked.status).toBe("conflict");
+    expect(blocked.mergeable).toEqual({ allowed: false, reason: "conflict" });
+    // Asking again at the same head and target refuses typed, without Git.
+    expect(
+      (await f.merge(chanterelle.number, chanterelle.head, "again")).accepted,
+    ).toEqual({ kind: "refused", reason: "conflict" });
+
+    const resolved = await f.resolve(
+      chanterelle,
+      "chanterelle",
+      "pond()\nfood()\nripples()\n",
+    );
+    const ready = await f.detail(chanterelle.number);
+    expect(ready).toMatchObject({ head: resolved, behind: 0 });
+    expect(ready.mergeable).toEqual({ allowed: true });
+    expect(
+      (await f.merge(chanterelle.number, resolved, "resolved")).row.state,
+    ).toBe("merged");
+  } finally {
+    f.close();
+  }
+});

package/test/merge-declaration.test.ts

@@ -0,0 +1,46 @@
+import { expect, it } from "vitest";
+import { nativeGitFrameMethods } from "@fungi.computer/agar/git-rpc";
+import {
+  buildAppApi,
+  buildAppDeclaration,
+} from "@fungi.computer/agar/backend-declaration";
+import { appBackend } from "../backend/methods.js";
+import bonsaiMetadata from "../package.json" with { type: "json" };
+const appApi = buildAppApi(appBackend);
+const appDeclaration = buildAppDeclaration(
+  appBackend,
+  bonsaiMetadata.fungi.app,
+);
+
+it("declares every native receive-pack operation used by an owner merge", () => {
+  const required = nativeGitFrameMethods.exchange.requiredOperations([
+    "pond",
+    { service: "receive-pack", phase: "advertise", headers: {}, body: null },
+  ]);
+  const git = appDeclaration.backend?.bindings.find(
+    (binding) => binding.name === "GIT",
+  );
+  expect(required).toEqual(["exchange", "write"]);
+  expect(git?.operations).toEqual(expect.arrayContaining([...required]));
+});
+
+it("requests the installation Git capability for Hub owner merges", () => {
+  const method = appApi.methods["changes.merge"];
+  if (method === undefined) throw new Error("Missing merge method");
+  expect(method.effect).toBe("write");
+  expect(method.requires).toEqual(["git.repository", "app.events.emit"]);
+});
+
+it.each([
+  "insights.layout.get",
+  "insights.layout.save",
+  "repos.list",
+  "activity.list",
+  "actors.list",
+])("keeps %s free of Git authority", (name) => {
+  const method = appApi.methods[name];
+  if (method === undefined) throw new Error(`Missing ${name} method`);
+  expect(method.requires).toEqual(
+    name === "insights.layout.save" ? ["app.events.emit"] : [],
+  );
+});