graftfork 0.1.0 → 0.2.0

package/README.md

@@ -15,6 +15,9 @@ graft connect you/project         # connect a repository Graft's GitHub app is i
 graft sync                        # start a sync now (inside the clone, or pass the copy)
 graft why                         # why the copy stayed, and what to do next
 graft pull                        # fetch the latest move as graft/<release>; your branch is untouched
+graft upstream "fix the parser"   # Graft builds that one change alone on your release and runs your tests;
+                                  # this fetches graft/upstream/<change>. Nothing is pushed: you open the PR
+graft upstream-pr <build> <url>   # the pull request you opened; Graft tells you when it's merged
 ```
 
 Also `graft whoami`, `graft status` and `graft usage`; `--json` prints the API's answers as they are. API docs:

package/graft.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/client/cli.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawnSync as spawnSync3 } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { parseArgs } from "node:util";
 
@@ -53,7 +53,7 @@ async function pull(o) {
       rmSync(dir, { recursive: true, force: true });
     }
     const sha = git(o.cwd, ["rev-parse", "--short", t.branch]).stdout.trim();
-    return { ok: true, branch: t.branch, message: `Fetched ${t.branch} (${sha}): your changes on ${t.release}. Your branch is untouched.
+    return { ok: true, branch: t.branch, message: `Fetched ${t.branch} (${sha}): ${t.release ? `your changes on ${t.release}` : "the branch Graft delivered"}. Your branch is untouched.
 Switch with: git switch ${t.branch}
 Or take it into ${t.copy.branch}: git checkout ${t.copy.branch} && git merge --ff-only ${t.branch}` };
   } catch (e) {
@@ -61,6 +61,69 @@ Or take it into ${t.copy.branch}: git checkout ${t.copy.branch} && git merge --f
   }
 }
 
+// src/client/upstream.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join2 } from "node:path";
+var git2 = (cwd, args) => spawnSync2("git", args, { cwd, encoding: "utf8" });
+async function upstream(o) {
+  const started = await o.call("POST", `/api/v1/copies/${o.copyId}/upstream`, { change: o.change });
+  let u = started.upstream;
+  if (o.noWait) return { ok: true, message: `${started.message ?? "Building."}
+Build: ${u.id}. Check it with graft upstream-status ${u.id}.` };
+  const until = Date.now() + (o.waitMs ?? 30 * 6e4);
+  while (u.status === "queued" || u.status === "running") {
+    if (Date.now() > until) return { ok: false, message: `Still building after ${Math.round((o.waitMs ?? 30 * 6e4) / 6e4)} minutes. Check it later with graft upstream-status ${u.id}.` };
+    await new Promise((r) => setTimeout(r, o.pollMs ?? 1e4));
+    u = (await o.call("GET", `/api/v1/upstreams/${u.id}`)).upstream;
+  }
+  if (u.status !== "built") return { ok: false, message: `Not built: ${u.note ?? "the build failed"}` };
+  return take(o, u);
+}
+async function take(o, u) {
+  if (!u.downloads?.bundle) return { ok: false, message: `Built ${u.branch}, but Graft doesn't keep it any more. Build it again with graft upstream.` };
+  if (git2(o.cwd, ["rev-parse", "--git-dir"]).status !== 0) return { ok: false, message: `Built ${u.branch}. Run this inside your clone of the copy to fetch it, or download it: ${u.downloads.bundle}` };
+  const r = await o.fetchImpl(u.downloads.bundle);
+  if (!r.ok) return { ok: false, message: `Downloading the branch failed (${r.status}). Try again; graft upstream-status makes a fresh link.` };
+  const dir = mkdtempSync2(join2(tmpdir2(), "graft-upstream-"));
+  const file = join2(dir, "upstream.bundle");
+  try {
+    writeFileSync2(file, new Uint8Array(await r.arrayBuffer()));
+    const v = git2(o.cwd, ["bundle", "verify", "-q", file]);
+    if (v.status !== 0) return { ok: false, message: `This clone is missing what the branch builds on (${v.stderr.trim().split("\n").pop()}). Bring your copy's branch up to date, then run it again.` };
+    const f = git2(o.cwd, ["fetch", "-q", file, `+refs/heads/${u.branch}:refs/heads/${u.branch}`]);
+    if (f.status !== 0) return { ok: false, message: `git fetch failed: ${f.stderr.trim().split("\n").pop()}` };
+  } finally {
+    rmSync2(dir, { recursive: true, force: true });
+  }
+  let saved = "";
+  if (o.patchDir && u.downloads.patch) {
+    const p = await o.fetchImpl(u.downloads.patch);
+    if (p.ok) {
+      const path = join2(o.patchDir, `${String(u.branch).split("/").pop()}.patch`);
+      writeFileSync2(path, await p.text());
+      saved = `
+The patch, for projects that take them by email: ${path}`;
+    }
+  }
+  const t = u.tests ?? {};
+  const pr = u.pullRequest ?? {};
+  return {
+    ok: true,
+    branch: u.branch,
+    message: [
+      `Fetched ${u.branch}: only "${u.change?.subject}" on ${u.release}${t.ran ? `; your tests: ${t.verdict ?? "ran"}` : "; no tests ran"}.${saved}`,
+      "Nothing was pushed. To send it, from your account:",
+      ...(u.commands ?? []).slice(2).map((c) => `  ${c}`),
+      `Pull request title: ${pr.title}`,
+      "Pull request text:",
+      ...String(pr.body ?? "").split("\n").map((l) => `  ${l}`),
+      `Then: graft upstream-pr ${u.id} <the pull request's URL>, and Graft tells you when it's merged.`
+    ].join("\n")
+  };
+}
+
 // src/client/cli.ts
 var USAGE = `graft: the command line for graftfork.com (a thin client; syncs run on graftfork.com)
 
@@ -72,8 +135,25 @@ var USAGE = `graft: the command line for graftfork.com (a thin client; syncs run
   graft status [copy]          a copy and its latest runs
   graft why [copy]             why the copy stayed, and what to do next
   graft pull [copy]            fetch the latest move as graft/<release> in your clone
+  graft upgrade <dependency> [version] [--copy <copy>]
+                               upgrade a dependency (npm or Python), delivered only if the tests pass
+  graft upgrades [id]          your upgrades, or one with what its tests said
+  graft upstream <change> [copy]   build one change alone on your release, tested; fetch graft/upstream/<change>
+               [--patch <dir>] [--no-wait]   (nothing is pushed: you open the pull request yourself)
+  graft upstream-status <build>    an upstream build's status, tests and links
+  graft upstream-pr <build> <url>  the pull request you opened upstream; Graft checks it until it's merged
   graft usage                  this month's syncs and agent work
-  graft verify-record <file>   check a run's signed record (from /app or GET /api/v1/runs/{id}/record)
+  graft verify-record <file>   check a run's signed record (from /app or GET /api/v1/runs/{id}/record),
+                               or an organization's agent change record
+  graft agent-record <org>     an organization's signed agent change record, as JSON
+               [--from <YYYY-MM-DD> --to <YYYY-MM-DD>]   (save it: graft agent-record <org> > record.json)
+  graft check <base> <head>    check a change against the project's own tests (no push, no agent)
+               [--pr <n>] [--repo <owner/name> | --clone-url <url>] [--wait]
+  graft checks [id]            your recent change checks, or one check's result
+  graft regen connect <owner/name or URL> --branch <b> --record <path> --impl <dir> --lang ts|py [--builds 1-3] [--on-push]
+                               connect a spec (a duramen record): Graft rebuilds its implementation blind
+  graft regen run <spec>       rebuild it now
+  graft regen status [id]      your specs, a spec's rebuilds, or one rebuild and how to take it
 
 [copy] is a copy id or owner/name; left out, it's this clone's origin remote.
 Token: GRAFT_TOKEN or --token (make one at https://graftfork.com/app#settings). --json prints raw answers.`;
@@ -84,9 +164,9 @@ async function run(argv, io) {
     args: argv,
     allowPositionals: true,
     strict: false,
-    options: { token: { type: "string" }, api: { type: "string" }, json: { type: "boolean" }, branch: { type: "string" }, upstream: { type: "string" }, base: { type: "string" }, tags: { type: "string" }, help: { type: "boolean", short: "h" } }
+    options: { token: { type: "string" }, api: { type: "string" }, json: { type: "boolean" }, patch: { type: "string" }, "no-wait": { type: "boolean" }, branch: { type: "string" }, upstream: { type: "string" }, base: { type: "string" }, tags: { type: "string" }, from: { type: "string" }, to: { type: "string" }, repo: { type: "string" }, "clone-url": { type: "string" }, pr: { type: "string" }, wait: { type: "boolean" }, copy: { type: "string" }, record: { type: "string" }, impl: { type: "string" }, lang: { type: "string" }, builds: { type: "string" }, "on-push": { type: "boolean" }, help: { type: "boolean", short: "h" } }
   });
-  const [cmd, arg] = positionals;
+  const [cmd, arg, arg2] = positionals;
   if (!cmd || a.help || cmd === "help") {
     io.out(USAGE);
     return cmd || a.help ? 0 : 1;
@@ -107,7 +187,7 @@ async function run(argv, io) {
   const show = (b, text) => io.out(a.json ? JSON.stringify(b, null, 1) : text);
   const copyId = async (given) => {
     if (given && !given.includes("/") && /^[A-Za-z0-9_-]{8,64}$/.test(given)) return given;
-    const repo = given ?? repoOfRemote(spawnSync2("git", ["remote", "get-url", "origin"], { cwd: io.cwd, encoding: "utf8" }).stdout ?? "");
+    const repo = given ?? repoOfRemote(spawnSync3("git", ["remote", "get-url", "origin"], { cwd: io.cwd, encoding: "utf8" }).stdout ?? "");
     if (!repo) throw new ApiError("Couldn't tell which copy: give its id or owner/name, or run this inside its clone.");
     const { copies } = await call("GET", "/api/v1/copies");
     const c = copies.find((x) => String(x.repo).toLowerCase() === repo.toLowerCase());
@@ -147,6 +227,73 @@ Run: ${b.run}`);
       const r = await pull({ cwd: io.cwd, copy: arg, token, api, fetchImpl: io.fetch });
       io.out(r.message);
       return r.ok ? 0 : 1;
+    } else if (cmd === "agent-record") {
+      if (!arg) {
+        io.out("graft agent-record <organization id> [--from <YYYY-MM-DD> --to <YYYY-MM-DD>]");
+        return 1;
+      }
+      const q = new URLSearchParams({ ...a.from && { from: String(a.from) }, ...a.to && { to: String(a.to) } }).toString();
+      const b = await call("GET", `/api/v1/orgs/${encodeURIComponent(arg)}/agent-record${q ? `?${q}` : ""}`);
+      io.out(JSON.stringify(b, null, 1));
+    } else if (cmd === "check") {
+      return await check(positionals[1], positionals[2]);
+    } else if (cmd === "checks") {
+      if (arg) {
+        const b = await call("GET", `/api/v1/checks/${encodeURIComponent(arg)}`);
+        show(b, checkText(b.check));
+      } else {
+        const b = await call("GET", "/api/v1/checks");
+        const rows = b.checks.map((c) => `${c.id}  ${c.repo} ${c.head} vs ${c.base}${c.pr ? ` (#${c.pr})` : ""}  ${c.outcome ?? c.status}`);
+        show(b, [...rows.length ? rows : ["No change checks yet. Start one with: graft check <base> <head>"], ...b.usage ? [`${b.usage.used} of ${b.usage.limit} checks this month.`] : []].join("\n"));
+      }
+    } else if (cmd === "upgrade") {
+      if (!arg) {
+        io.out("graft upgrade <dependency> [version] [--copy <copy id or owner/name>]");
+        return 1;
+      }
+      const b = await call("POST", "/api/v1/upgrades", { copy_id: await copyId(a.copy), dependency: arg, ...positionals[2] && { version: positionals[2] } });
+      show(b, `${b.message}
+Upgrade: ${b.upgrade}  (graft upgrades ${b.upgrade})`);
+    } else if (cmd === "upgrades") {
+      if (arg) {
+        const { upgrade: u } = await call("GET", `/api/v1/upgrades/${encodeURIComponent(arg)}`);
+        const lines = [`${u.dependency} ${u.from ?? ""} to ${u.version ?? u.requested} on ${u.repo ?? "?"}: ${u.status}`, ...u.why ? [`  ${u.why}`] : []];
+        if (u.tests?.newFailures?.length) lines.push("Broken by the upgrade:", ...u.tests.newFailures.map((f) => `  ${f}`));
+        if (u.fix) lines.push(`Graft's agent: ${u.fix.applied ? `changed ${(u.fix.files ?? []).join(", ")}` : `not used (${u.fix.why})`}`);
+        if (u.delivered) lines.push(`Delivered as ${u.delivered.branch}. Take it in your clone with: graft pull ${u.run}`);
+        if (u.prUrl) lines.push(`Pull request: ${u.prUrl}`);
+        show({ upgrade: u }, lines.join("\n"));
+      } else {
+        const b = await call("GET", "/api/v1/upgrades");
+        const rows = b.upgrades.map((u) => `${u.id}  ${u.repo ?? "?"}  ${u.dependency} to ${u.version ?? u.requested}: ${u.status}`);
+        show(b, rows.length ? rows.join("\n") : "No upgrades yet. Start one with: graft upgrade <dependency> [version]");
+      }
+    } else if (cmd === "upstream") {
+      if (!arg) {
+        io.out("graft upstream <change> [copy] [--patch <dir>] [--no-wait]: the change's subject (or part of it), or its number in the latest move");
+        return 1;
+      }
+      const r = await upstream({ cwd: io.cwd, copyId: await copyId(arg2), change: arg, call, fetchImpl: io.fetch, noWait: !!a["no-wait"], ...a.patch && { patchDir: String(a.patch) }, ...io.env.GRAFT_POLL_MS && { pollMs: Number(io.env.GRAFT_POLL_MS) } });
+      io.out(r.message);
+      return r.ok ? 0 : 1;
+    } else if (cmd === "upstream-status") {
+      if (!arg) {
+        io.out("graft upstream-status <build>");
+        return 1;
+      }
+      const b = await call("GET", `/api/v1/upstreams/${encodeURIComponent(arg)}`);
+      const u = b.upstream;
+      const pr = u.pullRequest ?? {};
+      show(b, [`${u.change?.subject} on ${u.release}: ${u.status}${u.phase ? ` (${u.phase})` : ""}${u.note ? `. ${u.note}` : ""}`, ...(u.commands ?? []).map((c) => `  ${c}`), ...pr.url ? [`Pull request: ${pr.url}${pr.state ? ` (${pr.state})` : ""}`] : []].join("\n"));
+    } else if (cmd === "upstream-pr") {
+      if (!arg || !arg2) {
+        io.out("graft upstream-pr <build> <https://github.com/owner/name/pull/123>");
+        return 1;
+      }
+      const b = await call("POST", `/api/v1/upstreams/${encodeURIComponent(arg)}/pr`, { url: arg2 });
+      show(b, b.message);
+    } else if (cmd === "regen") {
+      return await regen(arg, arg2, a, call, show, io);
     } else if (cmd === "usage") {
       const b = await call("GET", "/api/v1/usage");
       show(b, `${b.plan}: ${b.syncs?.used ?? 0} of ${b.syncs?.limit ?? "?"} syncs this month; Graft's agent $${Number(b.graftAgentUsd ?? 0).toFixed(2)}. Resets ${b.resetsOn}.`);
@@ -159,6 +306,97 @@ Run: ${b.run}`);
     io.out(e instanceof ApiError ? e.message : `graft: ${e.message}`);
     return 1;
   }
+  async function check(base, head) {
+    const pr = a.pr === void 0 ? void 0 : Number(a.pr);
+    if ((!base || !head) && pr === void 0) {
+      io.out("graft check <base> <head> [--pr <n>] [--repo <owner/name> | --clone-url <url>] [--wait]");
+      return 1;
+    }
+    let where;
+    if (a.repo) where = { repo: a.repo };
+    else if (a["clone-url"]) where = { clone_url: a["clone-url"] };
+    else {
+      const remote = (spawnSync3("git", ["remote", "get-url", "origin"], { cwd: io.cwd, encoding: "utf8" }).stdout ?? "").trim();
+      const repo = repoOfRemote(remote);
+      if (/github\.com[:/]/.test(remote) && repo) where = { repo };
+      else if (/^https:\/\//.test(remote) && !/@/.test(remote.split("/")[2] ?? "")) where = { clone_url: remote };
+      else {
+        io.out("Couldn't tell which repository: pass --repo <owner/name> or --clone-url <url>, or run this inside its clone.");
+        return 1;
+      }
+    }
+    const b = await call("POST", "/api/v1/checks", { ...where, ...base && { base }, ...head && { head }, ...pr !== void 0 && { pr } });
+    if (!a.wait) {
+      show(b, `${b.message}
+Check: ${b.check}  (graft checks ${b.check})`);
+      return 0;
+    }
+    const sleep = io.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    for (let i = 0; i < 200; i++) {
+      const c = (await call("GET", `/api/v1/checks/${encodeURIComponent(b.check)}`)).check;
+      if (!["queued", "running"].includes(c.status)) {
+        show({ check: c }, checkText(c));
+        return c.outcome === "pass" ? 0 : c.outcome === "fail" ? 1 : 2;
+      }
+      await sleep(15e3);
+    }
+    io.out(`Still running. Read it later with: graft checks ${b.check}`);
+    return 2;
+  }
+}
+function checkText(c) {
+  const word = c.outcome === "pass" ? "PASS" : c.outcome === "fail" ? "FAIL" : c.outcome === "could_not_run" ? "COULD NOT RUN" : String(c.status).toUpperCase();
+  const sha = (r) => r?.sha ? ` (${String(r.sha).slice(0, 7)})` : "";
+  return [
+    `${word}: ${c.repo} ${c.head}${sha(c.headRun)} against ${c.base}${sha(c.baseRun)}${c.pr ? `, pull request #${c.pr}` : ""}`,
+    ...c.reason ? [c.reason] : [],
+    ...(c.newFailures ?? []).length ? ["New failures:", ...c.newFailures.map((f) => `  ${f}`)] : [],
+    ...(c.alreadyFailing ?? []).length ? [`${c.alreadyFailing.length} already failing on the base (not counted against the change).`] : [],
+    ...(c.testFilesChanged ?? []).length ? [`The change edits files that shape the tests: ${c.testFilesChanged.join(", ")}. Read them before trusting the result.`] : []
+  ].join("\n");
+}
+async function regen(sub, id, a, call, show, io) {
+  const line = (r) => `${r.id}  ${r.status}${r.phase ? ` (${r.phase})` : ""}${r.suite?.total ? `  suite ${r.suite.passed}/${r.suite.total}` : ""}${r.choicesDiffer ? `  ${r.choicesDiffer} choice(s) differ` : ""}${r.why ? `: ${r.why}` : ""}`;
+  if (sub === "connect") {
+    if (!id || !a.record || !a.impl || !a.lang || !a.branch) {
+      io.out("graft regen connect <owner/name or https URL> --branch <b> --record <path> --impl <dir> --lang ts|py [--builds 1-3] [--on-push]");
+      return 1;
+    }
+    const b = await call("POST", "/api/v1/regen", { .../^https:\/\//.test(id) ? { clone_url: id } : { repo: id }, branch: a.branch, record: a.record, impl: a.impl, lang: a.lang, ...a.builds && { builds: Number(a.builds) }, ...a["on-push"] && { on_push: true } });
+    show(b, `${b.message ?? "Connected."}
+Spec id: ${b.id}`);
+  } else if (sub === "run") {
+    if (!id) {
+      io.out("graft regen run <spec id>");
+      return 1;
+    }
+    const b = await call("POST", `/api/v1/regen/${encodeURIComponent(id)}/run`);
+    show(b, `${b.message}
+Rebuild: ${b.run}`);
+  } else if (sub === "status") {
+    if (!id) {
+      const b = await call("GET", "/api/v1/regen");
+      const rows = b.specs.map((s) => `${s.id}  ${s.repo} ${s.branch}: ${s.record} -> ${s.impl} (${s.lang})${s.last ? `
+    last: ${line(s.last)}` : "\n    never rebuilt"}`);
+      show(b, rows.length ? rows.join("\n") : b.available ? "No specs yet. Connect one with: graft regen connect <owner/name> --branch main --record spec/ --impl impl --lang ts" : "Rebuilding from a spec is on Premium, Team and Enterprise.");
+      return 0;
+    }
+    const spec = await call("GET", `/api/v1/regen/${encodeURIComponent(id)}`).catch(() => null);
+    if (spec) {
+      show(spec, [`${spec.spec.repo} ${spec.spec.branch}: ${spec.spec.record} -> ${spec.spec.impl} (${spec.spec.lang})`, ...spec.runs.length ? spec.runs.map((r) => `  ${line(r)}`) : ["  No rebuilds yet."]].join("\n"));
+      return 0;
+    }
+    const { run: run2 } = await call("GET", `/api/v1/regen/runs/${encodeURIComponent(id)}`);
+    const differ = run2.choicesDiff?.previous;
+    const lines = [line(run2), ...run2.builds.map((b) => `  build ${b.n}: ${b.verdict?.why ?? b.note ?? b.status}`)];
+    if (differ) for (const [k, label] of [["changed", "chosen differently"], ["added", "new"], ["removed", "gone"]]) for (const c of differ[k]) lines.push(`  ${label}: ${c.title}`);
+    if (run2.take) lines.push("Take it, in your clone:", ...run2.take.commands.map((c) => `  ${c}`));
+    show({ run: run2 }, lines.join("\n"));
+  } else {
+    io.out("graft regen connect|run|status (graft help)");
+    return 1;
+  }
+  return 0;
 }
 var unb64 = (s) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
 async function verify(file, api, io) {
@@ -194,6 +432,10 @@ async function verify(file, api, io) {
     return 1;
   }
   const r = JSON.parse(e.payload);
+  if (r.graft_agent_record === 1) {
+    io.out(`Valid: signed by graftfork.com (key ${k.id}). Agent change record for ${r.org?.name ?? r.org?.id}, ${r.range?.from} to ${r.range?.to}: ${(r.changes ?? []).length} change(s) in ${r.counts?.runs ?? 0} run(s), ${(r.agent_actions ?? []).length} agent action(s).`);
+    return 0;
+  }
   io.out(`Valid: signed by graftfork.com (key ${k.id}). Run ${r.run}, ${r.outcome}${r.upstream?.to ? ` onto ${r.upstream.to}` : ""}, ${(r.changes ?? []).length} change(s).`);
   return 0;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graftfork",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The command line for graftfork.com: connect a copy, sync it, see why it stayed, and take each move. A thin client; syncs run on graftfork.com.",
   "license": "Apache-2.0",
   "homepage": "https://graftfork.com/docs/api",