f893244 · d83d24b · b6590fd · 37f854b · 9a5254d · 8e2125c
@@ -30,6 +30,7 @@
for a tunnel and a forge that sleeps.
| `apps`         | the apps you can see: live or not, where served, how each runs itself, what is working            |        |
| `tell`         | a sentence becomes an issue, a builder is picked, a run starts on the crew's next tick            | yes    |
| `say`          | speak on an issue or a pull; a working builder hears it as its next step                          | yes    |
| `pull`         | `{ repo, number }`: a pull's title, state, head and base, and for an open pull whether it merges into the base's current head (`mergeable`) and the paths that stop it (`conflicts`); the same fields as `GET …/pulls/:number` |        |
| `edit`         | a new title or body for an issue or a pull: its author's, or a writer's; an agent edits only what it wrote | yes    |
| `seal`         | `{ repo, number, sealed }`: seal a security report (and the pull that fixes it) so only writers and the crew see it, or unseal it for every reader; a writer's, recorded | yes    |
| `now`          | what the crew is doing right now: who, on what, since when, at what cost; a planner that declined the direction and waits for you comes first (`run: null`, its words in `says`) |        |
@@ -574,6 +574,9 @@
whole review with `bad_anchor`, and the message says how an anchor is written.
This is the one way the crew's reviewer brief posts a review.
`GET …/pulls/:number` gains `status.reviews:
{ approved, changesRequested, required, mergeable }`.
`GET …/pulls` and `GET …/pulls/:number` carry `mergeable` (does the head merge
into the base's current head) and `conflicts` (the paths that stop it) on open
pulls only; a merged or closed pull leaves both out.
Repo JSON gains `origin: { originId, kind, fullName, htmlUrl, host, lastFetchAt,
fetchError, detached, frozenSince, detachedAt } | null` — a detached mirror
@@ -92,6 +92,7 @@
export const GATE: readonly string[] = [
  "test/fork-flow.test.ts",
  "test/fork-pull-approval.test.ts",
  "test/cross-repo-pull.test.ts",
  "test/pull-mergeable.test.ts",
  "test/pulls.test.ts",
  "test/api-reader-marks.test.ts",
  "test/app-members.test.ts",
@@ -12,6 +12,7 @@
import { sealedByNumber } from "./sealed.ts";
import type { Database } from "bun:sqlite";
import { diffRange, type Diff } from "../git/diff.ts";
import { isSafeRef } from "../git/guard.ts";
import { listRefs } from "../git/read.ts";
import {
  aheadCount,
  fetchInto,
@@ -627,29 +628,112 @@
export async function pullStatus(
    : `refs/heads/${pull.headBranch}`;
  const headOid = (await resolveOid(dir, headRef)) ?? pull.headOid;
  const reviews = gate === undefined ? null : reviewGate(gate, pull, headOid);
  const { ahead, mergeable: clean, conflicts } = await mergeReading(
    dir,
    baseOid,
    headOid,
  );
  return { baseOid, headOid, ahead, mergeable: clean, conflicts, reviews };
}
interface MergeReading {
  readonly ahead: number;
  readonly mergeable: boolean;
  readonly conflicts: string[];
}
/** Readings by `head:base` oid: a merge-tree over two commits never changes. */
const readings = new Map<string, MergeReading>();
const READINGS_MAX = 500;
async function mergeReading(
  dir: string,
  baseOid: string,
  headOid: string,
): Promise<MergeReading> {
  const key = `${headOid}:${baseOid}`;
  const known = readings.get(key);
  if (known !== undefined) return { ...known, conflicts: [...known.conflicts] };
  const ahead = await aheadCount(dir, baseOid, headOid);
  if (ahead === 0) {
    return {
      baseOid,
      headOid,
      ahead,
      mergeable: false,
      conflicts: [],
      reviews,
    };
  let reading: MergeReading;
  if (ahead === 0) reading = { ahead, mergeable: false, conflicts: [] };
  else {
    const check = await mergeable(dir, baseOid, headOid);
    reading = check.ok
      ? { ahead, mergeable: true, conflicts: [] }
      : {
          ahead,
          mergeable: false,
          conflicts: check.error.kind === "conflict" ? check.error.files : [],
        };
    // A git failure is not a verdict about the commits: do not remember it.
    if (!check.ok && check.error.kind !== "conflict") return reading;
  }
  const check = await mergeable(dir, baseOid, headOid);
  if (check.ok)
    return {
      baseOid,
      headOid,
      ahead,
      mergeable: true,
      conflicts: [],
      reviews,
    };
  const conflicts = check.error.kind === "conflict" ? check.error.files : [];
  return { baseOid, headOid, ahead, mergeable: false, conflicts, reviews };
  if (readings.size >= READINGS_MAX)
    readings.delete(readings.keys().next().value!);
  readings.set(key, reading);
  return { ...reading, conflicts: [...reading.conflicts] };
}
/**
 * Whether an open pull merges into its base's current head, and the paths
 * that stop it — what the API and the MCP say on every reading of a pull.
 * Null for a pull that is no longer open: there is nothing left to merge.
 */
export async function pullMergeState(
  dir: string,
  pull: Pull,
): Promise<{ mergeable: boolean; conflicts: string[] } | null> {
  if (pull.state !== "open" || pull.mergedAt !== null) return null;
  const { mergeable: clean, conflicts } = await pullStatus(dir, pull);
  return { mergeable: clean, conflicts };
}
/** How many merge readings a list runs at once: a page is never a fork bomb. */
const READ_AT_ONCE = 4;
/**
 * `pullMergeState` for a page of pulls: one `for-each-ref` per repository
 * directory instead of two `rev-parse` per pull, and at most `READ_AT_ONCE`
 * readings in flight. Same answers, same order as the input.
 */
export async function pullMergeStates(
  items: readonly { dir: string; pull: Pull }[],
): Promise<({ mergeable: boolean; conflicts: string[] } | null)[]> {
  const tips = new Map<string, Promise<Map<string, string>>>();
  const tipsOf = (dir: string): Promise<Map<string, string>> => {
    let known = tips.get(dir);
    if (known === undefined) {
      known = listRefs(dir).then((refs) => {
        const out = new Map<string, string>();
        if (refs.ok) for (const r of refs.value) out.set(r.name, r.oid);
        return out;
      });
      tips.set(dir, known);
    }
    return known;
  };
  const out: ({ mergeable: boolean; conflicts: string[] } | null)[] =
    new Array(items.length).fill(null);
  let next = 0;
  const worker = async (): Promise<void> => {
    for (let i = next++; i < items.length; i = next++) {
      const { dir, pull } = items[i]!;
      if (pull.state !== "open" || pull.mergedAt !== null) continue;
      const live = await tipsOf(dir);
      const baseOid = live.get(`refs/heads/${pull.baseBranch}`) ?? pull.baseOid;
      const headRef = pull.crossRepo
        ? `refs/pull/${pull.number}/head`
        : `refs/heads/${pull.headBranch}`;
      const headOid = live.get(headRef) ?? pull.headOid;
      const r = await mergeReading(dir, baseOid, headOid);
      out[i] = { mergeable: r.mergeable, conflicts: r.conflicts };
    }
  };
  await Promise.all(
    Array.from({ length: Math.min(READ_AT_ONCE, items.length) }, worker),
  );
  return out;
}
/**
@@ -160,6 +160,7 @@
import {
  listPulls,
  pullDiff,
  pullDir,
  pullMergeStates,
  type Pull,
} from "../core/pulls.ts";
import {
@@ -2705,17 +2706,23 @@
export function apiRoutes(router: Router<Handler>): void {
  // ── pull requests — so automation drives the review/merge loop ───────
  router.add("GET", "/api/v1/repos/:owner/:name/pulls", (ctx) => {
  router.add("GET", "/api/v1/repos/:owner/:name/pulls", async (ctx) => {
    const repo = loadRepo(ctx);
    if (!repo) return notFound();
    const query = listQuery(ctx);
    const items = withLabelsMany(
      ctx,
      listPulls(ctx.app.db, repo.id, {
        ...query,
        ...sealedScope(ctx.app.db, repo, ctx.auth.user),
      }),
    const pulls = listPulls(ctx.app.db, repo.id, {
      ...query,
      ...sealedScope(ctx.app.db, repo, ctx.auth.user),
    });
    const states = await pullMergeStates(
      
        sentinelcrew
        1mo ago
        outdated
      
      Medium: the cache only stores the merge-tree result. Each open pull still spawns two git rev-parse in pullStatus, all at once and on every request, and anonymous readers of a public repo can trigger it. Resolve refs once per request (one for-each-ref, or the stored oids) and cap how many run at once.
    
      await Promise.all(
        pulls.map(async (p) => ({ dir: await pullDirOf(ctx, repo, p), pull: p })),
      
        sentinelcrew
        1mo ago
        
      
      Low: this calls pullDirOf for every pull on the page, including closed and merged ones whose state is then dropped. For a sealed cross-repo pull, pullDir runs followBase, which is a git fetch. That makes a plain GET do unbounded fetches, outside the READ_AT_ONCE cap. Filter first: resolve a dir only for p.state === "open" && p.mergedAt === null, or let pullMergeStates resolve dirs inside its capped workers.
    
      ),
    );
    const items = withLabelsMany(ctx, pulls).map((item, i) => ({
      ...item,
      ...(states[i] ?? {}),
    }));
    return json(paged(items, query.limit, (p) => p.number));
  });
@@ -2777,6 +2784,9 @@
export function apiRoutes(router: Router<Handler>): void {
    const hold = getHold(ctx.app.db, found.pull.id);
    return json({
      ...withLabels(ctx, found.pull),
      ...(found.pull.state === "open" && found.pull.mergedAt === null
      
        sentinelcrew
        1mo ago
        outdated
      
      Low: status from pullDiff above already carries mergeable and conflicts. Reuse it here (when the pull is open) instead of running pullStatus again.
    
      
        sentinelcrew
        1mo ago
        
      
      Leaving the fields out for closed and merged pulls is a behaviour this change adds, and no test covers it. Close the pull in test/pull-mergeable.test.ts, then assert that the detail route, the list (?state=all) and the MCP tool all omit mergeable and conflicts.
    
        ? { mergeable: status.mergeable, conflicts: status.conflicts }
        : {}),
      status,
      diff,
      hold: hold === undefined ? null : holdJson(hold),
@@ -59,7 +59,7 @@
import { getIssue, getIssueById, listOpenAgentPullsVisibleTo } from "../core/iss
import { waitsForPerson } from "../crew/review.ts";
import { attachLook } from "../actions/attach_look.ts";
import { lookUrl } from "../core/looks.ts";
import { getPull } from "../core/pulls.ts";
import { getPull, pullDir, pullMergeState } from "../core/pulls.ts";
import { repoGraph } from "../core/dependencies.ts";
import { pillarView } from "../core/pillars.ts";
import { getAppByRepo } from "../core/apps.ts";
@@ -371,6 +371,43 @@
const TOOLS: readonly Tool[] = [
        : bad("refused", "that could not be said here");
    },
  },
  {
    name: "pull",
      
        sentinelcrew
        1mo ago
        
      
      This is a new tool, but docs/MCP.md has no pull row in its tool table. Add one so it is reachable by documentation as well as by tools/list.
    
    description:
      "Read a pull: its title, state and head and base, and for an open pull whether it merges into the base's current head (`mergeable`) and the paths that stop it (`conflicts`). The same two fields as GET /api/v1/repos/:owner/:name/pulls/:number.",
    inputSchema: {
      type: "object",
      properties: {
        repo: REPO_ARG,
        number: { type: "integer", minimum: 1 },
      },
      required: ["repo", "number"],
    },
    writes: false,
    async run(ctx, user, args) {
      const repo = repoArg(ctx, user, args);
      if (isAnswer(repo)) return repo;
      const n = args["number"];
      const pull =
        typeof n === "number" && Number.isInteger(n) && n > 0
          ? getPull(ctx.app.db, repo.id, n)
          : undefined;
      if (pull === undefined || !mayView(ctx.app.db, repo, pull, user))
        return bad("no_such_pull", `no pull #${String(n)}`);
      
        sentinelcrew
        1mo ago
        
      
      The mayView gate is correct here. Add a test that would fail without it: a sealed pull, or a pull in a private repository, read by someone who cannot see it, must answer no_such_pull.
    
      const state = await pullMergeState(
        await pullDir(ctx.app.db, ctx.app.reposRoot, repo, pull),
        pull,
      );
      return good({
        number: pull.number,
        title: pull.title,
        state: pull.mergedAt !== null ? "merged" : pull.state,
        base: pull.baseBranch,
        head: pull.headBranch,
        ...(state ?? {}),
      });
    },
  },
  {
    name: "edit",
    description:
@@ -159,6 +159,7 @@
describe("the forge over MCP", () => {
      "tell",
      "share",
      "say",
      "pull",
      "edit",
      "asks",
      "asks_act",
@@ -0,0 +1,207 @@
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp, type App } from "../src/app.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { gitClientEnv } from "./helpers/git-client.ts";
const gitEnv = gitClientEnv();
describe("a pull says whether it merges", () => {
  let dataDir: string;
  let work: string;
  let app: App;
  let servers: Servers;
  let base: string;
  let token = "";
  let dir: string;
  async function gitOk(args: string[]): Promise<void> {
    const p = Bun.spawn(["git", ...args], {
      cwd: dir,
      env: gitEnv,
      stdout: "ignore",
      stderr: "pipe",
    });
    const [err, code] = await Promise.all([
      new Response(p.stderr).text(),
      p.exited,
    ]);
    if (code !== 0) throw new Error(`git ${args.join(" ")}: ${err}`);
  }
  const auth = { authorization: "" };
  const api = async (path: string, init: RequestInit = {}) =>
    (await fetch(`${base}/api/v1/repos/dev/app${path}`, {
      ...init,
      headers: { ...auth, "content-type": "application/json" },
    })).json() as Promise<any>;
  const mcp = async (name: string, args: unknown, as?: string) => {
    const res = await fetch(`${base}/mcp`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        accept: "application/json, text/event-stream",
        ...auth,
        ...(as ? { authorization: `Bearer ${as}` } : {}),
      },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: 1,
        method: "tools/call",
        params: { name, arguments: args },
      }),
    });
    const body = (await res.json()) as any;
    const text = body.result.content[0].text as string;
    try {
      return JSON.parse(text);
    } catch {
      return { error: text };
    }
  };
  const write = async (text: string, message: string) => {
    await Bun.write(join(dir, "code.txt"), text);
    await gitOk(["commit", "-am", message]);
  };
  beforeAll(async () => {
    dataDir = await mkdtemp(join(tmpdir(), "forge-pm-"));
    work = await mkdtemp(join(tmpdir(), "forge-pm-work-"));
    app = createApp({ dataDir, port: 0 });
    servers = await serve(app);
    base = servers.url;
    await fetch(`${base}/signup`, {
      method: "POST",
      body: new URLSearchParams({
        username: "dev",
        email: "[email protected]",
        password: "pull-mergeable-pass",
      }),
      redirect: "manual",
    });
    token = await fetch(`${base}/api/v1/tokens`, {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({
        adminConfirm: true,
        username: "dev",
        password: "pull-mergeable-pass",
        name: "cli",
        scope: "rw",
      }),
    })
      .then((r) => r.json())
      .then((j) => (j as { token: string }).token);
    auth.authorization = `Bearer ${token}`;
    await fetch(`${base}/api/v1/repos`, {
      method: "POST",
      headers: { ...auth, "content-type": "application/json" },
      body: JSON.stringify({ name: "app", visibility: "public" }),
    });
    const remote = `${base.replace("http://", `http://dev:${token}@`)}/dev/app.git`;
    dir = work;
    await gitOk(["clone", remote, "app"]);
    dir = join(work, "app");
    await Bun.write(join(dir, "code.txt"), "alpha\nbeta\ngamma\n");
    await gitOk(["add", "."]);
    await gitOk(["commit", "-m", "base"]);
    await gitOk(["push", "origin", "main"]);
  });
  afterAll(async () => {
    servers.stop();
    app.close();
    await rm(dataDir, { recursive: true, force: true });
    await rm(work, { recursive: true, force: true });
  });
  test("a conflicting pull reads false with the path; once the base resolves it, true", async () => {
    await gitOk(["checkout", "-b", "loud"]);
    await write("alpha\nBETA\ngamma\n", "loud beta");
    await gitOk(["push", "origin", "loud"]);
    const made = await api("/pulls", {
      method: "POST",
      body: JSON.stringify({ base: "main", head: "loud", title: "Loud" }),
    });
    expect(made.number).toBe(1);
    // The base takes a different edit of the same line.
    await gitOk(["checkout", "main"]);
    await write("alpha\nbeta!\ngamma\n", "quiet beta");
    await gitOk(["push", "origin", "main"]);
    const one = await api("/pulls/1");
    expect(one.mergeable).toBe(false);
    expect(one.conflicts).toEqual(["code.txt"]);
    const listed = await api("/pulls");
    expect(listed.items[0].mergeable).toBe(false);
    expect(listed.items[0].conflicts).toEqual(["code.txt"]);
    const seen = await mcp("pull", { repo: "dev/app", number: 1 });
    expect(seen.mergeable).toBe(false);
    expect(seen.conflicts).toEqual(["code.txt"]);
    // The base moves to hold the same line the pull wants.
    await write("alpha\nBETA\ngamma\n", "the same edit");
    await gitOk(["push", "origin", "main"]);
    const after = await api("/pulls/1");
    expect(after.mergeable).toBe(true);
    expect(after.conflicts).toEqual([]);
    expect((await api("/pulls")).items[0].mergeable).toBe(true);
    const mcpAfter = await mcp("pull", { repo: "dev/app", number: 1 });
    expect(mcpAfter.mergeable).toBe(true);
    expect(mcpAfter.conflicts).toEqual([]);
  });
  test("a sealed pull answers no_such_pull to a reader who cannot see it", async () => {
    const sealed = await mcp("seal", { repo: "dev/app", number: 1, sealed: true });
    expect(sealed.sealed).toBe(true);
    await fetch(`${base}/signup`, {
      method: "POST",
      body: new URLSearchParams({
        username: "eve",
        email: "[email protected]",
        password: "eve-reader-pass-1",
      }),
      redirect: "manual",
    });
    const eve = await fetch(`${base}/api/v1/tokens`, {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({
        adminConfirm: true,
        username: "eve",
        password: "eve-reader-pass-1",
        name: "cli",
        scope: "rw",
      }),
    })
      .then((r) => r.json())
      .then((j) => (j as { token: string }).token);
    const hidden = await mcp("pull", { repo: "dev/app", number: 1 }, eve);
    expect(hidden.error).toContain("no_such_pull");
    expect((await mcp("pull", { repo: "dev/app", number: 1 })).number).toBe(1);
    await mcp("seal", { repo: "dev/app", number: 1, sealed: false });
  });
  test("a closed pull leaves out mergeable and conflicts everywhere", async () => {
    const closed = await api("/pulls/1", {
      method: "PATCH",
      body: JSON.stringify({ state: "closed" }),
    });
    expect(closed.state).toBe("closed");
    const one = await api("/pulls/1");
    expect(one.state).toBe("closed");
    expect("mergeable" in one).toBe(false);
    expect("conflicts" in one).toBe(false);
    const listed = await api("/pulls?state=all");
    expect(listed.items[0].state).toBe("closed");
    expect("mergeable" in listed.items[0]).toBe(false);
    expect("conflicts" in listed.items[0]).toBe(false);
    const seen = await mcp("pull", { repo: "dev/app", number: 1 });
    expect(seen.state).toBe("closed");
    expect("mergeable" in seen).toBe(false);
    expect("conflicts" in seen).toBe(false);
  });
});
		@@ -30,6 +30,7 @@ for a tunnel and a forge that sleeps.
30	30	\| `apps` \| the apps you can see: live or not, where served, how each runs itself, what is working \| \|
31	31	\| `tell` \| a sentence becomes an issue, a builder is picked, a run starts on the crew's next tick \| yes \|
32	32	\| `say` \| speak on an issue or a pull; a working builder hears it as its next step \| yes \|
	33	\| `pull` \| `{ repo, number }`: a pull's title, state, head and base, and for an open pull whether it merges into the base's current head (`mergeable`) and the paths that stop it (`conflicts`); the same fields as `GET …/pulls/:number` \| \|
33	34	\| `edit` \| a new title or body for an issue or a pull: its author's, or a writer's; an agent edits only what it wrote \| yes \|
34	35	\| `seal` \| `{ repo, number, sealed }`: seal a security report (and the pull that fixes it) so only writers and the crew see it, or unseal it for every reader; a writer's, recorded \| yes \|
35	36	\| `now` \| what the crew is doing right now: who, on what, since when, at what cost; a planner that declined the direction and waits for you comes first (`run: null`, its words in `says`) \| \|
		@@ -574,6 +574,9 @@ whole review with `bad_anchor`, and the message says how an anchor is written.
574	574	This is the one way the crew's reviewer brief posts a review.
575	575	`GET …/pulls/:number` gains `status.reviews:
576	576	{ approved, changesRequested, required, mergeable }`.
	577	`GET …/pulls` and `GET …/pulls/:number` carry `mergeable` (does the head merge
	578	into the base's current head) and `conflicts` (the paths that stop it) on open
	579	pulls only; a merged or closed pull leaves both out.
577	580
578	581	Repo JSON gains `origin: { originId, kind, fullName, htmlUrl, host, lastFetchAt,
579	582	fetchError, detached, frozenSince, detachedAt } \| null` — a detached mirror
		@@ -92,6 +92,7 @@ export const GATE: readonly string[] = [
92	92	"test/fork-flow.test.ts",
93	93	"test/fork-pull-approval.test.ts",
94	94	"test/cross-repo-pull.test.ts",
	95	"test/pull-mergeable.test.ts",
95	96	"test/pulls.test.ts",
96	97	"test/api-reader-marks.test.ts",
97	98	"test/app-members.test.ts",
		@@ -12,6 +12,7 @@ import { sealedByNumber } from "./sealed.ts";
12	12	import type { Database } from "bun:sqlite";
13	13	import { diffRange, type Diff } from "../git/diff.ts";
14	14	import { isSafeRef } from "../git/guard.ts";
	15	import { listRefs } from "../git/read.ts";
15	16	import {
16	17	aheadCount,
17	18	fetchInto,
		@@ -627,29 +628,112 @@ export async function pullStatus(
627	628	: `refs/heads/${pull.headBranch}`;
628	629	const headOid = (await resolveOid(dir, headRef)) ?? pull.headOid;
629	630	const reviews = gate === undefined ? null : reviewGate(gate, pull, headOid);
	631	const { ahead, mergeable: clean, conflicts } = await mergeReading(
	632	dir,
	633	baseOid,
	634	headOid,
	635	);
	636	return { baseOid, headOid, ahead, mergeable: clean, conflicts, reviews };
	637	}
	638
	639	interface MergeReading {
	640	readonly ahead: number;
	641	readonly mergeable: boolean;
	642	readonly conflicts: string[];
	643	}
	644
	645	/** Readings by `head:base` oid: a merge-tree over two commits never changes. */
	646	const readings = new Map<string, MergeReading>();
	647	const READINGS_MAX = 500;
	648
	649	async function mergeReading(
	650	dir: string,
	651	baseOid: string,
	652	headOid: string,
	653	): Promise<MergeReading> {
	654	const key = `${headOid}:${baseOid}`;
	655	const known = readings.get(key);
	656	if (known !== undefined) return { ...known, conflicts: [...known.conflicts] };
630	657	const ahead = await aheadCount(dir, baseOid, headOid);
631		if (ahead === 0) {
632		return {
633		baseOid,
634		headOid,
635		ahead,
636		mergeable: false,
637		conflicts: [],
638		reviews,
639		};
	658	let reading: MergeReading;
	659	if (ahead === 0) reading = { ahead, mergeable: false, conflicts: [] };
	660	else {
	661	const check = await mergeable(dir, baseOid, headOid);
	662	reading = check.ok
	663	? { ahead, mergeable: true, conflicts: [] }
	664	: {
	665	ahead,
	666	mergeable: false,
	667	conflicts: check.error.kind === "conflict" ? check.error.files : [],
	668	};
	669	// A git failure is not a verdict about the commits: do not remember it.
	670	if (!check.ok && check.error.kind !== "conflict") return reading;
640	671	}
641		const check = await mergeable(dir, baseOid, headOid);
642		if (check.ok)
643		return {
644		baseOid,
645		headOid,
646		ahead,
647		mergeable: true,
648		conflicts: [],
649		reviews,
650		};
651		const conflicts = check.error.kind === "conflict" ? check.error.files : [];
652		return { baseOid, headOid, ahead, mergeable: false, conflicts, reviews };
	672	if (readings.size >= READINGS_MAX)
	673	readings.delete(readings.keys().next().value!);
	674	readings.set(key, reading);
	675	return { ...reading, conflicts: [...reading.conflicts] };
	676	}
	677
	678	/**
	679	* Whether an open pull merges into its base's current head, and the paths
	680	* that stop it — what the API and the MCP say on every reading of a pull.
	681	* Null for a pull that is no longer open: there is nothing left to merge.
	682	*/
	683	export async function pullMergeState(
	684	dir: string,
	685	pull: Pull,
	686	): Promise<{ mergeable: boolean; conflicts: string[] } \| null> {
	687	if (pull.state !== "open" \|\| pull.mergedAt !== null) return null;
	688	const { mergeable: clean, conflicts } = await pullStatus(dir, pull);
	689	return { mergeable: clean, conflicts };
	690	}
	691
	692	/** How many merge readings a list runs at once: a page is never a fork bomb. */
	693	const READ_AT_ONCE = 4;
	694
	695	/**
	696	* `pullMergeState` for a page of pulls: one `for-each-ref` per repository
	697	* directory instead of two `rev-parse` per pull, and at most `READ_AT_ONCE`
	698	* readings in flight. Same answers, same order as the input.
	699	*/
	700	export async function pullMergeStates(
	701	items: readonly { dir: string; pull: Pull }[],
	702	): Promise<({ mergeable: boolean; conflicts: string[] } \| null)[]> {
	703	const tips = new Map<string, Promise<Map<string, string>>>();
	704	const tipsOf = (dir: string): Promise<Map<string, string>> => {
	705	let known = tips.get(dir);
	706	if (known === undefined) {
	707	known = listRefs(dir).then((refs) => {
	708	const out = new Map<string, string>();
	709	if (refs.ok) for (const r of refs.value) out.set(r.name, r.oid);
	710	return out;
	711	});
	712	tips.set(dir, known);
	713	}
	714	return known;
	715	};
	716	const out: ({ mergeable: boolean; conflicts: string[] } \| null)[] =
	717	new Array(items.length).fill(null);
	718	let next = 0;
	719	const worker = async (): Promise<void> => {
	720	for (let i = next++; i < items.length; i = next++) {
	721	const { dir, pull } = items[i]!;
	722	if (pull.state !== "open" \|\| pull.mergedAt !== null) continue;
	723	const live = await tipsOf(dir);
	724	const baseOid = live.get(`refs/heads/${pull.baseBranch}`) ?? pull.baseOid;
	725	const headRef = pull.crossRepo
	726	? `refs/pull/${pull.number}/head`
	727	: `refs/heads/${pull.headBranch}`;
	728	const headOid = live.get(headRef) ?? pull.headOid;
	729	const r = await mergeReading(dir, baseOid, headOid);
	730	out[i] = { mergeable: r.mergeable, conflicts: r.conflicts };
	731	}
	732	};
	733	await Promise.all(
	734	Array.from({ length: Math.min(READ_AT_ONCE, items.length) }, worker),
	735	);
	736	return out;
653	737	}
654	738
655	739	/**
		@@ -160,6 +160,7 @@ import {
160	160	listPulls,
161	161	pullDiff,
162	162	pullDir,
	163	pullMergeStates,
163	164	type Pull,
164	165	} from "../core/pulls.ts";
165	166	import {
		@@ -2705,17 +2706,23 @@ export function apiRoutes(router: Router<Handler>): void {
2705	2706
2706	2707	// ── pull requests — so automation drives the review/merge loop ───────
2707	2708
2708		router.add("GET", "/api/v1/repos/:owner/:name/pulls", (ctx) => {
	2709	router.add("GET", "/api/v1/repos/:owner/:name/pulls", async (ctx) => {
2709	2710	const repo = loadRepo(ctx);
2710	2711	if (!repo) return notFound();
2711	2712	const query = listQuery(ctx);
2712		const items = withLabelsMany(
2713		ctx,
2714		listPulls(ctx.app.db, repo.id, {
2715		...query,
2716		...sealedScope(ctx.app.db, repo, ctx.auth.user),
2717		}),
	2713	const pulls = listPulls(ctx.app.db, repo.id, {
	2714	...query,
	2715	...sealedScope(ctx.app.db, repo, ctx.auth.user),
	2716	});
	2717	const states = await pullMergeStates(
		sentinelcrew 1mo ago outdated Medium: the cache only stores the merge-tree result. Each open pull still spawns two `git rev-parse` in `pullStatus`, all at once and on every request, and anonymous readers of a public repo can trigger it. Resolve refs once per request (one for-each-ref, or the stored oids) and cap how many run at once.
	2718	await Promise.all(
	2719	pulls.map(async (p) => ({ dir: await pullDirOf(ctx, repo, p), pull: p })),
		sentinelcrew 1mo ago Low: this calls `pullDirOf` for every pull on the page, including closed and merged ones whose state is then dropped. For a sealed cross-repo pull, `pullDir` runs `followBase`, which is a git fetch. That makes a plain GET do unbounded fetches, outside the `READ_AT_ONCE` cap. Filter first: resolve a dir only for `p.state === "open" && p.mergedAt === null`, or let `pullMergeStates` resolve dirs inside its capped workers.
	2720	),
2718	2721	);
	2722	const items = withLabelsMany(ctx, pulls).map((item, i) => ({
	2723	...item,
	2724	...(states[i] ?? {}),
	2725	}));
2719	2726	return json(paged(items, query.limit, (p) => p.number));
2720	2727	});
2721	2728
		@@ -2777,6 +2784,9 @@ export function apiRoutes(router: Router<Handler>): void {
2777	2784	const hold = getHold(ctx.app.db, found.pull.id);
2778	2785	return json({
2779	2786	...withLabels(ctx, found.pull),
	2787	...(found.pull.state === "open" && found.pull.mergedAt === null
		sentinelcrew 1mo ago outdated Low: `status` from `pullDiff` above already carries `mergeable` and `conflicts`. Reuse it here (when the pull is open) instead of running `pullStatus` again. sentinelcrew 1mo ago Leaving the fields out for closed and merged pulls is a behaviour this change adds, and no test covers it. Close the pull in `test/pull-mergeable.test.ts`, then assert that the detail route, the list (`?state=all`) and the MCP tool all omit `mergeable` and `conflicts`.
	2788	? { mergeable: status.mergeable, conflicts: status.conflicts }
	2789	: {}),
2780	2790	status,
2781	2791	diff,
2782	2792	hold: hold === undefined ? null : holdJson(hold),
		@@ -59,7 +59,7 @@ import { getIssue, getIssueById, listOpenAgentPullsVisibleTo } from "../core/iss
59	59	import { waitsForPerson } from "../crew/review.ts";
60	60	import { attachLook } from "../actions/attach_look.ts";
61	61	import { lookUrl } from "../core/looks.ts";
62		import { getPull } from "../core/pulls.ts";
	62	import { getPull, pullDir, pullMergeState } from "../core/pulls.ts";
63	63	import { repoGraph } from "../core/dependencies.ts";
64	64	import { pillarView } from "../core/pillars.ts";
65	65	import { getAppByRepo } from "../core/apps.ts";
		@@ -371,6 +371,43 @@ const TOOLS: readonly Tool[] = [
371	371	: bad("refused", "that could not be said here");
372	372	},
373	373	},
	374	{
	375	name: "pull",
		sentinelcrew 1mo ago This is a new tool, but `docs/MCP.md` has no `pull` row in its tool table. Add one so it is reachable by documentation as well as by `tools/list`.
	376	description:
	377	"Read a pull: its title, state and head and base, and for an open pull whether it merges into the base's current head (`mergeable`) and the paths that stop it (`conflicts`). The same two fields as GET /api/v1/repos/:owner/:name/pulls/:number.",
	378	inputSchema: {
	379	type: "object",
	380	properties: {
	381	repo: REPO_ARG,
	382	number: { type: "integer", minimum: 1 },
	383	},
	384	required: ["repo", "number"],
	385	},
	386	writes: false,
	387	async run(ctx, user, args) {
	388	const repo = repoArg(ctx, user, args);
	389	if (isAnswer(repo)) return repo;
	390	const n = args["number"];
	391	const pull =
	392	typeof n === "number" && Number.isInteger(n) && n > 0
	393	? getPull(ctx.app.db, repo.id, n)
	394	: undefined;
	395	if (pull === undefined \|\| !mayView(ctx.app.db, repo, pull, user))
	396	return bad("no_such_pull", `no pull #${String(n)}`);
		sentinelcrew 1mo ago The `mayView` gate is correct here. Add a test that would fail without it: a sealed pull, or a pull in a private repository, read by someone who cannot see it, must answer `no_such_pull`.
	397	const state = await pullMergeState(
	398	await pullDir(ctx.app.db, ctx.app.reposRoot, repo, pull),
	399	pull,
	400	);
	401	return good({
	402	number: pull.number,
	403	title: pull.title,
	404	state: pull.mergedAt !== null ? "merged" : pull.state,
	405	base: pull.baseBranch,
	406	head: pull.headBranch,
	407	...(state ?? {}),
	408	});
	409	},
	410	},
374	411	{
375	412	name: "edit",
376	413	description:
		@@ -159,6 +159,7 @@ describe("the forge over MCP", () => {
159	159	"tell",
160	160	"share",
161	161	"say",
	162	"pull",
162	163	"edit",
163	164	"asks",
164	165	"asks_act",
		@@ -0,0 +1,207 @@
	1	import { afterAll, beforeAll, describe, expect, test } from "bun:test";
	2	import { mkdtemp, rm } from "node:fs/promises";
	3	import { tmpdir } from "node:os";
	4	import { join } from "node:path";
	5	import { createApp, type App } from "../src/app.ts";
	6	import { serve, type Servers } from "../src/http/server.ts";
	7	import { gitClientEnv } from "./helpers/git-client.ts";
	8
	9	const gitEnv = gitClientEnv();
	10
	11	describe("a pull says whether it merges", () => {
	12	let dataDir: string;
	13	let work: string;
	14	let app: App;
	15	let servers: Servers;
	16	let base: string;
	17	let token = "";
	18	let dir: string;
	19
	20	async function gitOk(args: string[]): Promise<void> {
	21	const p = Bun.spawn(["git", ...args], {
	22	cwd: dir,
	23	env: gitEnv,
	24	stdout: "ignore",
	25	stderr: "pipe",
	26	});
	27	const [err, code] = await Promise.all([
	28	new Response(p.stderr).text(),
	29	p.exited,
	30	]);
	31	if (code !== 0) throw new Error(`git ${args.join(" ")}: ${err}`);
	32	}
	33	const auth = { authorization: "" };
	34	const api = async (path: string, init: RequestInit = {}) =>
	35	(await fetch(`${base}/api/v1/repos/dev/app${path}`, {
	36	...init,
	37	headers: { ...auth, "content-type": "application/json" },
	38	})).json() as Promise<any>;
	39	const mcp = async (name: string, args: unknown, as?: string) => {
	40	const res = await fetch(`${base}/mcp`, {
	41	method: "POST",
	42	headers: {
	43	"content-type": "application/json",
	44	accept: "application/json, text/event-stream",
	45	...auth,
	46	...(as ? { authorization: `Bearer ${as}` } : {}),
	47	},
	48	body: JSON.stringify({
	49	jsonrpc: "2.0",
	50	id: 1,
	51	method: "tools/call",
	52	params: { name, arguments: args },
	53	}),
	54	});
	55	const body = (await res.json()) as any;
	56	const text = body.result.content[0].text as string;
	57	try {
	58	return JSON.parse(text);
	59	} catch {
	60	return { error: text };
	61	}
	62	};
	63	const write = async (text: string, message: string) => {
	64	await Bun.write(join(dir, "code.txt"), text);
	65	await gitOk(["commit", "-am", message]);
	66	};
	67
	68	beforeAll(async () => {
	69	dataDir = await mkdtemp(join(tmpdir(), "forge-pm-"));
	70	work = await mkdtemp(join(tmpdir(), "forge-pm-work-"));
	71	app = createApp({ dataDir, port: 0 });
	72	servers = await serve(app);
	73	base = servers.url;
	74	await fetch(`${base}/signup`, {
	75	method: "POST",
	76	body: new URLSearchParams({
	77	username: "dev",
	78	email: "[email protected]",
	79	password: "pull-mergeable-pass",
	80	}),
	81	redirect: "manual",
	82	});
	83	token = await fetch(`${base}/api/v1/tokens`, {
	84	method: "POST",
	85	headers: { "content-type": "application/json" },
	86	body: JSON.stringify({
	87	adminConfirm: true,
	88	username: "dev",
	89	password: "pull-mergeable-pass",
	90	name: "cli",
	91	scope: "rw",
	92	}),
	93	})
	94	.then((r) => r.json())
	95	.then((j) => (j as { token: string }).token);
	96	auth.authorization = `Bearer ${token}`;
	97	await fetch(`${base}/api/v1/repos`, {
	98	method: "POST",
	99	headers: { ...auth, "content-type": "application/json" },
	100	body: JSON.stringify({ name: "app", visibility: "public" }),
	101	});
	102	const remote = `${base.replace("http://", `http://dev:${token}@`)}/dev/app.git`;
	103	dir = work;
	104	await gitOk(["clone", remote, "app"]);
	105	dir = join(work, "app");
	106	await Bun.write(join(dir, "code.txt"), "alpha\nbeta\ngamma\n");
	107	await gitOk(["add", "."]);
	108	await gitOk(["commit", "-m", "base"]);
	109	await gitOk(["push", "origin", "main"]);
	110	});
	111
	112	afterAll(async () => {
	113	servers.stop();
	114	app.close();
	115	await rm(dataDir, { recursive: true, force: true });
	116	await rm(work, { recursive: true, force: true });
	117	});
	118
	119	test("a conflicting pull reads false with the path; once the base resolves it, true", async () => {
	120	await gitOk(["checkout", "-b", "loud"]);
	121	await write("alpha\nBETA\ngamma\n", "loud beta");
	122	await gitOk(["push", "origin", "loud"]);
	123	const made = await api("/pulls", {
	124	method: "POST",
	125	body: JSON.stringify({ base: "main", head: "loud", title: "Loud" }),
	126	});
	127	expect(made.number).toBe(1);
	128
	129	// The base takes a different edit of the same line.
	130	await gitOk(["checkout", "main"]);
	131	await write("alpha\nbeta!\ngamma\n", "quiet beta");
	132	await gitOk(["push", "origin", "main"]);
	133
	134	const one = await api("/pulls/1");
	135	expect(one.mergeable).toBe(false);
	136	expect(one.conflicts).toEqual(["code.txt"]);
	137	const listed = await api("/pulls");
	138	expect(listed.items[0].mergeable).toBe(false);
	139	expect(listed.items[0].conflicts).toEqual(["code.txt"]);
	140	const seen = await mcp("pull", { repo: "dev/app", number: 1 });
	141	expect(seen.mergeable).toBe(false);
	142	expect(seen.conflicts).toEqual(["code.txt"]);
	143
	144	// The base moves to hold the same line the pull wants.
	145	await write("alpha\nBETA\ngamma\n", "the same edit");
	146	await gitOk(["push", "origin", "main"]);
	147
	148	const after = await api("/pulls/1");
	149	expect(after.mergeable).toBe(true);
	150	expect(after.conflicts).toEqual([]);
	151	expect((await api("/pulls")).items[0].mergeable).toBe(true);
	152	const mcpAfter = await mcp("pull", { repo: "dev/app", number: 1 });
	153	expect(mcpAfter.mergeable).toBe(true);
	154	expect(mcpAfter.conflicts).toEqual([]);
	155	});
	156
	157	test("a sealed pull answers no_such_pull to a reader who cannot see it", async () => {
	158	const sealed = await mcp("seal", { repo: "dev/app", number: 1, sealed: true });
	159	expect(sealed.sealed).toBe(true);
	160	await fetch(`${base}/signup`, {
	161	method: "POST",
	162	body: new URLSearchParams({
	163	username: "eve",
	164	email: "[email protected]",
	165	password: "eve-reader-pass-1",
	166	}),
	167	redirect: "manual",
	168	});
	169	const eve = await fetch(`${base}/api/v1/tokens`, {
	170	method: "POST",
	171	headers: { "content-type": "application/json" },
	172	body: JSON.stringify({
	173	adminConfirm: true,
	174	username: "eve",
	175	password: "eve-reader-pass-1",
	176	name: "cli",
	177	scope: "rw",
	178	}),
	179	})
	180	.then((r) => r.json())
	181	.then((j) => (j as { token: string }).token);
	182	const hidden = await mcp("pull", { repo: "dev/app", number: 1 }, eve);
	183	expect(hidden.error).toContain("no_such_pull");
	184	expect((await mcp("pull", { repo: "dev/app", number: 1 })).number).toBe(1);
	185	await mcp("seal", { repo: "dev/app", number: 1, sealed: false });
	186	});
	187
	188	test("a closed pull leaves out mergeable and conflicts everywhere", async () => {
	189	const closed = await api("/pulls/1", {
	190	method: "PATCH",
	191	body: JSON.stringify({ state: "closed" }),
	192	});
	193	expect(closed.state).toBe("closed");
	194	const one = await api("/pulls/1");
	195	expect(one.state).toBe("closed");
	196	expect("mergeable" in one).toBe(false);
	197	expect("conflicts" in one).toBe(false);
	198	const listed = await api("/pulls?state=all");
	199	expect(listed.items[0].state).toBe("closed");
	200	expect("mergeable" in listed.items[0]).toBe(false);
	201	expect("conflicts" in listed.items[0]).toBe(false);
	202	const seen = await mcp("pull", { repo: "dev/app", number: 1 });
	203	expect(seen.state).toBe("closed");
	204	expect("mergeable" in seen).toBe(false);
	205	expect("conflicts" in seen).toBe(false);
	206	});
	207	});