@kubohiroya/turbowarp-plus-editor-git 0.9.0 → 0.11.0

package/src/pull-request-panel.tsx

@@ -4,6 +4,7 @@ import type {GitHubPullRequests} from './github-pull-requests.js';
 import {ProjectSourceReview} from './project-source-review.js';
 import type {ProjectBlockRenderer} from './scratch-block-diff-renderer.js';
 import type {Repository} from './repository.js';
+import type {ProjectBlockLocator} from './block-diff-location.js';
 
 const en = {
     title: 'Pull requests', number: 'Pull request number', openNumber: 'Open pull request',
@@ -37,8 +38,9 @@ type Result<T> = {data: T; error?: never} | {data?: never; error: string};
 type Listing = Awaited<ReturnType<GitHubPullRequests['list']>>;
 type Pull = Awaited<ReturnType<GitHubPullRequests['load']>>;
 
-function PullRequests({name, labels, locale, renderBlock}: {
+function PullRequests({name, labels, locale, renderBlock, locateFor}: {
     name: string; labels: typeof en; locale: string; renderBlock: ProjectBlockRenderer;
+    locateFor?(path: string, headSha: string): ProjectBlockLocator | undefined;
 }) {
     const client = useMemo(() => createGitHubPullRequests(name), [name]);
     const [page, setPage] = useState(1);
@@ -108,14 +110,17 @@ function PullRequests({name, labels, locale, renderBlock}: {
                     <code title={pr.head.sha}>{pr.head.ref} → {pr.base.ref}</code>
                     <a href={pr.url} target="_blank" rel="noreferrer">{labels.onGitHub}</a>
                 </p>
-                <ProjectSourceReview title={pr.title} description={pr.description} files={pr.files} renderBlock={renderBlock} locale={locale}/>
+                <ProjectSourceReview title={pr.title} description={pr.description} files={locateFor ? pr.files.map(file => 'patch' in file ? {...file, locateBlock: locateFor(file.path, pr.head.sha)} : file) : pr.files}
+                    renderBlock={renderBlock} locale={locale}/>
             </>}
         </main>
     </div>;
 }
 
-export function PullRequestReviewPanel({repository, locale, renderBlock}: {
+export function PullRequestReviewPanel({repository, locale, renderBlock, locateFor}: {
     repository: Repository; locale: string; renderBlock: ProjectBlockRenderer;
+    /** Returns a locator for a project file whose PR head matches the open project, or `undefined`. */
+    locateFor?(path: string, headSha: string): ProjectBlockLocator | undefined;
 }) {
     const labels = locale.startsWith('ja') ? ja : en;
     const [origin, setOrigin] = useState<{repository: Repository; name: string | null; failed?: boolean}>();
@@ -130,5 +135,5 @@ export function PullRequestReviewPanel({repository, locale, renderBlock}: {
     }, [repository]);
     if (origin?.repository !== repository) return <p role="status" className="twgit-context">{labels.loading}</p>;
     if (!origin.name) return <p className="twgit-context" role="status">{origin.failed ? labels.failed : labels.noOrigin}</p>;
-    return <PullRequests key={origin.name} name={origin.name} labels={labels} locale={locale} renderBlock={renderBlock}/>;
+    return <PullRequests key={origin.name} name={origin.name} labels={labels} locale={locale} renderBlock={renderBlock} locateFor={locateFor}/>;
 }

package/src/repository.ts

@@ -45,6 +45,21 @@ export interface Snapshot {
     metadata: Metadata;
     /** Size and time fingerprint taken before the read. Compare it with `probe(scope)` to see later changes. */
     probe: string;
+    /**
+     * How the current branch stands against `refs/remotes/origin/<branch>` as of the last fetch, from local refs only.
+     * `unknown` when there is no current branch or no tracking ref yet.
+     */
+    upstream: UpstreamRelation;
+}
+export interface UpstreamRelation {
+    state: 'same' | 'ahead' | 'behind' | 'diverged' | 'unknown';
+    /**
+     * Commits on the local branch that the tracking branch lacks, and the reverse. Zero when unknown. Counting reads at
+     * most `upstreamWalkLimit` (1000) commits; past that, a side that has commits of its own reports exactly that limit,
+     * meaning "this many or more". The state itself comes from the merge base and stays exact.
+     */
+    ahead: number;
+    behind: number;
 }
 export interface FileDiff {
     binary: boolean;
@@ -63,6 +78,9 @@ const textLimit = 1024 * 1024;
 const inScope = (path: string, scope: string) => !scope || path === scope || path.startsWith(scope + '/');
 // Above this many work-tree files, probes only watch Git metadata. Edits then need a manual refresh.
 const probeLimit = 5000;
+/** Most commits read to count how far a branch is ahead of or behind its tracking branch. */
+export const upstreamWalkLimit = 1000;
+const trackingRef = (branchRef: string) => 'refs/remotes/origin/' + branchRef.slice('refs/heads/'.length);
 const sameMetadata = (a: Metadata, b: Metadata) => a.size === b.size && [...a].every(([path, bytes]) => sameBytes(bytes, b.get(path) ?? null));
 
 export async function openRepository(root: FileSystemDirectoryHandle) {
@@ -89,7 +107,7 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
         if (text.startsWith('ref: refs/heads/')) {
             const ref = text.slice(5);
             pathParts(ref);
-            paths.push('/.git/' + ref);
+            paths.push('/.git/' + ref, '/.git/' + trackingRef(ref));
         } else if (!/^[0-9a-f]{40}$/.test(text)) throw new GitPanelError('invalid');
         const result: Metadata = new Map();
         for (const path of paths) {
@@ -124,7 +142,7 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
         const paths = ['.git/HEAD', '.git/index', '.git/packed-refs', '.git/shallow', '.git/config'];
         if (head.startsWith('ref: refs/heads/')) {
             try {pathParts(head.slice(5));} catch {return 'locked';}
-            paths.push('.git/' + head.slice(5));
+            paths.push('.git/' + head.slice(5), '.git/' + trackingRef(head.slice(5)));
         }
         const lines: string[] = [];
         for (const path of paths) {
@@ -169,6 +187,60 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
         }) as {path: string; oid: string; mode: number}[];
         return new Map(result.map(({path, oid, mode}) => [path, {oid, mode}]));
     };
+    /**
+     * Compares `refs/heads/<branch>` with `refs/remotes/origin/<branch>` from local refs only. Counts by painting
+     * commits from both tips in committer-time order until every queued commit is reachable from both, like
+     * `git rev-list --left-right --count`, reading at most `upstreamWalkLimit` commits.
+     */
+    const upstreamRelation = async (branch: string | undefined, head: string | null): Promise<UpstreamRelation> => {
+        const unknown: UpstreamRelation = {state: 'unknown', ahead: 0, behind: 0};
+        if (!branch || !head) return unknown;
+        pathParts(trackingRef('refs/heads/' + branch));
+        try {
+            const remote = await git.resolveRef({...options, ref: trackingRef('refs/heads/' + branch)});
+            if (remote === head) return {state: 'same', ahead: 0, behind: 0};
+            const bases = await git.findMergeBase({...options, cache, oids: [head, remote]}) as string[];
+            const hasAhead = !bases.includes(head), hasBehind = !bases.includes(remote);
+            const local = 1, tracking = 2, both = 3;
+            const flags = new Map<string, number>([[head, local], [remote, tracking]]);
+            const time = async (oid: string) => (await git.readCommit({...options, cache, oid})).commit;
+            const queue: {oid: string; time: number; parents: string[]}[] = [];
+            const enqueue = async (oid: string) => {
+                const commit = await time(oid);
+                queue.push({oid, time: commit.committer.timestamp, parents: commit.parent});
+            };
+            await enqueue(head); await enqueue(remote);
+            let read = 2;
+            let complete = true;
+            while (queue.some(item => flags.get(item.oid) !== both)) {
+                if (read >= upstreamWalkLimit) {complete = false; break;}
+                queue.sort((a, b) => b.time - a.time);
+                const item = queue.shift()!;
+                const flag = flags.get(item.oid)!;
+                for (const parent of item.parents) {
+                    const previous = flags.get(parent) ?? 0;
+                    if ((previous | flag) === previous) continue;
+                    flags.set(parent, previous | flag);
+                    if (!queue.some(entry => entry.oid === parent)) {await enqueue(parent); read++;}
+                }
+            }
+            let ahead = 0, behind = 0;
+            for (const flag of flags.values()) {
+                if (flag === local) ahead++;
+                else if (flag === tracking) behind++;
+            }
+            if (!complete) {
+                ahead = hasAhead ? upstreamWalkLimit : 0;
+                behind = hasBehind ? upstreamWalkLimit : 0;
+            }
+            return {state: hasAhead && hasBehind ? 'diverged' : hasAhead ? 'ahead' : hasBehind ? 'behind' : 'same',
+                ahead: hasAhead ? Math.max(ahead, 1) : 0, behind: hasBehind ? Math.max(behind, 1) : 0};
+        } catch (error) {
+            // No tracking ref yet, or history missing from a shallow clone.
+            if (errorCode(error) === 'NotFoundError') return unknown;
+            throw error;
+        }
+    };
     const assertSnapshot = async (snapshot: Snapshot) => {
         if (!sameMetadata(snapshot.metadata, await metadata())) throw new GitPanelError('changed');
     };
@@ -189,6 +261,7 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
         const commits = head ? (await git.log({...options, cache, ref: head, depth: 50})).map(({oid, commit}) => ({
             oid, message: commit.message, author: commit.author.name, timestamp: commit.author.timestamp
         })) : [];
+        const upstream = await upstreamRelation(branch || undefined, head);
         const matrix = await git.statusMatrix({...options, cache, refresh: false, filepaths: [scope || '.']});
         const staged = await entries(null, scope);
         const committed = await entries(head || emptyTree, scope);
@@ -210,7 +283,7 @@ export async function openRepository(root: FileSystemDirectoryHandle) {
         }
         if (!sameMetadata(before, await metadata())) throw new GitPanelError('changed');
         await fs.checkReads();
-        return {branch: branch || undefined, head, branches, commits, changes, scope, metadata: before, probe: fingerprint};
+        return {branch: branch || undefined, head, branches, commits, changes, scope, metadata: before, probe: fingerprint, upstream};
     };
     const historyChanges = async (snapshot: Snapshot, oid: string): Promise<FileChange[]> => {
         fs.clearReads();

package/src/style.css

@@ -8,14 +8,24 @@
 .twgit-panel button:focus-visible, .twgit-panel summary:focus-visible { outline: 2px solid Highlight; outline-offset: 2px; }
 .twgit-panel button[aria-pressed="true"] { color: HighlightText; background: Highlight; }
 .twgit-context { display: flex; gap: 8px 20px; flex-wrap: wrap; padding: 8px 16px; }
-.twgit-connection { margin: 0 16px 8px; max-height: 45%; overflow: auto; }
+.twgit-context { align-items: center; }
+.twgit-connection, .twgit-git-details { position: relative; }
+.twgit-connection > summary, .twgit-git-details > summary { cursor: pointer; }
+/* Settings and Git details open over the list, so the list and the diff stay where they are. */
+.twgit-connection-body { position: absolute; z-index: 5; top: calc(100% + 4px); left: 0; width: min(440px, 80vw); max-height: 60vh;
+    overflow: auto; padding: 10px 12px; background: Canvas; color: CanvasText; border: 1px solid GrayText; border-radius: 6px;
+    box-shadow: 0 8px 24px #0004; }
+.twgit-connection-body > p { margin: 4px 0; overflow-wrap: anywhere; }
+.twgit-sync { display: inline-flex; flex-wrap: wrap; gap: 4px; }
+.twgit-change-kind { display: inline-block; min-width: 2.6em; font-size: 11px; opacity: .8; }
+.twgit-file-details { font-size: 12px; margin-bottom: 6px; }
+.twgit-file-details > p { margin: 2px 0; }
 .twgit-content { display: grid; grid-template-columns: minmax(230px, 30%) minmax(0, 1fr); flex: 1; min-height: 0; }
 .twgit-panel aside { padding: 0 14px 14px; overflow: auto; border-right: 1px solid GrayText; }
 .twgit-panel aside ul { list-style: none; padding: 0; margin: 4px 0; }
 .twgit-panel aside li { overflow-wrap: anywhere; }
 .twgit-panel summary { cursor: pointer; }
 .twgit-panel .twgit-file { width: 100%; border: 0; margin: 1px 0; }
-.twgit-file span { display: inline-block; width: 1.4em; font-family: monospace; }
 .twgit-diff { padding: 0 16px 16px; min-width: 0; overflow: auto; }
 .twgit-diff .diff { font-size: 12px; }
 .twgit-history { list-style: none; margin: 0; padding: 0; }
@@ -44,3 +54,6 @@
 .twgit-element-values td { font-family: ui-monospace, monospace; }
 .twgit-element-files { margin-top: 12px; }
 .twgit-panel .twgit-element span.twgit-element-name { width: auto; font-family: inherit; }
+.twgit-git-details > .twgit-connection-body { left: auto; right: 0; }
+/* In a layout tab the panel fills the tab and leaves the Editor beside it. */
+.twgit-panel.twgit-panel-tab { width: 100%; height: 100%; border: 0; border-radius: 0; box-shadow: none; }