@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/test/files-read-copy-calls.test.ts

@@ -0,0 +1,374 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import {
+  commitFiles,
+  type GitFileChange,
+} from "@fungi.computer/agar/git-commit";
+import {
+  countingGit,
+  ReadCopyBudgetExceeded,
+} from "@fungi.computer/agar/read-copy";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { realGit } from "@fungi.computer/agar/test-kit/git";
+import { gitStore, readCopyFrame } from "../backend/git.js";
+import { ensureBonsaiTables, BonsaiState } from "../backend/state.js";
+import { getRepoDetail } from "../backend/repository-copy.js";
+import {
+  listFilesCopy,
+  listTreeCopy,
+  readFileCopy,
+  invalidateFilesCopies,
+  refreshFilesCopy,
+  filesCopyRequests,
+} from "../backend/files-copy.js";
+
+const input = { repo: "pond", ref: "main" };
+const author = { name: "Morel", email: "morel@test.invalid" };
+const text = (value: string) => new TextEncoder().encode(value);
+
+async function fixture(extra: GitFileChange[] = []) {
+  const database = new DatabaseSync(":memory:");
+  const native = realGit();
+  try {
+    await native.git.create("pond", { defaultBranch: "main" });
+    const outcome = await commitFiles(native.git, {
+      repository: "pond",
+      branch: "main",
+      expectedHead: null,
+      author,
+      message: "Plant the Files fixture",
+      changes: [
+        { path: "README.md", content: text("# Pond\n") },
+        { path: "src/fish.ts", content: text("export const fish = 1;\n") },
+        ...extra,
+      ],
+    });
+    if (outcome.kind !== "committed") throw new Error("Fixture did not commit");
+    const owner = fromNodeSqlite(database);
+    ensureBonsaiTables(owner.sql);
+    const state = new BonsaiState(owner.sql, owner.transactionSync);
+    state.registerRepo({
+      name: "pond",
+      description: null,
+      parent: null,
+      owner: null,
+    });
+    const lifetime = new AbortController();
+    const counted = countingGit(native.git, {
+      limit: 10_000,
+      signal: lifetime.signal,
+    });
+    const runtime = {
+      state,
+      store: gitStore(counted.git),
+      events: { emit: () => Promise.resolve() },
+    };
+    await getRepoDetail(runtime, "pond");
+    return {
+      database,
+      native,
+      runtime,
+      counted,
+      initialHead: outcome.commit,
+      reopen: () => ({
+        ...runtime,
+        state: new BonsaiState(owner.sql, owner.transactionSync),
+      }),
+      close: () => {
+        lifetime.abort();
+        database.close();
+        native.close();
+      },
+    };
+  } catch (error) {
+    database.close();
+    native.close();
+    throw error;
+  }
+}
+
+it("serves listing, directory and file views after facet reconstruction with zero Git calls", async () => {
+  const f = await fixture();
+  try {
+    const listing = await listFilesCopy(f.runtime, input);
+    expect(listing.paths).toEqual(["README.md", "src/", "src/fish.ts"]);
+    expect(listing.truncated).toBe(false);
+    const directory = await listTreeCopy(f.runtime, { ...input, path: "src" });
+    expect(directory.entries.map((entry) => entry.name)).toEqual(["fish.ts"]);
+    const content = await readFileCopy(f.runtime, {
+      ...input,
+      path: "src/fish.ts",
+    });
+    expect(content.blob).toMatch(/^[0-9a-f]{40}$/u);
+    expect(content).toEqual({
+      version: null,
+      commit: f.initialHead,
+      blob: content.blob,
+      ref: "main",
+      path: "src/fish.ts",
+      size: 23,
+      binary: false,
+      text: "export const fish = 1;\n",
+    });
+    const reconstructed = f.reopen();
+    const before = f.counted.total();
+    expect(await listFilesCopy(reconstructed, input)).toEqual(listing);
+    expect(
+      await listTreeCopy(reconstructed, { ...input, path: "src" }),
+    ).toEqual(directory);
+    expect(
+      await readFileCopy(reconstructed, { ...input, path: "src/fish.ts" }),
+    ).toEqual(content);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+it("refuses ready and invalidated mutable Files views across reconstruction while repository refs are pending", async () => {
+  const f = await fixture();
+  try {
+    await listFilesCopy(f.runtime, input);
+    await listTreeCopy(f.runtime, { ...input, path: "src" });
+    await readFileCopy(f.runtime, { ...input, path: "README.md" });
+    const immutable = { repo: "pond", ref: f.initialHead };
+    const listing = await listFilesCopy(f.runtime, immutable);
+    const directory = await listTreeCopy(f.runtime, {
+      ...immutable,
+      path: "src",
+    });
+    const content = await readFileCopy(f.runtime, {
+      ...immutable,
+      path: "README.md",
+    });
+    const revision = f.runtime.state.invalidateRepositoryRefs("pond");
+    const reconstructed = f.reopen();
+    const before = f.counted.total();
+    for (const invalidate of [false, true]) {
+      if (invalidate) invalidateFilesCopies(reconstructed, "pond");
+      await expect(listFilesCopy(reconstructed, input)).rejects.toMatchObject({
+        code: "unavailable",
+      });
+      await expect(
+        listTreeCopy(reconstructed, { ...input, path: "src" }),
+      ).rejects.toMatchObject({ code: "unavailable" });
+      await expect(
+        readFileCopy(reconstructed, { ...input, path: "README.md" }),
+      ).rejects.toMatchObject({ code: "unavailable" });
+      expect(await listFilesCopy(reconstructed, immutable)).toEqual(listing);
+      expect(
+        await listTreeCopy(reconstructed, { ...immutable, path: "src" }),
+      ).toEqual(directory);
+      expect(
+        await readFileCopy(reconstructed, { ...immutable, path: "README.md" }),
+      ).toEqual(content);
+      expect(reconstructed.state.repositoryRefStatus("pond")).toEqual({
+        revision,
+        pending: true,
+      });
+    }
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+it("does not publish an in-flight view after synchronous push invalidation", async () => {
+  const f = await fixture();
+  try {
+    await listFilesCopy(f.runtime, input);
+    const changed = await commitFiles(f.native.git, {
+      repository: "pond",
+      branch: "main",
+      expectedHead: f.initialHead,
+      author,
+      message: "Change the pond",
+      changes: [{ path: "README.md", content: text("# New pond\n") }],
+    });
+    if (changed.kind !== "committed")
+      throw new Error("Fixture push did not commit");
+    f.runtime.state.repositoryCopies.stale("pond");
+    await getRepoDetail(f.runtime, "pond");
+    const concurrentStore = {
+      ...f.runtime.store,
+      commit: async (repo: string, hash: string) => {
+        const value = await f.runtime.store.commit(repo, hash);
+        invalidateFilesCopies(f.runtime, "pond");
+        return value;
+      },
+    };
+    await expect(
+      refreshFilesCopy(
+        { ...f.runtime, store: concurrentStore },
+        { kind: "list", ...input },
+      ),
+    ).rejects.toMatchObject({ code: "unavailable" });
+  } finally {
+    f.close();
+  }
+});
+
+it("retains unfinished Files keys across exhausted shared frames and rebuilds one key per foreground page", async () => {
+  const f = await fixture();
+  try {
+    await listFilesCopy(f.runtime, input);
+    await listTreeCopy(f.runtime, { ...input, path: "src" });
+    await readFileCopy(f.runtime, { ...input, path: "README.md" });
+    const changed = await commitFiles(f.native.git, {
+      repository: "pond",
+      branch: "main",
+      expectedHead: f.initialHead,
+      author,
+      message: "Grow sixty directories",
+      changes: [
+        { path: "README.md", content: text("# Updated pond\n") },
+        ...Array.from({ length: 60 }, (_, n) => ({
+          path: `plants/${String(n).padStart(2, "0")}/plant.ts`,
+          content: text(`export const plant = ${String(n)};\n`),
+        })),
+      ],
+    });
+    if (changed.kind !== "committed")
+      throw new Error("Fixture push did not commit");
+    invalidateFilesCopies(f.runtime, "pond");
+    // This module law starts after metadata publication. The composer owns
+    // the actual push transaction and pre-metadata pending-gate regression.
+    f.runtime.state.repositoryCopies.stale("pond");
+    await getRepoDetail(f.runtime, "pond");
+    const before = f.counted.total();
+    await expect(
+      readCopyFrame(f.runtime.store, async (store) => {
+        for (let n = 0; n < 40; n++) await store.info("pond");
+        await refreshFilesCopy(
+          { ...f.runtime, store },
+          { kind: "list", ...input },
+        );
+      }),
+    ).rejects.toBeInstanceOf(ReadCopyBudgetExceeded);
+    expect(f.counted.total() - before).toBe(40);
+    const reconstructed = f.reopen();
+    const requests = filesCopyRequests(reconstructed, "pond");
+    expect(requests).toEqual([
+      { kind: "list", ...input },
+      { kind: "tree", ...input, path: "src" },
+      { kind: "file", ...input, path: "README.md" },
+    ]);
+    let pages = 0;
+    for (const request of requests) {
+      let ready = false;
+      for (let attempt = 0; attempt < 4 && !ready; attempt++) {
+        const started = f.counted.total();
+        try {
+          await readCopyFrame(reconstructed.store, (store) =>
+            refreshFilesCopy({ ...reconstructed, store }, request),
+          );
+          ready = true;
+        } catch (error) {
+          if (!(error instanceof ReadCopyBudgetExceeded)) throw error;
+        }
+        expect(f.counted.total() - started).toBeLessThanOrEqual(40);
+        pages++;
+      }
+      expect(ready).toBe(true);
+    }
+    expect(pages).toBeGreaterThan(requests.length);
+    const started = f.counted.total();
+    expect((await listFilesCopy(reconstructed, input)).paths).toContain(
+      "plants/59/plant.ts",
+    );
+    expect(
+      (await listTreeCopy(reconstructed, { ...input, path: "src" })).entries[0]
+        ?.name,
+    ).toBe("fish.ts");
+    expect(
+      (await readFileCopy(reconstructed, { ...input, path: "README.md" })).text,
+    ).toBe("# Updated pond\n");
+    expect(f.counted.total() - started).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+it("retains binary, invalid UTF-8, oversized and long-path viewer behavior without warm provider reads", async () => {
+  const longPath = `${Array.from({ length: 6 }, (_, n) => `${String(n)}${"p".repeat(199)}`).join("/")}/leaf.txt`;
+  const f = await fixture([
+    { path: "binary.dat", content: new Uint8Array([0, 1, 2]) },
+    { path: "invalid.txt", content: new Uint8Array([0xff]) },
+    { path: "large.txt", content: text("x".repeat(512_001)) },
+    { path: longPath, content: text("long path\n") },
+  ]);
+  try {
+    for (const [path, expected] of [
+      ["binary.dat", { size: 3, binary: true, text: null }],
+      ["invalid.txt", { size: 1, binary: true, text: null }],
+      ["large.txt", { size: 512_001, binary: false, text: null }],
+      [longPath, { size: 10, binary: false, text: "long path\n" }],
+    ] as const) {
+      expect(await readFileCopy(f.runtime, { ...input, path })).toMatchObject(
+        expected,
+      );
+      const before = f.counted.total();
+      expect(await readFileCopy(f.reopen(), { ...input, path })).toMatchObject(
+        expected,
+      );
+      expect(f.counted.total() - before).toBe(0);
+    }
+    const immutable = { repo: "pond", ref: f.initialHead, path: "large.txt" };
+    await readFileCopy(f.runtime, immutable);
+    invalidateFilesCopies(f.runtime, "pond");
+    f.runtime.state.repositoryCopies.stale("pond");
+    const beforeImmutable = f.counted.total();
+    expect(await readFileCopy(f.reopen(), immutable)).toMatchObject({
+      size: 512_001,
+      text: null,
+    });
+    expect(f.counted.total() - beforeImmutable).toBe(0);
+    // A proven missing leaf is a ready committed absence, not a guessed blob.
+    await getRepoDetail(f.runtime, "pond");
+    expect(
+      await readFileCopy(f.runtime, { ...input, path: "missing.txt" }),
+    ).toEqual({
+      commit: f.initialHead,
+      blob: null,
+      text: null,
+      version: null,
+      ref: "main",
+      path: "missing.txt",
+      size: 0,
+      binary: false,
+    });
+    const absentReads = f.counted.total();
+    expect(
+      await readFileCopy(f.reopen(), { ...input, path: "missing.txt" }),
+    ).toMatchObject({ blob: null, text: null });
+    expect(f.counted.total() - absentReads).toBe(0);
+    expect(
+      filesCopyRequests(f.runtime, "pond").some(
+        (request) => request.kind === "file" && request.path === "missing.txt",
+      ),
+    ).toBe(true);
+  } finally {
+    f.close();
+  }
+});
+
+for (const failure of ["tree", "blob", "directory", "ref"] as const) {
+  it(`does not invent a missing file for ${failure} failure`, async () => {
+    const f = await fixture();
+    try {
+      const binding = { ...f.native.git };
+      if (failure === "tree") binding.readTree = () => Promise.resolve(null);
+      if (failure === "blob") binding.readBlob = () => Promise.resolve(null);
+      const runtime = { ...f.runtime, store: gitStore(binding) };
+      await expect(
+        readFileCopy(runtime, {
+          repo: "pond",
+          ref: failure === "ref" ? "gone" : "main",
+          path: failure === "directory" ? "src" : "README.md",
+        }),
+      ).rejects.toMatchObject({ code: "not_found" });
+    } finally {
+      f.close();
+    }
+  });
+}

package/test/fork-adoption.test.ts

@@ -0,0 +1,111 @@
+import { DatabaseSync } from "node:sqlite";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import type { GitBinding } from "@fungi.computer/agar/git";
+import type { AppMethodCallContext } from "@fungi.computer/puffball/app-method-runtime";
+import { expect, it, vi } from "vitest";
+import { appBackend } from "../backend/methods.js";
+import { gitStore } from "../backend/git.js";
+import { BonsaiState, ensureBonsaiTables } from "../backend/state.js";
+
+const caller: AppMethodCallContext = {
+  computerId: null,
+  actor: { kind: "member", memberId: "Levi" },
+  role: "owner",
+};
+
+/** A host whose fork answers the destination an earlier attempt left. */
+function fixture(fork: GitBinding["fork"]) {
+  const database = new DatabaseSync(":memory:");
+  const sql = fromNodeSqlite(database);
+  ensureBonsaiTables(sql.sql);
+  const state = new BonsaiState(sql.sql, sql.transactionSync);
+  state.registerRepo({
+    name: "pond",
+    description: null,
+    parent: null,
+    owner: null,
+  });
+  const unavailable = () =>
+    Promise.reject(new Error("Unexpected provider operation"));
+  const forks = vi.fn(fork);
+  const binding: GitBinding = {
+    create: unavailable,
+    fork: forks,
+    cloneUrl: (name) => Promise.resolve(`https://git.test/${name}.git`),
+    info: unavailable,
+    delete: unavailable,
+    log: unavailable,
+    readCommit: unavailable,
+    readTree: unavailable,
+    readBlob: unavailable,
+    refs: () =>
+      Promise.resolve([{ name: "refs/heads/main", hash: "a".repeat(40) }]),
+    exchange: unavailable,
+  };
+  const bonsai = {
+    state,
+    store: gitStore(binding),
+    events: { emit: () => Promise.resolve() },
+  };
+  const call = () =>
+    appBackend.call("repos.fork", { repo: "pond" }, { bonsai }, caller);
+  return { database, state, forks, call };
+}
+
+const repository = (name: string, source: string | null) => ({
+  name,
+  defaultBranch: "main",
+  lastPushAt: null,
+  source,
+});
+
+it("adopts an existing provider fork of the same source and registers it", async () => {
+  const f = fixture((source, name) =>
+    Promise.resolve(repository(name, source)),
+  );
+  try {
+    await expect(f.call()).resolves.toMatchObject({
+      name: "pond--Levi",
+      parent: "pond",
+      owner: "Levi",
+    });
+    expect(f.state.repo("pond")?.forks).toEqual(["pond--Levi"]);
+  } finally {
+    f.database.close();
+  }
+});
+
+it("refuses an existing provider repository with another source as a conflict", async () => {
+  const f = fixture((_source, name) =>
+    Promise.resolve(repository(name, "elsewhere")),
+  );
+  try {
+    await expect(f.call()).rejects.toMatchObject({ code: "conflict" });
+    expect(f.state.repo("pond--Levi")).toBeNull();
+    expect(f.state.repo("pond")?.forks).toEqual([]);
+  } finally {
+    f.database.close();
+  }
+});
+
+it("a fork retry after a partial failure registers the fork the first attempt left", async () => {
+  let attempts = 0;
+  const f = fixture((source, name) => {
+    attempts += 1;
+    return attempts === 1
+      ? Promise.reject(new Error("Artifacts activation failed"))
+      : Promise.resolve(repository(name, source));
+  });
+  try {
+    await expect(f.call()).rejects.toThrow("Artifacts activation failed");
+    expect(f.state.repo("pond--Levi")).toBeNull();
+    await expect(f.call()).resolves.toMatchObject({
+      name: "pond--Levi",
+      parent: "pond",
+    });
+    await expect(f.call()).resolves.toMatchObject({ name: "pond--Levi" });
+    expect(f.forks).toHaveBeenCalledTimes(2);
+  } finally {
+    f.database.close();
+  }
+});

package/test/gills.test.ts

@@ -0,0 +1,125 @@
+import { afterEach, expect, test, vi } from "vitest";
+import { openChangesGill, recentCommitsGill } from "../backend/gills.js";
+
+const context = { params: { repo: "pond" } };
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+test("Recent Commits forwards the source page and opens the placement repository", () => {
+  vi.spyOn(Date, "now").mockReturnValue(30 * 60_000);
+  expect(
+    recentCommitsGill.input({
+      params: context.params,
+      limit: 20,
+      after: "opaque-source-cursor",
+    }),
+  ).toEqual({ repo: "pond", limit: 20, after: "opaque-source-cursor" });
+  const record = {
+    hash: "a".repeat(40),
+    treeHash: "b".repeat(40),
+    message: "Keep every returned commit",
+    author: { name: "Levi", email: "levi@test.invalid" },
+    committer: { name: "Levi", email: "levi@test.invalid" },
+    parents: [],
+    authoredAt: 4 * 60,
+    committedAt: 22 * 60,
+  };
+  const output = {
+    ref: "main",
+    commits: [{ commit: record, agent: null }],
+    next: "source-next",
+  };
+  const view = recentCommitsGill.rows(output, context);
+  expect(view.state).toBe("full");
+  if (view.state !== "full") throw new Error("Expected a commit page");
+  expect(view.rows).toHaveLength(1);
+  expect(view.next).toBe("source-next");
+  expect(view.rows[0]?.detail).toContain("8m ago");
+  expect(view.rows[0]?.detail).not.toContain("UTC");
+  expect(view.rows[0]?.open?.params).toEqual([
+    { key: "page", value: "commit" },
+    { key: "repo", value: "pond" },
+    { key: "hash", value: record.hash },
+  ]);
+  const other = recentCommitsGill.rows(output, { params: { repo: "garden" } });
+  expect(other.rows[0]?.open?.params).toContainEqual({
+    key: "repo",
+    value: "garden",
+  });
+});
+
+test("Open Changes reads only open proposals and distinguishes rebuilding from empty", () => {
+  expect(
+    openChangesGill.input({
+      params: context.params,
+      limit: 20,
+      after: "unchanged",
+    }),
+  ).toEqual({ repo: "pond", state: "open", limit: 20, after: "unchanged" });
+  expect(openChangesGill.rows({ kind: "rebuilding" }, context).state).toBe(
+    "error",
+  );
+  expect(openChangesGill.rows({ changes: [] }, context).state).toBe("empty");
+});
+
+test("Open Changes preserves every source row, cursor and App-owned detail route", () => {
+  const records = Array.from({ length: 21 }, (_, index) => ({
+    repo: "pond",
+    number: index + 1,
+    sourceRepo: "pond",
+    sourceRef: "feature",
+    targetRef: "main",
+    title: `Change ${String(index + 1)}`,
+    body: "",
+    openedBy: "member-a",
+    openedKind: "human",
+    createdAt: 1,
+    updatedAt: 2,
+    state: "open",
+    head: "a".repeat(40),
+    target: "b".repeat(40),
+    revision: 1,
+    conflict: null,
+    lease: null,
+    mergedCommit: null,
+    mergedBy: null,
+    closedBy: null,
+    status: "needs-approval",
+    mergeable: { allowed: false, reason: "needs-approval" },
+    base: "b".repeat(40),
+    ahead: 1,
+    behind: 0,
+  }));
+  const result = openChangesGill.rows(
+    { changes: records, next: "untouched-next" },
+    context,
+  );
+  if (result.state !== "full")
+    throw new Error("Expected the returned source rows");
+  expect(result.rows).toHaveLength(21);
+  expect(result.next).toBe("untouched-next");
+  expect(result.rows[0]?.status).toEqual({
+    label: "Needs approval",
+    tone: "warning",
+  });
+  expect(result.rows[0]?.detail).not.toContain("needs-approval");
+  expect(result.rows[20]?.open?.params).toEqual([
+    { key: "page", value: "change" },
+    { key: "repo", value: "pond" },
+    { key: "number", value: "21" },
+  ]);
+});
+
+test("Bonsai widgets declare saved-copy picker methods and recover rebuilding with the host App launch", () => {
+  expect(openChangesGill.declaration.params?.[0]?.options).toBe(
+    "repos.options",
+  );
+  expect(
+    recentCommitsGill.declaration.params?.map((param) => param.options),
+  ).toEqual(["repos.options", "branches.options"]);
+  for (const gill of [openChangesGill, recentCommitsGill])
+    expect(gill.rows({ kind: "rebuilding" }, context)).toMatchObject({
+      state: "error",
+      recovery: { kind: "open" },
+    });
+});

package/test/git-binding.fixture.ts

@@ -0,0 +1,30 @@
+import type { GitStore, GitBinding } from "../backend/git.js";
+
+/** Existing store fixtures expose the same maintained binding used in a facet. */
+export function bindingOf(store: Omit<GitStore, "binding">): GitBinding {
+  return {
+    cloneUrl: (name) => store.cloneUrl(name),
+    create: (name, options) => store.create(name, options?.description ?? ""),
+    fork: (source, name, options) =>
+      store.fork(source, name, options?.description ?? ""),
+    info: (name) => store.info(name),
+    log: async (name, options) => [
+      ...(await store.log(
+        name,
+        options.ref,
+        options.limit ?? 30,
+        options.offset,
+      )),
+    ],
+    readCommit: (name, hash) => store.commit(name, hash),
+    readTree: async (name, hash) => {
+      const entries = await store.tree(name, hash);
+      return entries === null ? null : [...entries];
+    },
+    readBlob: (name, hash) => store.blob(name, hash),
+    refs: async (name) => [...(await store.refs(name))],
+    exchange: (name, request) => store.exchange(name, request),
+    delete: () =>
+      Promise.reject(new Error("Fixture does not delete repositories")),
+  };
+}

package/test/git-push.config.jsonc

@@ -0,0 +1,9 @@
+{
+  "name": "bonsai-push-proof",
+  "compatibility_date": "2026-09-04",
+  "compatibility_flags": ["nodejs_compat"],
+  "durable_objects": {
+    "bindings": [{ "name": "PROBE", "class_name": "BonsaiPushProbe" }],
+  },
+  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["BonsaiPushProbe"] }],
+}