@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/test/graph-commit-read-copy-calls.test.ts

@@ -0,0 +1,401 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, test } from "vitest";
+import { countingGit } from "@fungi.computer/agar/read-copy";
+import { commitFiles } from "@fungi.computer/agar/git-commit";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { realGit } from "@fungi.computer/agar/test-kit/git";
+import { readCopyFrame, gitStore } from "../backend/git.js";
+import { readRepositoryRefs } from "../backend/repository-copy.js";
+import { ensureBonsaiTables, BonsaiState } from "../backend/state.js";
+import {
+  readGraph,
+  readCommits,
+  readCommitDetail,
+  invalidateGraphCommitCopies,
+  graphCommitCopyKeys,
+  rebuildGraphCommitCopy,
+} from "../backend/graph-commit-copies.js";
+
+async function fixture() {
+  const provider = realGit();
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const state = new BonsaiState(owner.sql, owner.transactionSync);
+  const lifetime = new AbortController();
+  const counted = countingGit(provider.git, {
+    limit: 1000,
+    signal: lifetime.signal,
+  });
+  const bonsai = {
+    state,
+    store: gitStore(counted.git),
+    events: { emit: () => Promise.resolve() },
+  };
+  await provider.git.create("pond");
+  state.registerRepo({
+    name: "pond",
+    description: null,
+    parent: null,
+    owner: null,
+  });
+  const write = await commitFiles(provider.git, {
+    repository: "pond",
+    branch: "main",
+    expectedHead: null,
+    changes: [
+      { path: "notes.txt", content: new TextEncoder().encode("Fish\n") },
+    ],
+    message: "Add fish",
+    author: { name: "Morel", email: "morel@test.invalid" },
+  });
+  if (write.kind !== "committed") throw new Error("Fixture commit failed");
+  state.repositoryCopies.write("pond", write.commit, {
+    defaultBranch: "main",
+    refs: [{ name: "refs/heads/main", hash: write.commit }],
+    cloneUrl: "https://git.test/pond.git",
+    empty: false,
+  });
+  return {
+    provider,
+    bonsai,
+    hash: write.commit,
+    counted,
+    database,
+    owner,
+    close() {
+      lifetime.abort();
+      database.close();
+      provider.close();
+    },
+  };
+}
+
+test("Graph screen reads the ready copy without any Git binding calls", async () => {
+  const f = await fixture();
+  try {
+    const first = await readCopyFrame(f.bonsai.store, (store) =>
+      readGraph({ ...f.bonsai, store }, "pond"),
+    );
+    expect(first.lanes.map((lane) => lane.ref)).toEqual(["main"]);
+    expect(first.nodes.map((node) => node.message)).toEqual(["Add fish"]);
+    const before = f.counted.total();
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+    };
+    expect(
+      await readCopyFrame(reopened.store, (store) =>
+        readGraph({ ...reopened, store }, "pond"),
+      ),
+    ).toEqual(first);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+test("Commits screen reads a ready branch page without any Git calls after restart", async () => {
+  const f = await fixture();
+  try {
+    const input = { repo: "pond", ref: "main" };
+    const first = await readCopyFrame(f.bonsai.store, (store) =>
+      readCommits({ ...f.bonsai, store }, input),
+    );
+    expect(first.commits.map((item) => item.commit.message)).toEqual([
+      "Add fish",
+    ]);
+    const before = f.counted.total();
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+    };
+    expect(
+      await readCopyFrame(reopened.store, (store) =>
+        readCommits({ ...reopened, store }, input),
+      ),
+    ).toEqual(first);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+test("Commit detail keeps its first-parent diff locally across restart", async () => {
+  const f = await fixture();
+  try {
+    const input = { repo: "pond", hash: f.hash };
+    const first = await readCopyFrame(f.bonsai.store, (store) =>
+      readCommitDetail({ ...f.bonsai, store }, input),
+    );
+    expect(
+      first.diff.files.map((file) => ({
+        path: file.path,
+        newText: file.newText,
+      })),
+    ).toEqual([{ path: "notes.txt", newText: "Fish\n" }]);
+    const before = f.counted.total();
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+    };
+    expect(
+      await readCopyFrame(reopened.store, (store) =>
+        readCommitDetail({ ...reopened, store }, input),
+      ),
+    ).toEqual(first);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+test("push invalidation refuses old ready refs when earlier preparation exhausts the frame", async () => {
+  const f = await fixture();
+  try {
+    await readCopyFrame(f.bonsai.store, (store) =>
+      readGraph({ ...f.bonsai, store }, "pond"),
+    );
+    await readCopyFrame(f.bonsai.store, (store) =>
+      readCommits({ ...f.bonsai, store }, { repo: "pond", ref: "main" }),
+    );
+    f.bonsai.state.invalidateRepositoryRefs("pond");
+    invalidateGraphCommitCopies(f.bonsai, "pond");
+    const before = f.counted.total();
+    await expect(
+      readCopyFrame(f.bonsai.store, async (store) => {
+        for (let i = 0; i < 40; i++) await store.info("pond");
+        await store.info("pond");
+      }),
+    ).rejects.toThrow("budget exhausted");
+    expect(f.counted.total() - before).toBe(40);
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+    };
+    await expect(
+      readCopyFrame(reopened.store, (store) =>
+        readGraph({ ...reopened, store }, "pond"),
+      ),
+    ).rejects.toMatchObject({ code: "unavailable" });
+    await expect(
+      readCopyFrame(reopened.store, (store) =>
+        readCommits({ ...reopened, store }, { repo: "pond", ref: "main" }),
+      ),
+    ).rejects.toMatchObject({ code: "unavailable" });
+  } finally {
+    f.close();
+  }
+});
+
+test("Graph includes canonical and fork refs without Git when ready", async () => {
+  const f = await fixture();
+  try {
+    await f.provider.git.create("pond--morel");
+    f.bonsai.state.registerRepo({
+      name: "pond--morel",
+      description: null,
+      parent: "pond",
+      owner: "morel",
+    });
+    const write = await commitFiles(f.provider.git, {
+      repository: "pond--morel",
+      branch: "work",
+      expectedHead: null,
+      changes: [
+        { path: "notes.txt", content: new TextEncoder().encode("Fork fish\n") },
+      ],
+      message: "Fork work",
+      author: { name: "Morel", email: "morel@test.invalid" },
+    });
+    if (write.kind !== "committed") throw Error("Fork fixture commit failed");
+    f.bonsai.state.repositoryCopies.write("pond--morel", write.commit, {
+      defaultBranch: "work",
+      refs: [{ name: "refs/heads/work", hash: write.commit }],
+      cloneUrl: "https://git.test/pond--morel.git",
+      empty: false,
+    });
+    const first = await readCopyFrame(f.bonsai.store, (store) =>
+      readGraph({ ...f.bonsai, store }, "pond"),
+    );
+    expect(
+      first.lanes.map((lane) => ({
+        repo: lane.repo,
+        ref: lane.ref,
+        owner: lane.owner,
+      })),
+    ).toEqual([
+      { repo: "pond", ref: "main", owner: null },
+      { repo: "pond--morel", ref: "work", owner: "morel" },
+    ]);
+    expect(new Set(first.nodes.map((node) => node.message))).toEqual(
+      new Set(["Add fish", "Fork work"]),
+    );
+    const before = f.counted.total();
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+    };
+    expect(
+      await readCopyFrame(reopened.store, (store) =>
+        readGraph({ ...reopened, store }, "pond"),
+      ),
+    ).toEqual(first);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+test("ref deletion removes the lane and branch history while immutable detail stays readable", async () => {
+  const f = await fixture();
+  try {
+    const detail = await readCopyFrame(f.bonsai.store, (store) =>
+      readCommitDetail({ ...f.bonsai, store }, { repo: "pond", hash: f.hash }),
+    );
+    await readCopyFrame(f.bonsai.store, (store) =>
+      readGraph({ ...f.bonsai, store }, "pond"),
+    );
+    await readCopyFrame(f.bonsai.store, (store) =>
+      readCommits({ ...f.bonsai, store }, { repo: "pond", ref: "main" }),
+    );
+    invalidateGraphCommitCopies(f.bonsai, "pond");
+    f.bonsai.state.repositoryCopies.write("pond", null, {
+      defaultBranch: "main",
+      refs: [],
+      cloneUrl: "https://git.test/pond.git",
+      empty: true,
+    });
+    const before = f.counted.total();
+    expect(
+      await readCopyFrame(f.bonsai.store, (store) =>
+        readGraph({ ...f.bonsai, store }, "pond"),
+      ),
+    ).toEqual({ lanes: [], nodes: [] });
+    expect(
+      await readCopyFrame(f.bonsai.store, (store) =>
+        readCommits({ ...f.bonsai, store }, { repo: "pond", ref: "main" }),
+      ),
+    ).toEqual({ ref: "main", commits: [] });
+    expect(
+      await readCopyFrame(f.bonsai.store, (store) =>
+        readCommitDetail(
+          { ...f.bonsai, store },
+          { repo: "pond", hash: f.hash },
+        ),
+      ),
+    ).toEqual(detail);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+test("foreground keys finish a 60-file commit in bounded frames with durable object reuse", async () => {
+  const f = await fixture();
+  try {
+    const write = await commitFiles(f.provider.git, {
+      repository: "pond",
+      branch: "main",
+      expectedHead: f.hash,
+      changes: Array.from({ length: 60 }, (_, index) => ({
+        path: `fish-${String(index)}.txt`,
+        content: new TextEncoder().encode(`Pond fish ${String(index)}\n`),
+      })),
+      message: "Add 60 fish",
+      author: { name: "Morel", email: "morel@test.invalid" },
+    });
+    if (write.kind !== "committed") throw Error("Large fixture commit failed");
+    f.bonsai.state.repositoryCopies.write("pond", write.commit, {
+      defaultBranch: "main",
+      refs: [{ name: "refs/heads/main", hash: write.commit }],
+      cloneUrl: "https://git.test/pond.git",
+      empty: false,
+    });
+    const keys = graphCommitCopyKeys(f.bonsai, "pond");
+    let index = 0,
+      frames = 0,
+      unfinished = 0;
+    while (index < keys.length && frames < 10) {
+      const key = keys[index];
+      if (key === undefined) throw Error("Missing rebuild key");
+      const before = f.counted.total();
+      const runtime = {
+        ...f.bonsai,
+        state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+      };
+      const done = await readCopyFrame(runtime.store, (store) =>
+        rebuildGraphCommitCopy({ ...runtime, store }, key),
+      );
+      expect(f.counted.total() - before).toBeLessThanOrEqual(40);
+      if (done) index++;
+      else unfinished++;
+      frames++;
+    }
+    expect(index).toBe(keys.length);
+    expect(unfinished).toBeGreaterThan(0);
+    const before = f.counted.total();
+    const detail = await readCopyFrame(f.bonsai.store, (store) =>
+      readCommitDetail(
+        { ...f.bonsai, store },
+        { repo: "pond", hash: write.commit },
+      ),
+    );
+    expect(detail.diff.files).toHaveLength(60);
+    expect(detail.diff.additions).toBe(60);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+test("only the current refs refresh can clear pending after facet reconstruction", async () => {
+  const f = await fixture();
+  try {
+    const value = readRepositoryRefs(f.bonsai, "pond");
+    const older = f.bonsai.state.invalidateRepositoryRefs("pond");
+    const newer = f.bonsai.state.invalidateRepositoryRefs("pond");
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+    };
+    expect(
+      reopened.state.publishRepositoryRefs("pond", older, f.hash, value),
+    ).toBe(false);
+    expect(() => readRepositoryRefs(reopened, "pond")).toThrow(
+      "Repository refs are rebuilding",
+    );
+    expect(
+      reopened.state.publishRepositoryRefs("pond", newer, f.hash, value),
+    ).toBe(true);
+    const before = f.counted.total();
+    expect(readRepositoryRefs(reopened, "pond")).toEqual(value);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+test("pending mutable refs do not block an immutable commit detail", async () => {
+  const f = await fixture();
+  try {
+    const input = { repo: "pond", hash: f.hash };
+    const detail = await readCopyFrame(f.bonsai.store, (store) =>
+      readCommitDetail({ ...f.bonsai, store }, input),
+    );
+    f.bonsai.state.invalidateRepositoryRefs("pond");
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+    };
+    const before = f.counted.total();
+    expect(
+      await readCopyFrame(reopened.store, (store) =>
+        readCommitDetail({ ...reopened, store }, input),
+      ),
+    ).toEqual(detail);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});

package/test/home-page.test.ts

@@ -0,0 +1,170 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { act, createElement } from "react";
+import { createRoot } from "react-dom/client";
+import {
+  QueryClient,
+  QueryClientProvider,
+  notifyManager,
+} from "@tanstack/react-query";
+import { createCapabilityRegistry } from "@fungi.computer/agar";
+import { appMethods } from "@fungi.computer/agar/backend";
+import { HomePage } from "../web/home-page.js";
+import { RouterProvider } from "../web/router.js";
+import { connect } from "../web/transport.js";
+import type { JsonValue } from "../shared/contract.js";
+
+const callMethod =
+  vi.fn<(method: string, input: string) => Promise<JsonValue>>();
+
+let container: HTMLDivElement;
+let root: ReturnType<typeof createRoot>;
+let client: QueryClient;
+
+beforeEach(() => {
+  vi.stubGlobal("scrollTo", vi.fn());
+  Object.defineProperty(HTMLElement.prototype, "scrollTo", {
+    configurable: true,
+    value: vi.fn(),
+  });
+  vi.stubGlobal(
+    "matchMedia",
+    vi.fn(() => ({
+      matches: false,
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+    })),
+  );
+  vi.stubGlobal(
+    "ResizeObserver",
+    class {
+      observe = vi.fn();
+      disconnect = vi.fn();
+      unobserve = vi.fn();
+    },
+  );
+  const capabilities = createCapabilityRegistry();
+  capabilities.provide(appMethods, { call: callMethod });
+  connect({ capabilities });
+  Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+  notifyManager.setScheduler(queueMicrotask);
+  client = new QueryClient({
+    defaultOptions: { queries: { retry: false, staleTime: Infinity } },
+  });
+  container = document.createElement("div");
+  document.body.appendChild(container);
+  root = createRoot(container);
+});
+
+afterEach(async () => {
+  await act(async () => {
+    root.unmount();
+    await Promise.resolve();
+  });
+  connect(null);
+  client.clear();
+  container.remove();
+  vi.unstubAllGlobals();
+  vi.resetAllMocks();
+});
+
+const render = async (child: ReturnType<typeof createElement>) => {
+  await act(async () => {
+    root.render(createElement(QueryClientProvider, { client }, child));
+    await Promise.resolve();
+    await Promise.resolve();
+  });
+};
+
+describe("Bonsai home page", () => {
+  it("shows the live board and no README section", async () => {
+    callMethod.mockImplementation((method) => {
+      switch (method) {
+        case "repos.list":
+          return Promise.resolve({
+            repos: [
+              {
+                name: "koi-pond",
+                description: "A pond for koi",
+                parent: null,
+                owner: null,
+                createdAt: 1,
+                lastPushAt: null,
+                forks: [],
+                openChanges: 0,
+                activity: [],
+              },
+            ],
+          });
+        case "actors.list":
+          return Promise.resolve({ agents: [] });
+        case "changes.list":
+          return Promise.resolve({ changes: [] });
+        case "activity.list":
+          return Promise.resolve({
+            events: [
+              {
+                id: 1,
+                at: 1,
+                type: "repo.created",
+                repo: "koi-pond",
+                actor: "ada",
+                data: {},
+              },
+            ],
+          });
+        default:
+          return Promise.reject(new Error(`unexpected method ${method}`));
+      }
+    });
+    await render(
+      createElement(
+        RouterProvider,
+        null,
+        createElement(HomePage, {
+          live: { connected: true, error: null, fresh: new Set<number>() },
+        }),
+      ),
+    );
+    // The window title already says "Bonsai"; the home page renders no
+    // repeated inner title.
+    expect(container.querySelector("h1")).toBeNull();
+    expect(container.textContent).toContain("koi-pond");
+    expect(container.querySelector('[data-tile="readme"]')).toBeNull();
+    expect(
+      [...container.querySelectorAll("h2")].some(
+        (heading) => heading.textContent === "README",
+      ),
+    ).toBe(false);
+    expect(container.textContent).not.toContain("Bonsai is a git platform");
+  });
+  it("shows its empty state on a fresh Oyster with no repositories", async () => {
+    callMethod.mockImplementation((method) => {
+      switch (method) {
+        case "repos.list":
+          return Promise.resolve({ repos: [] });
+        case "actors.list":
+          return Promise.resolve({ agents: [] });
+        case "activity.list":
+          return Promise.resolve({ events: [] });
+        default:
+          return Promise.reject(new Error(`unexpected method ${method}`));
+      }
+    });
+    await render(
+      createElement(
+        RouterProvider,
+        null,
+        createElement(HomePage, {
+          live: { connected: true, error: null, fresh: new Set<number>() },
+        }),
+      ),
+    );
+    expect(
+      [...container.querySelectorAll("h2")].map(
+        (heading) => heading.textContent,
+      ),
+    ).toEqual(["No repositories yet"]);
+    expect(container.textContent).not.toContain("Loading repositories");
+  });
+});