@kubohiroya/turbowarp-plus-editor-git 0.16.1 → 0.18.0

package/src/index.tsx

@@ -5,7 +5,9 @@ import {FileDiffView} from './file-diff-view.js';
 import {findElement, ProjectChangeListView, ProjectElementView, projectChangeLabels, useProjectChanges} from './project-change-list.js';
 import type {ChangedFile} from './project-change-model.js';
 import {openRepository} from './repository.js';
-import type {Repository, Snapshot, FileChange, FileDiff, ChangeGroup, HistoryCommit, HistoryCursor} from './repository.js';
+import type {BranchRefs, Repository, Snapshot, FileChange, FileDiff, ChangeGroup, HistoryCommit, HistoryCursor} from './repository.js';
+import {BranchButton} from './branch-button.js';
+import type {BranchButtonState} from './branch-button.js';
 import {HistoryGraph} from './history-graph-view.js';
 import type {HistoryActionResult} from './history-graph-view.js';
 import {labelsFor} from './messages.js';
@@ -14,6 +16,7 @@ import {ConnectionSettings} from './connection-settings.js';
 import type {GitConnectionSettings} from './connection-settings.js';
 import type {RemoteOperation} from './remote-operations.js';
 import type {GitAuthor, LocalOperation} from './local-operations.js';
+import {pullRequestBranch} from './local-operations.js';
 import {PullRequestReviewPanel} from './pull-request-panel.js';
 import {openProjectSourceTabs} from './project-source-tabs.js';
 import type {ProjectSourceTabsFile} from './project-source-tabs.js';
@@ -28,17 +31,20 @@ import type {LocatorVM} from './editor-block-locator.js';
 export {createScratchBlocksDiffRenderer} from './scratch-block-diff-renderer.js';
 export type {ScratchBlockDiffRendererOptions, ScratchBlocksPort} from './scratch-block-diff-renderer.js';
 
-export {openRepository, createReadOnlyFs, GitPanelError} from './repository.js';
+export {openRepository, createReadOnlyFs, GitPanelError, pullRequestRef} from './repository.js';
 export {openProjectComparison} from './project-comparison.js';
 export {openProjectSourceTabs} from './project-source-tabs.js';
 export type {ProjectSourceTabsFile, ProjectSourceTabsOptions} from './project-source-tabs.js';
 export type {ProjectComparisonAction, ProjectComparisonOptions, ProjectComparisonSection} from './project-comparison.js';
-export type {Repository, Snapshot, FileChange, FileDiff, HistoryCommit, HistoryCursor, HistoryPage, HistoryRef} from './repository.js';
+export type {BranchRefs, PullRequestBase, PullRequestFetch, PullRequestFiles, Repository, Snapshot, FileChange, FileDiff, HistoryCommit, HistoryCursor, HistoryPage, HistoryRef} from './repository.js';
+export {BranchButton} from './branch-button.js';
+export type {BranchButtonActions, BranchButtonProps, BranchButtonState} from './branch-button.js';
 export {HistoryGraph, laneColors} from './history-graph-view.js';
 export type {HistoryActionResult, HistoryGraphProps} from './history-graph-view.js';
 export {layoutHistory} from './history-graph.js';
 export type {GraphCommit, GraphLayout, GraphRow, GraphSegment} from './history-graph.js';
 export type {GitAuthor, LocalOperation} from './local-operations.js';
+export {pullRequestBranch} from './local-operations.js';
 
 export interface GitHost {
     connectionSettings?: GitConnectionSettings;
@@ -75,7 +81,46 @@ export interface GitPanelRequest {
     inactive?: boolean;
     mount(element: HTMLElement, close: () => void): {requestClose(): void; dispose(): void};
 }
-interface Controller {open(locale: string): void; refresh(automatic?: boolean): Promise<void>}
+type BranchOperation = Extract<LocalOperation, {kind: 'createBranch' | 'switchBranch'}>;
+/** The panel's side of its entries: set by the panel as it renders, used by the branch buttons and `mountGitPanel`'s result. */
+interface Controller {
+    open(locale: string): void;
+    refresh(automatic?: boolean): Promise<void>;
+    /** Asks for a repository, then opens the panel on it. */
+    choose(locale: string): Promise<void>;
+    changeBranch(operation: BranchOperation): Promise<HistoryActionResult>;
+    /** What the branch buttons show. */
+    branch: BranchButtonState;
+    publish(state: BranchButtonState): void;
+    /** Follows `branch`. While anything follows it, the closed panel keeps watching the branches. */
+    follow(listener: () => void): () => void;
+    /** How many follow `branch`. */
+    followers(): number;
+    /** Set by the panel while it is mounted, to hear when `followers()` changes. */
+    onFollowers(count: number): void;
+}
+function createController(): Controller {
+    const listeners = new Set<() => void>();
+    const controller: Controller = {
+        open() {}, async refresh() {}, async choose() {}, async changeBranch() {return {done: false};},
+        branch: {repository: false, branch: undefined, head: null, branches: [], remoteBranches: [], writable: false, busy: false},
+        publish(state) {
+            controller.branch = state;
+            for (const listener of [...listeners]) listener();
+        },
+        follow(listener) {
+            listeners.add(listener);
+            controller.onFollowers(listeners.size);
+            return () => {
+                listeners.delete(listener);
+                controller.onFollowers(listeners.size);
+            };
+        },
+        followers: () => listeners.size,
+        onFollowers() {}
+    };
+    return controller;
+}
 interface State {
     repository: Repository | null;
     snapshot: Snapshot | null;
@@ -92,6 +137,8 @@ interface State {
 const initial: State = {repository: null, snapshot: null, project: null, browser: null,
     changes: [], selected: null, diff: null, commit: null, error: null, busy: false};
 const controllers = new WeakMap<object, Controller>();
+// Branch buttons rendered before the panel is mounted, or after it is disposed, wait for the VM's controller here.
+const registrations = new Set<() => void>();
 type PickerWindow = Window & {showDirectoryPicker?: (options: {id: string; mode: 'readwrite'}) => Promise<FileSystemDirectoryHandle>};
 type ObserverWindow = Window & {FileSystemObserver?: new (callback: () => void) => {
     observe(handle: FileSystemDirectoryHandle, options: {recursive: boolean}): Promise<void>;
@@ -99,6 +146,53 @@ type ObserverWindow = Window & {FileSystemObserver?: new (callback: () => void)
 }};
 const watchInterval = 2000;
 
+/**
+ * Calls `check` every `watchInterval`, when the window regains focus and shortly after a File System Observer reports
+ * a change under `root`, one call at a time and never while the page is hidden. Returns the function that stops it.
+ */
+function watchRepository(document: Document, root: FileSystemDirectoryHandle, check: (stopped: () => boolean) => Promise<void>) {
+    const view = document.defaultView as ObserverWindow;
+    let stopped = false;
+    let checking = false;
+    const run = async () => {
+        if (stopped || checking || document.visibilityState === 'hidden') return;
+        checking = true;
+        try {
+            await check(() => stopped);
+        } catch {
+            // Entries can disappear while another tool writes. The next check reads them again.
+        } finally {
+            checking = false;
+        }
+    };
+    let soon: number | undefined;
+    const schedule = () => {view.clearTimeout(soon); soon = view.setTimeout(() => void run(), 300);};
+    const interval = view.setInterval(() => void run(), watchInterval);
+    const onFocus = () => void run();
+    view.addEventListener('focus', onFocus);
+    document.addEventListener('visibilitychange', onFocus);
+    let observer: InstanceType<NonNullable<ObserverWindow['FileSystemObserver']>> | null = null;
+    try {
+        if (view.FileSystemObserver) {
+            observer = new view.FileSystemObserver(schedule);
+            observer.observe(root, {recursive: true}).catch(() => {});
+        }
+    } catch {
+        observer = null;
+    }
+    void run();
+    return () => {
+        stopped = true;
+        view.clearInterval(interval);
+        view.clearTimeout(soon);
+        view.removeEventListener('focus', onFocus);
+        document.removeEventListener('visibilitychange', onFocus);
+        observer?.disconnect();
+    };
+}
+const sameRefs = (a: BranchRefs | null, b: BranchRefs) => !!a && a.branch === b.branch && a.head === b.head &&
+    a.branches.join('\n') === b.branches.join('\n') && a.remoteBranches.join('\n') === b.remoteBranches.join('\n');
+
 function GitPanel({vm, document, host, controller}: {vm: object; document: Document; host: GitHost; controller: Controller}) {
     const [visible, setVisible] = useState(false);
     // A layout tab that holds the panel. The panel component stays mounted, so the repository survives closing the tab.
@@ -231,61 +325,48 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
             void controller.refresh();
         }
     }, [shown]);
+    // The branches the branch buttons show: those of the last snapshot, or newer ones read while the panel is not in view.
+    const [refs, setRefs] = useState<BranchRefs | null>(null);
+    useEffect(() => {
+        if (!state.repository) setRefs(null);
+        else if (state.snapshot) setRefs(refsOf(state.snapshot));
+    }, [state.repository, state.snapshot]);
+    const [followers, setFollowers] = useState(controller.followers());
+    useEffect(() => {
+        controller.onFollowers = setFollowers;
+        // A button may have started following before the panel was mounted.
+        setFollowers(controller.followers());
+        return () => {controller.onFollowers = () => {};};
+    }, []);
     // While the panel is open, notice Git commands, agents and editors that change the repository outside the Editor.
+    // While it is out of view and a branch button follows it, read only the refs at the same moments, so the button
+    // follows branch changes; the panel reads everything again when it comes into view.
+    const following = followers > 0;
     useEffect(() => {
         const repository = state.repository;
-        if (!shown || !repository) return;
-        const view = document.defaultView as ObserverWindow;
-        let stopped = false;
-        let checking = false;
-        const check = async () => {
+        if (!repository || !shown && !following) return;
+        return watchRepository(document, repository.root, async stopped => {
             const {snapshot} = current.current;
+            if (running.current || current.current.repository !== repository) return;
             // A tab behind another one has no boxes; it reads again when it is shown.
-            const hidden = !dialog.current || !dialog.current.getClientRects().length;
-            if (stopped || checking || running.current || document.visibilityState === 'hidden' || hidden ||
-                !snapshot || current.current.repository !== repository) return;
-            checking = true;
-            try {
-                const probe = await repository.probe(snapshot.scope);
-                if (stopped || probe === 'locked' || probe === snapshot.probe || probe === handled.current ||
-                    current.current.snapshot !== snapshot) return;
-                handled.current = probe;
-                const {selected, commit} = current.current;
-                // Keep an open diff, commit or review in place and ask for a refresh instead.
-                if (selected || commit || reviewing.current) {
-                    setState(previous => previous.snapshot === snapshot ? {...previous, notice: labelsFor(locale).outdated} : previous);
-                } else await controller.refresh(true);
-            } catch {
-                // Entries can disappear while another tool writes. The next check reads them again.
-            } finally {
-                checking = false;
-            }
-        };
-        let soon: number | undefined;
-        const schedule = () => {view.clearTimeout(soon); soon = view.setTimeout(() => void check(), 300);};
-        const interval = view.setInterval(() => void check(), watchInterval);
-        const onFocus = () => void check();
-        view.addEventListener('focus', onFocus);
-        document.addEventListener('visibilitychange', onFocus);
-        let observer: InstanceType<NonNullable<ObserverWindow['FileSystemObserver']>> | null = null;
-        try {
-            if (view.FileSystemObserver) {
-                observer = new view.FileSystemObserver(schedule);
-                observer.observe(repository.root, {recursive: true}).catch(() => {});
+            const inView = shown && !!dialog.current && dialog.current.getClientRects().length > 0;
+            if (!inView || !snapshot) {
+                if (!following) return;
+                const next = await repository.refs();
+                if (!stopped() && current.current.repository === repository) setRefs(previous => sameRefs(previous, next) ? previous : next);
+                return;
             }
-        } catch {
-            observer = null;
-        }
-        void check();
-        return () => {
-            stopped = true;
-            view.clearInterval(interval);
-            view.clearTimeout(soon);
-            view.removeEventListener('focus', onFocus);
-            document.removeEventListener('visibilitychange', onFocus);
-            observer?.disconnect();
-        };
-    }, [shown, state.repository, locale]);
+            const probe = await repository.probe(snapshot.scope);
+            if (stopped() || probe === 'locked' || probe === snapshot.probe || probe === handled.current ||
+                current.current.snapshot !== snapshot) return;
+            handled.current = probe;
+            const {selected, commit} = current.current;
+            // Keep an open diff, commit or review in place and ask for a refresh instead.
+            if (selected || commit || reviewing.current) {
+                setState(previous => previous.snapshot === snapshot ? {...previous, notice: labelsFor(locale).outdated} : previous);
+            } else await controller.refresh(true);
+        });
+    }, [shown, following, state.repository, locale]);
     useEffect(() => {
         if (!visible || slot) return;
         const previous = document.activeElement as HTMLElement | null;
@@ -294,7 +375,7 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
     }, [visible, slot]);
     const chooseRoot = async () => {
         const view = document.defaultView as PickerWindow;
-        await run(async () => {
+        return run(async () => {
             let root: FileSystemDirectoryHandle;
             try {root = await view.showDirectoryPicker!({id: 'turbowarp-plus-git-root', mode: 'readwrite'});} catch (error) {
                 if ((error as DOMException).name === 'AbortError') return {};
@@ -365,6 +446,12 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
                 notice: operation === 'pull' && current.current.project !== null ? labels.pulledProject : labels.remoteDone};
         });
     };
+    // A connected GitHub connection reads pull request contents over Git Smart HTTP, so private repositories work too.
+    const pullRequestConnection = useMemo(() => {
+        const settings = host.connectionSettings;
+        const getSession = settings?.getSession;
+        return getSession ? {getSession, connected: () => settings.getView().state.status === 'connected'} : undefined;
+    }, [host]);
     const [message, setMessage] = useState('');
     const localOperation = (operation: LocalOperation, notice?: string) => {
         const repository = current.current.repository;
@@ -386,7 +473,7 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
     };
     const [newBranch, setNewBranch] = useState('');
     const [switchAfterCreate, setSwitchAfterCreate] = useState(true);
-    const changeBranch = async (operation: Extract<LocalOperation, {kind: 'createBranch' | 'switchBranch'}>): Promise<HistoryActionResult> => {
+    const changeBranch = async (operation: BranchOperation): Promise<HistoryActionResult> => {
         const repository = current.current.repository;
         const project = current.current.project;
         const switching = operation.kind === 'switchBranch' || operation.checkout;
@@ -401,6 +488,25 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
         if (operation.kind === 'createBranch' && !operation.fromRemote && !at) setNewBranch('');
         return result;
     };
+    /**
+     * Opens a pull request version fetched over the connection: creates `pr/<number>` at its head (or reuses that
+     * branch when it already points there), switches to it with the same refusals as any switch, and opens the project
+     * folder again from it. The branch the person was on stays, so switching back is an ordinary switch.
+     */
+    const openPullRequest = async (number: number, head: string): Promise<HistoryActionResult> => {
+        const repository = current.current.repository;
+        if (!repository) return {done: false};
+        const original = current.current.snapshot?.branch ?? null;
+        const name = pullRequestBranch(number);
+        const result = await changeBranch({kind: 'createBranch', name, at: head, checkout: true, reuse: true});
+        if (!result.done) return result;
+        const project = current.current.project;
+        if (project !== null && await repository.hasFolder(name, project)) await openProject(project);
+        const notice = (original && original !== name ? labels.openedPullRequest : labels.openedPullRequestDetached)
+            .replace('{number}', String(number)).replace('{branch}', name).replace('{previous}', original ?? '');
+        if (alive.current) setState(previous => previous.error ? previous : {...previous, notice});
+        return result;
+    };
     // The history graph reads its own pages after each snapshot, through the same queue as the other reads.
     const [history, setHistory] = useState<{commits: HistoryCommit[]; cursor: HistoryCursor | null; loading: boolean; failed: boolean}>(
         {commits: [], cursor: null, loading: false, failed: false});
@@ -445,6 +551,18 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
     // One loader per selected change, so thumbnails read each asset once.
     const loadAsset = useMemo(() => state.repository && state.snapshot && state.selected ?
         state.repository.assetLoader(state.snapshot, state.selected) : undefined, [state.repository, state.snapshot, state.selected]);
+    controller.changeBranch = changeBranch;
+    controller.choose = async language => {
+        setLocale(language);
+        const before = current.current.repository;
+        const result = await chooseRoot();
+        // The panel shows the chosen repository, or why it could not be read; a cancelled choice opens nothing.
+        if (!result.done && result.error || current.current.repository !== before) controller.open(language);
+    };
+    const branchState: BranchButtonState = {repository: !!state.repository, branch: refs?.branch, head: refs?.head ?? null,
+        branches: refs?.branches ?? [], remoteBranches: refs?.remoteBranches ?? [], writable: !!host.localWrite && !!refs, busy: state.busy};
+    const published = JSON.stringify(branchState);
+    useEffect(() => controller.publish(branchState), [published]);
     if (!shown) return null;
     const groups: ChangeGroup[] = state.commit ? ['commit'] : ['staged', 'unstaged', 'untracked'];
     // Branches can be switched and created whenever writes are allowed and the repository has been read.
@@ -517,7 +635,8 @@ function GitPanel({vm, document, host, controller}: {vm: object; document: Docum
             {!state.repository && <p>{labels.empty}</p>}
             {review && state.repository && host.renderReviewBlock &&
                 <PullRequestReviewPanel repository={state.repository} locale={locale} renderBlock={host.renderReviewBlock}
-                    locateFor={reviewLocator} openTabs={openTabs}/>}
+                    locateFor={reviewLocator} openTabs={openTabs} connection={pullRequestConnection}
+                    openLocally={branching ? {open: openPullRequest, busy: state.busy} : undefined}/>}
             {!review && state.repository && <div className="twgit-content">
                 <aside>
                     {state.browser && <details>
@@ -628,28 +747,55 @@ function upstreamText({upstream}: Snapshot, labels: ReturnType<typeof labelsFor>
     }
 }
 
+const refsOf = ({branch, head, branches, remoteBranches}: Snapshot): BranchRefs => ({branch, head, branches, remoteBranches});
+const announce = () => {for (const listener of [...registrations]) listener();};
+
 export function mountGitPanel({vm, document, host}: {vm: object; document: Document; host: GitHost}) {
     if (!(document.defaultView as PickerWindow)?.showDirectoryPicker) return null;
     const root = document.createElement('div');
     document.body.append(root);
-    const controller: Controller = {open() {}, async refresh() {}};
+    const controller = createController();
     controllers.set(vm, controller);
     render(<GitPanel vm={vm} document={document} host={host} controller={controller}/>, root);
-    return {refresh: () => controller.refresh(), dispose() {
+    announce();
+    return {refresh: () => controller.refresh(), open: (locale: string) => controller.open(locale), dispose() {
         if (controllers.get(vm) === controller) controllers.delete(vm);
         void host.connectionSettings?.disconnect().catch(() => {});
         unmountComponentAtNode(root);
         root.remove();
+        announce();
     }};
 }
 
-export function renderGitMenu(createElement: (component: any, props: any, ...children: any[]) => any,
-    {vm, locale = 'en', MenuItem, MenuSection, onRequestClose}: {
-        vm: object; locale?: string; MenuItem: any; MenuSection: any; onRequestClose(): void;
-    }) {
-    const controller = controllers.get(vm);
-    if (!controller) return null;
-    return createElement(MenuSection, null, createElement(MenuItem, {
-        command: 'local-git', onClick() {onRequestClose(); controller.open(locale);}
-    }, labelsFor(locale).menu));
+/** The branch button of the panel mounted for `vm`, or nothing while no panel is mounted for it. */
+function BranchEntry({vm, locale}: {vm: object; locale: string}) {
+    const [controller, setController] = useState(() => controllers.get(vm));
+    useEffect(() => {
+        const update = () => setController(controllers.get(vm));
+        registrations.add(update);
+        update();
+        return () => {registrations.delete(update);};
+    }, [vm]);
+    const [state, setState] = useState(controller?.branch);
+    useEffect(() => {
+        if (!controller) return;
+        const update = () => setState(controller.branch);
+        update();
+        return controller.follow(update);
+    }, [controller]);
+    if (!controller || !state) return null;
+    return <BranchButton state={state} locale={locale} open={() => controller.open(locale)} choose={() => void controller.choose(locale)}
+        switchBranch={name => controller.changeBranch({kind: 'switchBranch', name})}
+        createBranch={(name, checkout) => controller.changeBranch({kind: 'createBranch', name, checkout})}
+        createFromRemote={name => controller.changeBranch({kind: 'createBranch', name, fromRemote: true, checkout: true})}/>;
+}
+
+/**
+ * Renders the button for the host's menu bar that shows the current branch of the panel mounted for `vm` and opens the
+ * menu of branches, the panel and the repository choice. It renders nothing while no panel is mounted for `vm`, such as
+ * when the host does not offer local Git, and shares the panel's repository, operations and checks.
+ */
+export function renderBranchButton(createElement: (component: any, props: any, ...children: any[]) => any,
+    {vm, locale = 'en'}: {vm: object; locale?: string}) {
+    return createElement(BranchEntry, {vm, locale});
 }

package/src/local-operations.ts

@@ -10,11 +10,18 @@ export type LocalOperation =
     | {kind: 'commit'; message: string; author?: GitAuthor}
     /**
      * Creates `name` at HEAD, at the commit `at`, or at `origin/<name>` with `fromRemote`, and switches to it with
-     * `checkout`.
+     * `checkout`. With `reuse` (only with `at`), a branch `name` that already points at `at` is switched to instead of
+     * failing, and one that points elsewhere fails with `pullRequestBranch` and is never moved.
      */
-    | {kind: 'createBranch'; name: string; fromRemote?: boolean; at?: string; checkout: boolean}
+    | {kind: 'createBranch'; name: string; fromRemote?: boolean; at?: string; checkout: boolean; reuse?: boolean}
     | {kind: 'switchBranch'; name: string};
 
+/**
+ * The local branch a pull request is opened on: `pr/<number>`, a name `git check-ref-format --branch` accepts. It is
+ * created at the fetched head (`pullRequestRef(number)`) and is an ordinary branch afterwards.
+ */
+export const pullRequestBranch = (number: number) => `pr/${number}`;
+
 const missing = (error: unknown) => ['ENOENT', 'ENOTDIR', 'NotFoundError'].includes(errorCode(error) ?? '');
 
 /**
@@ -53,6 +60,7 @@ export async function runLocalOperation(root: FileSystemDirectoryHandle, operati
             }
             if (operation.kind === 'createBranch') {
                 let object: string;
+                if (operation.reuse && operation.at === undefined) throw new GitPanelError('invalid');
                 if (operation.at !== undefined) {
                     if (operation.fromRemote || !/^[0-9a-f]{40}$/.test(operation.at)) throw new GitPanelError('invalid');
                     object = await git.readCommit({...options, oid: operation.at})
@@ -66,7 +74,19 @@ export async function runLocalOperation(root: FileSystemDirectoryHandle, operati
                 } else {
                     object = await git.resolveRef({...options, ref: 'HEAD'}).catch(() => {throw new GitPanelError('unsupported');});
                 }
-                try {
+                let existing: string | undefined;
+                if (operation.reuse && (await git.listBranches(options)).includes(name)) {
+                    existing = await git.resolveRef({...options, ref: local});
+                    // Never move a branch the person may have recorded on: only the same commit is reused.
+                    if (existing !== object) throw new GitPanelError('pullRequestBranch');
+                }
+                if (existing === undefined) {
+                    // Git keeps branches as files under refs/heads, so `pr` and `pr/7` cannot both exist.
+                    const conflict = (await git.listBranches(options)).some(branch =>
+                        branch !== name && (name.startsWith(`${branch}/`) || branch.startsWith(`${name}/`)));
+                    if (conflict) throw new GitPanelError('branchConflict');
+                }
+                if (existing === undefined) try {
                     // The ref first: isomorphic-git's checkout of a missing branch would write tracking config.
                     await git.branch({...options, ref: name, object, checkout: false});
                 } catch (error) {

package/src/messages.ts

@@ -1,7 +1,7 @@
 export const messages = {
     en: {
         pullRequests: 'Pull requests', localChanges: 'Local changes',
-        title: 'Local Git', menu: 'Local Git…', close: 'Close', choose: 'Choose Repository…', refresh: 'Refresh',
+        title: 'Local Git', close: 'Close', choose: 'Choose Repository…', refresh: 'Refresh',
         empty: 'Choose an existing Git repository to inspect its files and history.',
         repository: 'Repository', project: 'Project folder', none: 'No project selected', root: 'Repository root',
         open: 'Open This Project', reload: 'Reload Project', up: 'Parent folder', browse: 'Choose a project inside this repository',
@@ -20,6 +20,10 @@ export const messages = {
         commitMessage: 'Write a message for this record.',
         switchUnsafe: 'Stop the project, and save or record (or undo) every change, before switching branches.',
         branchExists: 'A branch with this name already exists.',
+        branchConflict: 'This name clashes with an existing branch: Git cannot keep both a branch and another branch under its name followed by /, such as pr and pr/7. Rename or delete the other branch with Git, or choose another name.',
+        pullRequestBranch: 'The branch pr/<number> already exists with other records, so this version was not opened. The branch is left unchanged. Switch to it in Local changes, or rename or delete it with Git, then open the pull request here again.',
+        openedPullRequest: 'Opened pull request #{number} on the local branch {branch}. To go back, switch to {previous} in Local changes.',
+        openedPullRequestDetached: 'Opened pull request #{number} on the local branch {branch}. To go back, switch to another branch in Local changes.',
         locked: 'Another Git tool is working on this repository (a lock file, or a merge, cherry-pick, revert or rebase in progress). Try again after it finishes.',
         branchName: 'Git cannot use this name for a branch.',
         pullUnsafe: 'Stop the project, and save or undo unsaved edits and unrecorded changes, before getting changes from GitHub (pull).',
@@ -50,11 +54,12 @@ export const messages = {
         historyMore: 'Show more', historyLoading: 'Reading records…', historyFailed: 'Could not read the records.',
         historyActions: 'Actions', historyCreateHere: 'Create branch here…', historySwitch: 'Switch to {name}',
         historyCreateFromRemote: 'Create and switch to {name}', historyCopy: 'Copy commit ID', historyCopied: 'Copied the commit ID.',
-        historyCopyFailed: 'Could not copy the commit ID.', historyRefs: 'Branches', cancel: 'Cancel'
+        historyCopyFailed: 'Could not copy the commit ID.', historyRefs: 'Branches', cancel: 'Cancel',
+        branchMenu: 'Branches', openPanel: 'Open Local Git', newBranchItem: 'New Branch…', newBranchTitle: 'New Branch'
     },
     ja: {
         pullRequests: 'プルリクエスト', localChanges: 'ローカルの変更',
-        title: 'ローカル Git', menu: 'ローカル Git…', close: '閉じる', choose: 'リポジトリを選択…', refresh: '再取得',
+        title: 'ローカル Git', close: '閉じる', choose: 'リポジトリを選択…', refresh: '再取得',
         empty: '既存の Git リポジトリを選び、ファイルの状態と履歴を確認できます。',
         repository: 'リポジトリ', project: '作品フォルダ', none: '作品は未選択', root: 'リポジトリルート',
         open: 'この作品を開く', reload: '作品を再読込', up: '上のフォルダ', browse: 'リポジトリ内の作品を選択',
@@ -73,6 +78,10 @@ export const messages = {
         commitMessage: 'この記録の説明を書いてください。',
         switchUnsafe: 'ブランチを切り替える前に、実行を止め、すべての変更を保存して記録（または取り消し）してください。',
         branchExists: '同じ名前のブランチがすでにあります。',
+        branchConflict: 'この名前は既存のブランチとぶつかります。Git では、pr と pr/7 のように、あるブランチと、その名前に / を続けたブランチを両方は持てません。Git でもう一方の名前を変えるか消すか、別の名前にしてください。',
+        pullRequestBranch: 'ブランチ pr/<番号> が、別の記録を指してすでにあるため、この版を開きませんでした。ブランチはそのままです。「ローカルの変更」で切り替えるか、Git で名前を変えるか消してから、もう一度ここで開いてください。',
+        openedPullRequest: 'プルリクエスト #{number} を、ローカルブランチ {branch} で開きました。戻るときは「ローカルの変更」で {previous} に切り替えてください。',
+        openedPullRequestDetached: 'プルリクエスト #{number} を、ローカルブランチ {branch} で開きました。戻るときは「ローカルの変更」で別のブランチに切り替えてください。',
         locked: 'ほかの Git の操作が、このリポジトリを使っています（ロックファイル、またはマージ・cherry-pick・revert・rebase の途中）。終わってから、もう一度試してください。',
         branchName: 'この名前は Git のブランチ名に使えません。',
         pullUnsafe: 'GitHub から取り込む前に、実行を止め、保存していない編集とまだ記録していない変更をなくしてください。',
@@ -103,7 +112,8 @@ export const messages = {
         historyMore: 'さらに表示', historyLoading: '記録を読込中…', historyFailed: '記録を読み込めませんでした。',
         historyActions: '操作', historyCreateHere: 'ここからブランチを作る…', historySwitch: '{name} に切り替える',
         historyCreateFromRemote: '{name} を作って切り替える', historyCopy: 'コミットの ID をコピー', historyCopied: 'コミットの ID をコピーしました。',
-        historyCopyFailed: 'コミットの ID をコピーできませんでした。', historyRefs: 'ブランチ', cancel: 'キャンセル'
+        historyCopyFailed: 'コミットの ID をコピーできませんでした。', historyRefs: 'ブランチ', cancel: 'キャンセル',
+        branchMenu: 'ブランチ', openPanel: 'ローカル Git を開く', newBranchItem: '新しいブランチ…', newBranchTitle: '新しいブランチ'
     }
 };
 export type Labels = typeof messages.en;