@fungi.computer/bonsai 0.0.0-stage → 0.0.1

package/backend/files-copy.ts

@@ -0,0 +1,361 @@
+/** Files projections consume the composer's bounded store; they never open a frame. */
+import * as z from "zod";
+import {
+  fileContent,
+  fileList,
+  treeListing,
+  type Commit,
+} from "@fungi.computer/agar/roles/files";
+import { decodeText, isBinary } from "./diff.js";
+import { AppMethodRefusal } from "@fungi.computer/agar/backend";
+import { projectionStore } from "./history.js";
+import { readRepositoryRefs } from "./repository-copy.js";
+import type { Bonsai } from "./service.js";
+
+const requestSchema = z.discriminatedUnion("kind", [
+  z.strictObject({
+    kind: z.literal("list"),
+    repo: z.string(),
+    ref: z.string(),
+  }),
+  z.strictObject({
+    kind: z.literal("tree"),
+    repo: z.string(),
+    ref: z.string(),
+    path: z.string(),
+  }),
+  z.strictObject({
+    kind: z.literal("file"),
+    repo: z.string(),
+    ref: z.string(),
+    path: z.string(),
+  }),
+]);
+export type FilesCopyRequest = z.infer<typeof requestSchema>;
+const registrySchema = z.strictObject({
+  epoch: z.number().int().nonnegative(),
+  entries: z
+    .array(z.strictObject({ key: z.string(), request: requestSchema }))
+    .max(3000),
+});
+const storedFile = fileContent.omit({
+  text: true,
+  pending: true,
+  version: true,
+});
+const MAX_VIEW_BYTES = 512_000;
+
+/** One key is one foreground page. Existing views remain discoverable after invalidation. */
+export function filesCopyRequests(
+  bonsai: Bonsai,
+  repo: string,
+): FilesCopyRequest[] {
+  return registry(bonsai, repo).entries.map((entry) => entry.request);
+}
+
+function registryKey(bonsai: Bonsai, repo: string): string {
+  return JSON.stringify([repo, bonsai.state.repositoryGeneration(repo)]);
+}
+
+function registry(bonsai: Bonsai, repo: string) {
+  const saved = bonsai.state.copies
+    .open("bonsai-files-keys", registrySchema)
+    .read(registryKey(bonsai, repo));
+  return saved.kind === "ready" ? saved.value : { epoch: 0, entries: [] };
+}
+
+/** Invoke before ANY provider await, including repository/Change preparation. */
+export function invalidateFilesCopies(bonsai: Bonsai, repo: string): void {
+  const lists = bonsai.state.copies.open("bonsai-files-list", fileList);
+  const trees = bonsai.state.copies.open("bonsai-files-tree", treeListing);
+  const files = bonsai.state.copies.open("bonsai-files-file", storedFile);
+  const saved = registry(bonsai, repo);
+  bonsai.state.copies
+    .open("bonsai-files-keys", registrySchema)
+    .write(registryKey(bonsai, repo), null, {
+      ...saved,
+      epoch: saved.epoch + 1,
+    });
+  for (const { key, request } of saved.entries) {
+    if (/^[0-9a-f]{40}$/u.test(request.ref)) continue;
+    if (request.kind === "list") lists.stale(key);
+    else if (request.kind === "tree") trees.stale(key);
+    else files.stale(key);
+  }
+}
+
+async function remember(
+  bonsai: Bonsai,
+  request: FilesCopyRequest,
+): Promise<string> {
+  const normalized = requestSchema.parse(request);
+  const generation = bonsai.state.repositoryGeneration(request.repo);
+  const identity = JSON.stringify([generation, normalized]);
+  const found = registry(bonsai, request.repo).entries.find(
+    (entry) => JSON.stringify([generation, entry.request]) === identity,
+  );
+  if (found !== undefined) return found.key;
+  // Public file paths may exceed R0's 1024-character storage-key bound.
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(identity),
+  );
+  const key = Array.from(new Uint8Array(digest), (byte) =>
+    byte.toString(16).padStart(2, "0"),
+  ).join("");
+  if (bonsai.state.repositoryGeneration(request.repo) !== generation)
+    throw new AppMethodRefusal(
+      "unavailable",
+      "Repository changed during Files key registration.",
+    );
+  const saved = registry(bonsai, request.repo);
+  if (!saved.entries.some((entry) => entry.key === key)) {
+    if (saved.entries.length === 3000)
+      throw new AppMethodRefusal("invalid", "Too many Files read-copy keys.");
+    bonsai.state.copies
+      .open("bonsai-files-keys", registrySchema)
+      .write(registryKey(bonsai, request.repo), null, {
+        ...saved,
+        entries: [...saved.entries, { key, request: normalized }],
+      });
+  }
+  return key;
+}
+
+function head(bonsai: Bonsai, request: FilesCopyRequest): string {
+  if (bonsai.state.repo(request.repo) === null)
+    throw new AppMethodRefusal("not_found", "No such repository");
+  if (/^[0-9a-f]{40}$/u.test(request.ref)) return request.ref;
+  const repository = readRepositoryRefs(bonsai, request.repo);
+  const resolved = repository.refs.find(
+    (ref) =>
+      ref.name === request.ref ||
+      ref.name === `refs/heads/${request.ref}` ||
+      ref.name === `refs/tags/${request.ref}`,
+  );
+  if (resolved === undefined)
+    throw new AppMethodRefusal("not_found", "Unknown ref");
+  return resolved.hash;
+}
+
+/** Refresh only this view, sharing the supplied frame budget and immutable objects. */
+export async function refreshFilesCopy(
+  bonsai: Bonsai,
+  request: FilesCopyRequest,
+): Promise<void> {
+  const generation = bonsai.state.repositoryGeneration(request.repo);
+  const key = await remember(bonsai, request);
+  try {
+    const epoch = registry(bonsai, request.repo).epoch;
+    const hash = head(bonsai, request);
+    const checkPublication = () => {
+      if (
+        bonsai.state.repositoryGeneration(request.repo) !== generation ||
+        (!/^[0-9a-f]{40}$/u.test(request.ref) &&
+          registry(bonsai, request.repo).epoch !== epoch) ||
+        head(bonsai, request) !== hash
+      )
+        throw new AppMethodRefusal(
+          "unavailable",
+          "Files copy changed during rebuild.",
+        );
+    };
+    const store = projectionStore(bonsai);
+    const commit = await store.commit(request.repo, hash);
+    if (commit === null) throw new AppMethodRefusal("not_found", "Unknown ref");
+    if (request.kind === "list") {
+      // Preserve the ordinary listing's breadth-first ordering and 3000-path cap,
+      // but consume provider operations serially within the shared frame.
+      const paths: string[] = [];
+      let level = [{ hash: commit.treeHash, prefix: "" }];
+      while (level.length > 0 && paths.length < 3000) {
+        const next: typeof level = [];
+        for (const item of level) {
+          const entries = await store.tree(request.repo, item.hash);
+          for (const entry of entries ?? []) {
+            if (entry.type === "commit") continue;
+            const path = `${item.prefix}${entry.name}`;
+            if (entry.type === "tree") {
+              paths.push(`${path}/`);
+              next.push({ hash: entry.hash, prefix: `${path}/` });
+            } else paths.push(path);
+          }
+        }
+        level = next;
+      }
+      checkPublication();
+      bonsai.state.copies.open("bonsai-files-list", fileList).write(key, hash, {
+        ref: request.ref,
+        commit,
+        paths: paths.slice(0, 3000),
+        truncated: paths.length >= 3000,
+      });
+      return;
+    }
+    const target = await targetAt(store, request.repo, commit, request.path);
+    if (request.kind === "tree") {
+      if (target?.type !== "tree")
+        throw new AppMethodRefusal("not_found", "No such directory");
+      const entries = [
+        ...((await store.tree(request.repo, target.hash)) ?? []),
+      ].sort((a, b) =>
+        a.type === b.type
+          ? a.name.localeCompare(b.name)
+          : a.type === "tree"
+            ? -1
+            : 1,
+      );
+      checkPublication();
+      bonsai.state.copies
+        .open("bonsai-files-tree", treeListing)
+        .write(key, hash, {
+          ref: request.ref,
+          commit,
+          path: request.path,
+          entries,
+        });
+      return;
+    }
+    if (target === null) {
+      checkPublication();
+      bonsai.state.copies
+        .open("bonsai-files-file", storedFile)
+        .write(key, hash, {
+          ref: request.ref,
+          path: request.path,
+          commit: hash,
+          blob: null,
+          size: 0,
+          binary: false,
+        });
+      return;
+    }
+    if (target.type !== "blob")
+      throw new AppMethodRefusal("not_found", "No such file");
+    const bytes = await store.blob(request.repo, target.hash);
+    if (bytes === null) throw new AppMethodRefusal("not_found", "No such file");
+    const decoded = bytes.length > MAX_VIEW_BYTES ? null : decodeText(bytes);
+    checkPublication();
+    bonsai.state.copies.open("bonsai-files-file", storedFile).write(key, hash, {
+      ref: request.ref,
+      path: request.path,
+      commit: hash,
+      blob: target.hash,
+      size: bytes.length,
+      binary: isBinary(bytes) || decoded?.kind === "invalid-utf8",
+    });
+  } catch (error) {
+    if (error instanceof AppMethodRefusal && error.code === "not_found") {
+      const saved = registry(bonsai, request.repo);
+      bonsai.state.copies
+        .open("bonsai-files-keys", registrySchema)
+        .write(registryKey(bonsai, request.repo), null, {
+          ...saved,
+          entries: saved.entries.filter((entry) => entry.key !== key),
+        });
+    }
+    throw error;
+  }
+}
+
+type TreeTarget = Readonly<{ hash: string; type: "tree" | "blob" }>;
+
+async function targetAt(
+  store: ReturnType<typeof projectionStore>,
+  repo: string,
+  commit: Commit,
+  path: string,
+) {
+  let target: TreeTarget = {
+    type: "tree",
+    hash: commit.treeHash,
+  };
+  for (const segment of path.split("/").filter(Boolean)) {
+    if (target.type !== "tree")
+      throw new AppMethodRefusal("not_found", "Not a repository directory");
+    const entries = await store.tree(repo, target.hash);
+    if (entries === null)
+      throw new AppMethodRefusal("not_found", "Directory object is missing");
+    const entry = entries.find((item) => item.name === segment);
+    if (entry === undefined) return null;
+    if (entry.type === "commit")
+      throw new AppMethodRefusal("not_found", "Unsupported repository entry");
+    target = { hash: entry.hash, type: entry.type };
+  }
+  return target;
+}
+
+export async function listFilesCopy(
+  bonsai: Bonsai,
+  input: { repo: string; ref: string },
+) {
+  const request: FilesCopyRequest = { kind: "list", ...input };
+  const key = await remember(bonsai, request);
+  const copies = bonsai.state.copies.open("bonsai-files-list", fileList);
+  let saved = copies.read(key);
+  if (saved.kind !== "ready" || saved.head !== head(bonsai, request)) {
+    await refreshFilesCopy(bonsai, request);
+    saved = copies.read(key);
+  }
+  if (saved.kind !== "ready")
+    throw new AppMethodRefusal("unavailable", "Files copy is rebuilding.");
+  return saved.value;
+}
+
+export async function listTreeCopy(
+  bonsai: Bonsai,
+  input: { repo: string; ref: string; path: string },
+) {
+  const request: FilesCopyRequest = { kind: "tree", ...input };
+  const key = await remember(bonsai, request);
+  const copies = bonsai.state.copies.open("bonsai-files-tree", treeListing);
+  let saved = copies.read(key);
+  if (saved.kind !== "ready" || saved.head !== head(bonsai, request)) {
+    await refreshFilesCopy(bonsai, request);
+    saved = copies.read(key);
+  }
+  if (saved.kind !== "ready")
+    throw new AppMethodRefusal("unavailable", "Files copy is rebuilding.");
+  return saved.value;
+}
+
+export async function readFileCopy(
+  bonsai: Bonsai,
+  input: { repo: string; ref: string; path: string },
+) {
+  const request: FilesCopyRequest = { kind: "file", ...input };
+  const key = await remember(bonsai, request);
+  const copies = bonsai.state.copies.open("bonsai-files-file", storedFile);
+  let saved = copies.read(key);
+  if (
+    saved.kind !== "ready" ||
+    saved.head !== head(bonsai, request) ||
+    (saved.value.blob !== null &&
+      !saved.value.binary &&
+      saved.value.size <= MAX_VIEW_BYTES &&
+      bonsai.state.copies.readBlob(saved.value.blob) === null)
+  ) {
+    await refreshFilesCopy(bonsai, request);
+    saved = copies.read(key);
+  }
+  if (saved.kind !== "ready")
+    throw new AppMethodRefusal("unavailable", "File copy is rebuilding.");
+  const value = saved.value;
+  const bytes =
+    value.blob === null || value.binary || value.size > MAX_VIEW_BYTES
+      ? null
+      : bonsai.state.copies.readBlob(value.blob);
+  if (
+    value.blob !== null &&
+    !value.binary &&
+    value.size <= MAX_VIEW_BYTES &&
+    bytes === null
+  )
+    throw new AppMethodRefusal("unavailable", "File copy is rebuilding.");
+  const decoded = bytes === null ? null : decodeText(bytes);
+  return {
+    ...value,
+    version: null,
+    text: decoded?.kind === "text" ? decoded.text : null,
+  };
+}

package/backend/gills.ts

@@ -0,0 +1,125 @@
+import { defineAppGill, type AppBackendGill } from "@fungi.computer/agar/gills";
+import { changePage, repoSummary } from "../shared/contract.js";
+import {
+  commitPage,
+  readCopyRebuilding,
+} from "@fungi.computer/agar/roles/files";
+import {
+  changeStatusLabel,
+  changeStatusTone,
+  relativeTime,
+} from "../shared/presentation.js";
+
+const repositoryParam = {
+  key: "repo",
+  label: "Repository",
+  kind: "repository" as const,
+  required: true,
+  options: "repos.options",
+};
+const repository = repoSummary.shape.name;
+
+export const openChangesGill = defineAppGill({
+  id: "open-changes",
+  title: "Open Changes",
+  source: "changes.list",
+  limit: 20,
+  sizes: ["M", "L"],
+  params: [repositoryParam],
+  input: ({ params, limit, after }): ReturnType<AppBackendGill["input"]> => {
+    const input = { repo: repository.parse(params.repo), state: "open", limit };
+    return after === undefined ? input : { ...input, after };
+  },
+  rows: (output) => {
+    const identity = { viewId: "open-changes", title: "Open Changes" };
+    if (readCopyRebuilding.safeParse(output).success)
+      return {
+        ...identity,
+        state: "error",
+        rows: [],
+        recovery: { kind: "open" },
+        error:
+          "Saved changes are rebuilding. Open Bonsai to finish the rebuild.",
+      };
+    const page = changePage.parse(output);
+    if (page.changes.length === 0)
+      return { ...identity, state: "empty", rows: [] };
+    const rows = page.changes.map((change) => ({
+      id: String(change.number),
+      title: change.title,
+      detail: `#${String(change.number)} · ${change.sourceRef} → ${change.targetRef}`,
+      status: {
+        label: changeStatusLabel(change.status),
+        tone: changeStatusTone[change.status],
+      },
+      open: {
+        params: [
+          { key: "page", value: "change" },
+          { key: "repo", value: change.repo },
+          { key: "number", value: String(change.number) },
+        ],
+      },
+    }));
+    return page.next === undefined
+      ? { ...identity, state: "full", rows }
+      : { ...identity, state: "full", rows, next: page.next };
+  },
+});
+
+export const recentCommitsGill = defineAppGill({
+  id: "recent-commits",
+  title: "Recent Commits",
+  source: "commits.list",
+  limit: 20,
+  sizes: ["M", "L"],
+  params: [
+    repositoryParam,
+    {
+      key: "branch",
+      label: "Branch",
+      kind: "branch",
+      required: false,
+      options: "branches.options",
+    },
+  ],
+  input: ({ params, limit, after }): ReturnType<AppBackendGill["input"]> => {
+    const input = { repo: repository.parse(params.repo), limit };
+    const selected =
+      params.branch === undefined ? input : { ...input, ref: params.branch };
+    return after === undefined ? selected : { ...selected, after };
+  },
+  rows: (output, { params }) => {
+    const identity = { viewId: "recent-commits", title: "Recent Commits" };
+    if (readCopyRebuilding.safeParse(output).success)
+      return {
+        ...identity,
+        state: "error",
+        rows: [],
+        recovery: { kind: "open" },
+        error:
+          "Saved commits are rebuilding. Open Bonsai to finish the rebuild.",
+      };
+    const page = commitPage.parse(output);
+    const repo = repository.parse(params.repo);
+    if (page.commits.length === 0)
+      return { ...identity, state: "empty", rows: [] };
+    const rows = page.commits.map(({ commit, agent }) => ({
+      id: commit.hash,
+      title:
+        commit.message.trim().length === 0
+          ? commit.hash.slice(0, 8)
+          : (commit.message.split("\n")[0] ?? commit.hash.slice(0, 8)),
+      detail: `${commit.hash.slice(0, 8)} · ${agent ?? commit.author.name} · ${relativeTime(commit.committedAt * 1000)} · ${page.ref}`,
+      open: {
+        params: [
+          { key: "page", value: "commit" },
+          { key: "repo", value: repo },
+          { key: "hash", value: commit.hash },
+        ],
+      },
+    }));
+    return page.next === undefined
+      ? { ...identity, state: "full", rows }
+      : { ...identity, state: "full", rows, next: page.next };
+  },
+});

package/backend/git.ts

@@ -0,0 +1,123 @@
+/**
+ * Bonsai's view of git: the host's GIT binding (agar's `GitBinding`, the
+ * Artifacts binding surface scoped to this installation) wrapped as a
+ * GitStore whose results are parsed into the shared contract. Bonsai never
+ * holds a credential or a provider remote.
+ */
+import * as z from "zod";
+import { countingGit } from "@fungi.computer/agar/read-copy";
+import { ref as refSchema, type Ref } from "../shared/contract.js";
+import {
+  commit as commitSchema,
+  treeEntry as treeEntrySchema,
+  type Commit,
+  type TreeEntry,
+} from "@fungi.computer/agar/roles/files";
+
+import type {
+  GitBinding,
+  GitExchangeRequest,
+  GitExchangeResponse,
+  GitRepositoryInfo as RepoInfo,
+} from "@fungi.computer/agar/git";
+
+export type { GitBinding, GitExchangeRequest, GitExchangeResponse, RepoInfo };
+
+export type GitStore = Readonly<{
+  binding: GitBinding;
+  cloneUrl(name: string): Promise<string>;
+  create(name: string, description: string): Promise<RepoInfo>;
+  fork(source: string, target: string, description: string): Promise<RepoInfo>;
+  info(name: string): Promise<RepoInfo | null>;
+  log(
+    name: string,
+    ref: string,
+    limit: number,
+    offset?: number,
+  ): Promise<readonly Commit[]>;
+  commit(name: string, hash: string): Promise<Commit | null>;
+  tree(name: string, hash: string): Promise<readonly TreeEntry[] | null>;
+  blob(name: string, hash: string): Promise<Uint8Array | null>;
+  refs(name: string): Promise<readonly Ref[]>;
+  exchange(
+    name: string,
+    request: GitExchangeRequest,
+  ): Promise<GitExchangeResponse>;
+}>;
+
+const repoInfoSchema = z.object({
+  name: z.string(),
+  defaultBranch: z.string(),
+  lastPushAt: z.string().nullable(),
+  source: z.string().nullable(),
+});
+
+const exchangeSchema = z.object({
+  status: z.number(),
+  headers: z.record(z.string(), z.string()),
+  body: z.instanceof(Uint8Array),
+});
+
+/** Parse every binding result: the binding is an I/O boundary. */
+export function gitStore(binding: GitBinding): GitStore {
+  return {
+    binding,
+    async cloneUrl(name) {
+      return z.url().parse(await binding.cloneUrl(name));
+    },
+    async create(name, description) {
+      return repoInfoSchema.parse(
+        await binding.create(name, { description, defaultBranch: "main" }),
+      );
+    },
+    async fork(source, target, description) {
+      return repoInfoSchema.parse(
+        await binding.fork(source, target, { description }),
+      );
+    },
+    async info(name) {
+      const raw = await binding.info(name);
+      return raw === null ? null : repoInfoSchema.parse(raw);
+    },
+    async log(name, ref, limit, offset = 0) {
+      return z
+        .array(commitSchema)
+        .parse(await binding.log(name, { ref, limit, offset }));
+    },
+    async commit(name, hash) {
+      const raw = await binding.readCommit(name, hash);
+      return raw === null ? null : commitSchema.parse(raw);
+    },
+    async tree(name, hash) {
+      const raw = await binding.readTree(name, hash);
+      return raw === null ? null : z.array(treeEntrySchema).parse(raw);
+    },
+    async blob(name, hash) {
+      const raw = await binding.readBlob(name, hash);
+      return raw === null ? null : z.instanceof(Uint8Array).parse(raw);
+    },
+    async refs(name) {
+      return z.array(refSchema).parse(await binding.refs(name));
+    },
+    async exchange(name, request) {
+      return exchangeSchema.parse(await binding.exchange(name, request));
+    },
+  };
+}
+
+/** One provider budget and lifetime for an App-owned projection frame. */
+export async function readCopyFrame<T>(
+  store: GitStore,
+  body: (store: GitStore, signal: AbortSignal) => Promise<T>,
+): Promise<T> {
+  const lifetime = new AbortController();
+  try {
+    const counted = countingGit(store.binding, {
+      limit: 40,
+      signal: lifetime.signal,
+    });
+    return await body(gitStore(counted.git), lifetime.signal);
+  } finally {
+    lifetime.abort();
+  }
+}