jj-octo 0.3.0 → 0.3.1

package/dist/jj-octo.js

@@ -18112,7 +18112,7 @@ var layer14 = /* @__PURE__ */ layerMergedContext(/* @__PURE__ */ succeed6(fetch)
 // package.json
 var package_default = {
   name: "jj-octo",
-  version: "0.3.0",
+  version: "0.3.1",
   description: "A jj subcommand for working with GitHub that supports stacking",
   license: "MIT",
   repository: {
@@ -18478,6 +18478,10 @@ var PullRequests = responseOf()(ArraySchema(Struct({
   number: PullRequestNumberSchema,
   title: String4
 })));
+var ClosedPullRequests = responseOf()(ArraySchema(Struct({
+  head: Struct({ sha: String4 }),
+  merged_at: NullOr(String4)
+})));
 var StackedPullRequest = Struct({
   number: PullRequestNumberSchema,
   state: Literals(["closed", "open"])
@@ -18521,6 +18525,7 @@ var GitHubLive = (repository, connection) => {
       open: stack.pull_requests.filter(({ state }) => state === "open").map(({ number }) => number)
     }))));
     const mergeRequest = (path) => json(MergeResult)(get4(repo(path)));
+    const fromBranch = (branch, state) => repo(`/pulls?state=${state}&head=${repository.owner}:${encodeURIComponent(branch)}`);
     return {
       addToStack: (stack, pullRequests) => send(post(repo(`/stacks/${stack}/add`)).pipe(bodyOf({ pull_requests: [...pullRequests] }))).pipe(asVoid2),
       createPullRequest: ({ base, body, draft, head, title }) => json(CreatedPullRequest)(post(repo("/pulls")).pipe(bodyOf({ base, body, draft, head, title }))).pipe(map7(({ number }) => number)),
@@ -18549,7 +18554,8 @@ var GitHubLive = (repository, connection) => {
           message: `merging #${pullRequest} ended ${settled.status}: ${settled.details.message}`
         });
       }),
-      openPullRequest: (branch) => json(PullRequests)(get4(repo(`/pulls?state=open&head=${repository.owner}:${encodeURIComponent(branch)}`))).pipe(map7((found) => map(fromNullishOr(found[0]), ({ base, body, draft, number, title }) => ({
+      mergedHeads: (branch) => json(ClosedPullRequests)(get4(fromBranch(branch, "closed"))).pipe(map7((closed) => closed.filter(({ merged_at }) => merged_at !== null).map(({ head }) => head.sha))),
+      openPullRequest: (branch) => json(PullRequests)(get4(fromBranch(branch, "open"))).pipe(map7((found) => map(fromNullishOr(found[0]), ({ base, body, draft, number, title }) => ({
         base: base.ref,
         body: body ?? "",
         draft: draft ?? false,
@@ -18949,20 +18955,31 @@ var rebaseStack = (root, required) => gen2(function* () {
     yield* error(`left "${name}" and the changes on it where they were: they conflict with the trunk`);
   }
 });
-var sync4 = (required = [], mergedChanges = []) => gen2(function* () {
+var mergedOnGitHub = (bookmarks) => gen2(function* () {
+  const github = yield* GitHub;
+  const merged = yield* forEach2(bookmarks.filter(({ remote }) => remote !== undefined), ({ change, local, name }) => github.mergedHeads(name).pipe(map7((heads) => heads.includes(local) ? [{ bookmark: name, changeId: change }] : [])), { concurrency: "unbounded" });
+  return merged.flat();
+});
+var sync4 = (known = []) => gen2(function* () {
   const jj = yield* Jj;
   const before = yield* bookmarksBeforeFetch;
+  const merged = [
+    ...known,
+    ...yield* mergedOnGitHub(before.filter(({ name }) => known.every(({ bookmark }) => bookmark !== name)))
+  ];
   yield* jj.run(["git", "fetch"]);
-  for (const { bookmark } of mergedChanges) {
+  for (const { bookmark } of merged) {
     yield* jj.run(["bookmark", "forget", "--include-remotes", `exact:${bookmark}`]);
   }
-  if (mergedChanges.length > 0) {
-    const revset = mergedChanges.map(({ changeId }) => `change_id(${changeId})`).join(" | ");
-    yield* jj.run(["abandon", `(${revset}) & mutable()`]);
+  const mergedRevset = `(${["none()", ...merged.map(({ changeId }) => `change_id(${changeId})`)].join(" | ")}) & mutable()`;
+  const required = yield* changeIdsAt(`(${mergedRevset}):: ~ (${mergedRevset})`);
+  if (merged.length > 0) {
+    yield* jj.run(["abandon", mergedRevset]);
+    yield* error(`abandoned the changes whose pull requests merged: ${merged.map(({ bookmark }) => bookmark).join(", ")}`);
   }
   const fetched = yield* bookmarkTargets;
   const notCombined = [];
-  for (const bookmark of before.filter(({ name }) => mergedChanges.every((change) => change.bookmark !== name))) {
+  for (const bookmark of before.filter(({ name }) => merged.every((change) => change.bookmark !== name))) {
     if (!(yield* combine4(bookmark, fetched.get(bookmark.name)?.origin))) {
       notCombined.push(bookmark.name);
     }
@@ -18970,8 +18987,8 @@ var sync4 = (required = [], mergedChanges = []) => gen2(function* () {
   for (const root of yield* commitsAt(BEHIND_ROOTS)) {
     yield* rebaseStack(root, required);
   }
-  const merged = (yield* bookmarksAt("::trunk()")).filter((name) => before.some((bookmark) => bookmark.name === name));
-  for (const name of merged) {
+  const onTrunk = (yield* bookmarksAt("::trunk()")).filter((name) => before.some((bookmark) => bookmark.name === name));
+  for (const name of onTrunk) {
     yield* jj.run(["bookmark", "forget", "--include-remotes", `exact:${name}`]);
   }
   if (notCombined.length > 0) {
@@ -18988,7 +19005,7 @@ var sync4 = (required = [], mergedChanges = []) => gen2(function* () {
 var syncCommand = make30("sync", {}, () => asUserError(gen2(function* () {
   yield* checkTrunk(yield* (yield* GitHub).defaultBranch);
   yield* sync4();
-}).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Fetch, and rebase every change onto the trunk", "Fetches, then rebases every change that isn't merged yet onto the trunk, keeping each on the changes below it. A change that has merged is empty after the rebase, so it's abandoned and its bookmark forgotten.", "A stack that would conflict with the trunk is left where it was, and named. Rebase it yourself with `jj rebase` when you want to resolve it.", "Commits added to a branch on GitHub are squashed into the branch's local change, whether or not that change was also edited locally. Where GitHub only rebased a branch, the local change is kept.", "Fails before fetching if `trunk()` isn't GitHub's default branch, which `jj gh init` sets.", "Pushes nothing. Run `jj gh submit` to update the pull requests of a change and the ones below it."));
+}).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Fetch, and rebase every change onto the trunk", "Fetches, then rebases every change that isn't merged yet onto the trunk, keeping each on the changes below it. A change whose pull request GitHub merged is abandoned and its bookmark forgotten, unless it was edited after the merge.", "A stack that would conflict with the trunk is left where it was, and named. Rebase it yourself with `jj rebase` when you want to resolve it. The rest of a stack whose changes merged is rebased even where it conflicts, and the conflict is recorded in the change.", "Commits added to a branch on GitHub are squashed into the branch's local change, whether or not that change was also edited locally. Where GitHub only rebased a branch, the local change is kept.", "Fails before fetching if `trunk()` isn't GitHub's default branch, which `jj gh init` sets.", "Pushes nothing. Run `jj gh submit` to update the pull requests of a change and the ones below it."));
 
 // src/cli/gh/merge.ts
 class NotMergeable extends TaggedError2("NotMergeable") {
@@ -19035,12 +19052,11 @@ var merge5 = (revision) => gen2(function* () {
   }
   const pullRequest = yield* openPullRequestOf(top);
   const above = yield* bookmarksAt(upstackRevset(bookmarkRevset(top)));
-  const stackChanges = yield* changeIdsAt(stackRevset(revision));
   if ((yield* mergeOnGitHub(pullRequest, trunk)) === "enqueued") {
     yield* error("queued to merge; run `jj gh sync` once it has");
   } else {
     yield* error(`merged up to #${pullRequest.number}`);
-    yield* sync4(stackChanges, changes);
+    yield* sync4(changes);
     for (const bookmark of above) {
       if ((yield* commitsAt(bookmarkRevset(bookmark))).length > 0) {
         yield* republish(bookmarkRevset(bookmark));
@@ -19049,7 +19065,7 @@ var merge5 = (revision) => gen2(function* () {
     }
   }
 });
-var mergeCommand = make30("merge", { revision: revisionFlag("The top change to merge") }, ({ revision }) => asUserError(merge5(revision).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Merge the pull requests of a change and the ones below it", "Squash-merges them, and prints which before it does. An empty working copy means the change below it. Fails before merging if any of the changes has edits that aren't pushed.", "A pull request in a GitHub stack is merged together with the pull requests below it. Either all of them merge or none does. A pull request outside a stack is merged alone, and only if its base is the trunk.", "Then syncs, as `jj gh sync` does, and pushes what is left of the change's stack again, up to the highest branch already on GitHub. Unlike `jj gh sync`, it abandons the merged changes and forgets their bookmarks, rather than relying on each coming out empty on the trunk, which one doesn't where a change merged above it edited the same lines. It also rebases the rest of the stack even where it conflicts with the trunk, and the conflict is recorded in the change.", "If GitHub queues the merge instead, nothing is synced. Run `jj gh sync` once it has merged."));
+var mergeCommand = make30("merge", { revision: revisionFlag("The top change to merge") }, ({ revision }) => asUserError(merge5(revision).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Merge the pull requests of a change and the ones below it", "Squash-merges them, and prints which before it does. An empty working copy means the change below it. Fails before merging if any of the changes has edits that aren't pushed.", "A pull request in a GitHub stack is merged together with the pull requests below it. Either all of them merge or none does. A pull request outside a stack is merged alone, and only if its base is the trunk.", "Then syncs, as `jj gh sync` does: it abandons the merged changes, forgets their bookmarks, and rebases the rest of the stack onto the trunk even where it conflicts, recording the conflict in the change. Then it pushes what is left of the change's stack again, up to the highest branch already on GitHub.", "If GitHub queues the merge instead, nothing is synced. Run `jj gh sync` once it has merged."));
 
 // src/cli/gh/submit.ts
 var submitCommand = make30("submit", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jj-octo",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "A jj subcommand for working with GitHub that supports stacking",
   "license": "MIT",
   "repository": {