feat: set PR base branch from first remote bookmark in commit history

When creating a PR, walk the ancestor commits of the bookmark to find
the first bookmark that exists on the remote, and use it as the base
branch in the GitHub compare URL.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: olup

package.json

@@ -2,7 +2,7 @@
   "name": "open-jj",
   "displayName": "OPEN JJ",
   "description": "Jujutsu (jj) version control integration for VS Code",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "publisher": "olup",
   "license": "MIT",
   "engines": {
@@ -69,12 +69,6 @@
         "title": "Abandon Change",
         "category": "JJ"
       },
-      {
-        "command": "open-jj.bookmark.manage",
-        "title": "Manage Bookmarks",
-        "category": "JJ",
-        "icon": "$(bookmark)"
-      },
       {
         "command": "open-jj.bookmark.create",
         "title": "Create Bookmark",

src/extension.ts

@@ -450,202 +450,6 @@ function registerCoreCommands(context: vscode.ExtensionContext): void {
     })
   );
 
-  // Manage bookmarks - tag-style UI
-  context.subscriptions.push(
-    vscode.commands.registerCommand('open-jj.bookmark.manage', async (arg?: Change | { change: Change }) => {
-      if (!repository) {
-        return;
-      }
-
-      const change = arg && 'change' in arg ? arg.change : arg;
-      const targetRevision = change?.changeIdShort ?? '@';
-      const targetChangeId = change?.changeId ?? repository.currentChange?.changeId;
-
-      // Get bookmarks on this change
-      const bookmarksOnChange = repository.bookmarks.filter(
-        b => !b.isRemote && targetChangeId && b.changeId === targetChangeId
-      );
-      const otherBookmarks = repository.bookmarks.filter(
-        b => !b.isRemote && (!targetChangeId || b.changeId !== targetChangeId)
-      );
-
-      interface ActionItem extends vscode.QuickPickItem {
-        action: 'remove' | 'add' | 'create';
-        bookmarkName?: string;
-      }
-
-      const showPicker = async () => {
-        // Refresh bookmark lists
-        // Compare using startsWith since bookmark changeId might be short
-        const isOnChange = (b: { changeId: string }) => {
-          if (!targetChangeId) return false;
-          return targetChangeId.startsWith(b.changeId) || b.changeId.startsWith(targetChangeId);
-        };
-
-        const currentOnChange = repository!.bookmarks.filter(
-          b => !b.isRemote && isOnChange(b)
-        );
-        const currentOther = repository!.bookmarks.filter(
-          b => !b.isRemote && !isOnChange(b)
-        );
-
-        const buildItems = (filter: string): ActionItem[] => {
-          const items: ActionItem[] = [];
-          const filterLower = filter.toLowerCase();
-
-          // Current bookmarks on this change (removable)
-          const matchingOnChange = currentOnChange.filter(b => b.name.toLowerCase().includes(filterLower));
-          if (matchingOnChange.length > 0) {
-            items.push({
-              label: 'On this change',
-              kind: vscode.QuickPickItemKind.Separator,
-              action: 'remove',
-            });
-            for (const b of matchingOnChange) {
-              items.push({
-                label: `$(close)  ${b.name}`,
-                description: 'click to remove',
-                action: 'remove',
-                bookmarkName: b.name,
-              });
-            }
-          }
-
-          // Other bookmarks (can be moved here)
-          const matchingOther = currentOther.filter(b => b.name.toLowerCase().includes(filterLower));
-          if (matchingOther.length > 0) {
-            items.push({
-              label: 'Move to this change',
-              kind: vscode.QuickPickItemKind.Separator,
-              action: 'add',
-            });
-            for (const b of matchingOther) {
-              items.push({
-                label: `$(add)  ${b.name}`,
-                description: b.changeId.slice(0, 8),
-                action: 'add',
-                bookmarkName: b.name,
-              });
-            }
-          }
-
-          // Add "Create xxx" option if there's text and no exact match
-          const allBookmarks = [...currentOnChange, ...currentOther];
-          const hasExactMatch = allBookmarks.some(b => b.name.toLowerCase() === filterLower);
-          if (filter.trim() && !hasExactMatch) {
-            items.push({
-              label: `$(plus)  Create "${filter.trim()}"`,
-              description: 'Create new bookmark',
-              action: 'create',
-              bookmarkName: filter.trim(),
-            });
-          } else {
-            // Create new option (static)
-            items.push({
-              label: 'Create new bookmark...',
-              kind: vscode.QuickPickItemKind.Separator,
-              action: 'create',
-            });
-            items.push({
-              label: '$(plus)  Create new bookmark',
-              description: 'type a name for the new bookmark',
-              action: 'create',
-            });
-          }
-
-          return items;
-        };
-
-        const quickPick = vscode.window.createQuickPick<ActionItem>();
-        quickPick.title = `Bookmarks on ${change?.changeIdShort ?? '@'}`;
-        quickPick.placeholder = currentOnChange.length > 0
-          ? `Current: ${currentOnChange.map(b => b.name).join(', ')}`
-          : 'No bookmarks on this change';
-        quickPick.items = buildItems('');
-        quickPick.matchOnDescription = true;
-
-        quickPick.onDidChangeValue((value) => {
-          quickPick.items = buildItems(value);
-        });
-
-        const picked = await new Promise<ActionItem | undefined>((resolve) => {
-          quickPick.onDidAccept(() => {
-            resolve(quickPick.selectedItems[0]);
-            quickPick.hide();
-          });
-          quickPick.onDidHide(() => {
-            resolve(undefined);
-            quickPick.dispose();
-          });
-          quickPick.show();
-        });
-
-        if (!picked || picked.kind === vscode.QuickPickItemKind.Separator) {
-          return;
-        }
-
-        if (picked.action === 'remove' && picked.bookmarkName) {
-          // Remove = move to a new empty change (abandon it from here)
-          // Actually in jj we can't easily "remove" a bookmark, we just move it
-          // Let's ask where to move it or delete it
-          const choice = await vscode.window.showQuickPick([
-            { label: '$(trash)  Delete bookmark', value: 'delete' },
-            { label: '$(arrow-right)  Move to different change...', value: 'move' },
-          ], {
-            title: `What to do with "${picked.bookmarkName}"?`,
-          });
-
-          if (choice?.value === 'delete') {
-            await repository!.deleteBookmark(picked.bookmarkName);
-            vscode.window.showInformationMessage(`Deleted bookmark "${picked.bookmarkName}"`);
-          } else if (choice?.value === 'move') {
-            const targetChange = await vscode.window.showInputBox({
-              prompt: 'Enter change ID to move bookmark to',
-              placeHolder: 'e.g., abc123',
-            });
-            if (targetChange) {
-              await repository!.setBookmark(picked.bookmarkName, targetChange);
-              vscode.window.showInformationMessage(`Moved "${picked.bookmarkName}" to ${targetChange}`);
-            }
-          }
-          await showPicker(); // Show picker again
-        } else if (picked.action === 'add' && picked.bookmarkName) {
-          await repository!.setBookmark(picked.bookmarkName, targetRevision);
-          vscode.window.showInformationMessage(`Moved "${picked.bookmarkName}" here`);
-          await showPicker(); // Show picker again
-        } else if (picked.action === 'create') {
-          let name = picked.bookmarkName;
-          if (!name) {
-            name = await vscode.window.showInputBox({
-              prompt: 'Enter new bookmark name',
-              placeHolder: 'bookmark-name',
-              validateInput: (v) => {
-                if (!v?.trim()) return 'Name required';
-                if (!/^[\w\-./]+$/.test(v)) return 'Invalid characters';
-                if (repository!.bookmarks.some(b => b.name === v)) return 'Already exists';
-                return null;
-              },
-            });
-          }
-          if (name) {
-            // Validate the name
-            if (!/^[\w\-./]+$/.test(name)) {
-              vscode.window.showErrorMessage('Invalid bookmark name');
-            } else if (repository!.bookmarks.some(b => b.name === name)) {
-              vscode.window.showErrorMessage('Bookmark already exists');
-            } else {
-              await repository!.createBookmark(name, targetRevision);
-              vscode.window.showInformationMessage(`Created bookmark "${name}"`);
-            }
-          }
-          await showPicker(); // Show picker again
-        }
-      };
-
-      await showPicker();
-    })
-  );
-
   // Create bookmark (simple version, kept for compatibility)
   context.subscriptions.push(
     vscode.commands.registerCommand('open-jj.bookmark.create', async (arg?: Change | { change: Change }) => {

src/repository/repository.ts

@@ -549,6 +549,72 @@ export class Repository implements vscode.Disposable {
     return session !== null;
   }
 
+  /**
+   * Find the base branch for a PR by walking ancestors to find the first
+   * bookmark that exists on the remote.
+   */
+  findBaseBranchForPr(bookmarkName: string): string | null {
+    // Build set of bookmark names that exist on remote
+    const remoteBookmarkNames = new Set<string>();
+    for (const b of this._bookmarks) {
+      if (b.isRemote && b.remote !== 'git') {
+        remoteBookmarkNames.add(b.name);
+      }
+    }
+
+    const normalizeBookmarkName = (name: string): string => {
+      const withoutConflict = name.endsWith('*') ? name.slice(0, -1) : name;
+      const atIndex = withoutConflict.indexOf('@');
+      return atIndex === -1 ? withoutConflict : withoutConflict.slice(0, atIndex);
+    };
+
+    // Build commitId -> Change map from full log
+    const changeByCommitId = new Map<string, Change>();
+    for (const change of this._fullLog) {
+      changeByCommitId.set(change.commitId, change);
+    }
+
+    // Find the change that has this bookmark
+    const startChange = this._fullLog.find(c =>
+      c.bookmarks.some(b => normalizeBookmarkName(b) === bookmarkName)
+    );
+    if (!startChange) {
+      return null;
+    }
+
+    // BFS through ancestors (skip the start change itself)
+    const queue = [...startChange.parentIds];
+    const visited = new Set<string>();
+
+    while (queue.length > 0) {
+      const commitId = queue.shift()!;
+      if (visited.has(commitId)) {
+        continue;
+      }
+      visited.add(commitId);
+
+      const change = changeByCommitId.get(commitId);
+      if (!change) {
+        continue;
+      }
+
+      // Check if any bookmark on this ancestor exists on remote
+      for (const bName of change.bookmarks) {
+        const normalized = normalizeBookmarkName(bName);
+        if (normalized && remoteBookmarkNames.has(normalized)) {
+          return normalized;
+        }
+      }
+
+      // Continue to parents
+      for (const parentId of change.parentIds) {
+        queue.push(parentId);
+      }
+    }
+
+    return null;
+  }
+
   /**
    * Get the absolute path for a relative file path
    */

src/views/logWebview.ts

@@ -376,10 +376,6 @@ export class LogWebviewProvider implements vscode.WebviewViewProvider {
         vscode.commands.executeCommand('open-jj.edit', { change: this._findChange(message.changeId as string) });
         break;
 
-      case 'manageBookmarks':
-        vscode.commands.executeCommand('open-jj.bookmark.manage', { change: this._findChange(message.changeId as string) });
-        break;
-
       case 'describeChange':
         vscode.commands.executeCommand('open-jj.describe', this._findChange(message.changeId as string));
         break;
@@ -436,6 +432,10 @@ export class LogWebviewProvider implements vscode.WebviewViewProvider {
         vscode.commands.executeCommand('open-jj.new', { revision: message.changeId });
         break;
 
+      case 'createBookmark':
+        vscode.commands.executeCommand('open-jj.bookmark.create', { change: this._findChange(message.changeId as string) });
+        break;
+
       case 'refresh':
         await repo.refresh({ refreshPrInfo: true });
         break;
@@ -502,7 +502,8 @@ export class LogWebviewProvider implements vscode.WebviewViewProvider {
         const prBookmark = message.bookmarkName as string;
         const remoteUrl = await repo.getRemoteUrl();
         if (remoteUrl) {
-          const githubUrl = this._convertToGitHubPrUrl(remoteUrl, prBookmark);
+          const baseBranch = repo.findBaseBranchForPr(prBookmark) ?? undefined;
+          const githubUrl = this._convertToGitHubPrUrl(remoteUrl, prBookmark, baseBranch);
           if (githubUrl) {
             vscode.env.openExternal(vscode.Uri.parse(githubUrl));
           } else {
@@ -531,7 +532,8 @@ export class LogWebviewProvider implements vscode.WebviewViewProvider {
           // Now open PR creation page
           const pushPrRemoteUrl = await repo.getRemoteUrl();
           if (pushPrRemoteUrl) {
-            const pushPrGitHubUrl = this._convertToGitHubPrUrl(pushPrRemoteUrl, pushPrBookmark);
+            const pushPrBaseBranch = repo.findBaseBranchForPr(pushPrBookmark) ?? undefined;
+            const pushPrGitHubUrl = this._convertToGitHubPrUrl(pushPrRemoteUrl, pushPrBookmark, pushPrBaseBranch);
             if (pushPrGitHubUrl) {
               vscode.env.openExternal(vscode.Uri.parse(pushPrGitHubUrl));
             } else {
@@ -573,13 +575,16 @@ export class LogWebviewProvider implements vscode.WebviewViewProvider {
     return this._repository?.log.filter(c => c.changeId === changeId || c.changeIdShort === changeId) ?? [];
   }
 
-  private _convertToGitHubPrUrl(remoteUrl: string, branchName: string): string | null {
+  private _convertToGitHubPrUrl(remoteUrl: string, branchName: string, baseBranch?: string): string | null {
     // Convert git remote URL to GitHub PR creation URL
     // Handles: git@github.com:owner/repo.git, https://github.com/owner/repo.git
     let match = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/]+?)(\.git)?$/);
     if (match) {
       const owner = match[1];
       const repo = match[2];
+      if (baseBranch) {
+        return `https://github.com/${owner}/${repo}/compare/${baseBranch}...${branchName}?expand=1`;
+      }
       return `https://github.com/${owner}/${repo}/compare/${branchName}?expand=1`;
     }
     return null;
@@ -853,7 +858,7 @@ export class LogWebviewProvider implements vscode.WebviewViewProvider {
     }
 
     if (badges.length === 0) return '';
-    return `<span class="bookmarks" data-action="manage-bookmarks" data-change-id="${changeId}" title="Manage Bookmarks">${badges.join('')}</span>`;
+    return `<span class="bookmarks">${badges.join('')}</span>`;
   }
 
   private _renderFiles(files: FileChange[], revision?: string, changeId?: string, graphInfo?: GraphInfo): string {