@young1lin/dsh-ui-gitworkbench 0.1.10 → 0.1.12

package/src/client/WorktreeGlyph.tsx

@@ -0,0 +1,24 @@
+import type { ReactNode } from 'react'
+import css from './GitWorkbenchPanel.module.css'
+
+/**
+ * Tree glyph: a root with two working copies hanging off it.
+ *
+ * This was git's fork glyph — the three-dot branch symbol — which named the
+ * wrong thing. A worktree is not a branch; the picker beside it is already full
+ * of branch names, and the two ideas need to stay tellable apart at 12px. A
+ * hierarchy reads as "one repository, several directories", which is what a
+ * worktree list is.
+ */
+export function WorktreeGlyph(): ReactNode {
+  return (
+    <svg className={css.cardGlyph} width="12" height="12" viewBox="0 0 16 16" fill="currentColor" aria-hidden="true">
+      {/* Trunk down from the root, and the two limbs it puts out. */}
+      <path d="M2.25 2.75h1.5v10.5h-1.5zM3 6.75h7.25v1.5H3zM3 11.75h7.25v1.5H3z" />
+      {/* The root, then the worktrees. */}
+      <circle cx="3" cy="2.75" r="1.75" />
+      <circle cx="12" cy="7.5" r="1.75" />
+      <circle cx="12" cy="12.5" r="1.75" />
+    </svg>
+  )
+}

package/src/client/diff-nav.ts

@@ -58,6 +58,20 @@ export interface BlockTop {
   readonly top: number
 }
 
+/** The change nearest a viewport position, used to retain the reader's place
+ * when the right diff grid becomes a dense editor. */
+export function blockNearestTo(anchors: readonly BlockTop[], top: number): BlockTop | null {
+  let nearest: BlockTop | null = null
+  let distance = Number.POSITIVE_INFINITY
+  for (const anchor of anchors) {
+    const next = Math.abs(anchor.top - top)
+    if (next >= distance) continue
+    nearest = anchor
+    distance = next
+  }
+  return nearest
+}
+
 /**
  * The content position that counts as "where the reader is".
  *
@@ -116,6 +130,13 @@ export function anchorFrom(
   return anchorFor(scrollTop)
 }
 
+/** The adjacent explicit editor selection, wrapping at both ends. */
+export function stepBlockIndex(totalBlocks: number, currentBlock: number, direction: 1 | -1): number | null {
+  if (totalBlocks <= 0) return null
+  const current = Number.isInteger(currentBlock) && currentBlock >= 0 && currentBlock < totalBlocks ? currentBlock : 0
+  return (current + direction + totalBlocks) % totalBlocks
+}
+
 /**
  * The next or previous change block, wrapping at the ends.
  *
@@ -224,3 +245,41 @@ export function blockTopsFromRows(
   }
   return tops
 }
+
+/**
+ * Place change blocks in one dense side of an aligned diff.
+ *
+ * Edit mode removes alignment holes: the working-tree CodeMirror has one row
+ * per real right-side line. A deletion-only block has no line on that side, so
+ * it sits at the following line's insertion point, or just after the final
+ * present line when the deletion reaches EOF.
+ */
+export function blockTopsFromSideRows(
+  rows: readonly import('./side-rows.ts').SideRow[],
+  side: 'left' | 'right',
+  rowH: number,
+  offset = 0,
+): readonly BlockTop[] {
+  const nextLine: Array<number | undefined> = new Array(rows.length)
+  let following: number | undefined
+  for (let i = rows.length - 1; i >= 0; i -= 1) {
+    const cell = rows[i]![side]
+    if (cell !== null) following = cell.line
+    nextLine[i] = following
+  }
+
+  const tops: BlockTop[] = []
+  const seen = new Set<number>()
+  let previous = 0
+  for (let i = 0; i < rows.length; i += 1) {
+    const row = rows[i]!
+    const cell = row[side]
+    if (row.block >= 0 && !seen.has(row.block)) {
+      seen.add(row.block)
+      const line = cell?.line ?? nextLine[i] ?? previous + 1
+      tops.push({ block: row.block, top: offset + Math.max(0, line - 1) * rowH })
+    }
+    if (cell !== null) previous = cell.line
+  }
+  return tops
+}

package/src/client/git-workbench-types.ts

@@ -0,0 +1,252 @@
+/** Shared JSON-safe contracts between the panel, feature views, and RPC adapters. */
+
+export type GitFileStatus = 'added' | 'deleted' | 'modified' | 'renamed' | 'untracked'
+
+export interface GitFile {
+  readonly path: string
+  readonly status: GitFileStatus
+  readonly addedLines: number
+  readonly deletedLines: number
+  readonly binary: boolean
+  readonly previousPath?: string
+  /**
+   * Which side of the index this file's change is on. Both can be true — a file
+   * staged and then edited again. Absent outside the working-tree view: a
+   * commit's files were staged long ago and the question is meaningless.
+   */
+  readonly staged?: boolean
+  readonly unstaged?: boolean
+}
+
+export interface GitCommit {
+  readonly hash: string
+  readonly subject: string
+  readonly when: string
+  /** Everything after the subject. Empty string when the commit has none. */
+  readonly body: string
+  /** Author name (`%an`). Optional only because a pre-0.1.4 host half sends none. */
+  readonly authorName?: string
+  /** Committer name (`%cn`); equals the author except on rebases and patches a maintainer applied. */
+  readonly committerName?: string
+  /** Committer date, strict ISO 8601 (`%cI`) — the exact moment `when` summarizes. */
+  readonly dateIso?: string
+  /** Abbreviated parent hashes, first parent first — the graph's edges. */
+  readonly parents?: readonly string[]
+  /** Branch and tag names pointing here, already stripped of git's decoration syntax. */
+  readonly refs?: readonly string[]
+}
+
+export interface WorkbenchStats {
+  readonly worktreePath: string
+  readonly branch: string
+  readonly ahead: number
+  readonly behind: number
+  readonly detached: boolean
+  readonly addedLines: number
+  readonly deletedLines: number
+  readonly addedFiles: number
+  readonly deletedFiles: number
+  readonly modifiedFiles: number
+  readonly files: readonly GitFile[]
+  readonly diff: string
+  /**
+   * Commits this view is about: the single commit for a commit view, the range's
+   * commits for a comparison. Empty for the working tree — the history list
+   * loads its own pages so it can follow a ref of its own.
+   */
+  readonly commits: readonly GitCommit[]
+  readonly error?: string
+}
+
+/** One worktree of the repository, as `git worktree list --porcelain` reports it. */
+export interface WorktreeEntry {
+  readonly path: string
+  readonly head: string
+  readonly branch: string
+}
+
+/** The session's worktree binding, as persisted by the worktree tools. */
+export interface WorktreeBinding {
+  readonly repoRoot: string
+  readonly worktreePath: string
+  readonly name: string
+  readonly enteredAt: string
+  readonly baseCommit?: string
+}
+
+/**
+ * `gitWorkbench/worktreeStatus`: the session's binding (null when unbound) plus every
+ * worktree of the surrounding repository. Git allows at most one worktree per
+ * branch, so this one list is both the worktree picker and the branch picker.
+ */
+export interface WorktreeStatus {
+  readonly binding: WorktreeBinding | null
+  readonly worktrees: readonly WorktreeEntry[]
+  /**
+   * Every local branch, most-recently-committed first. Distinct from
+   * {@link worktrees} on purpose: a branch without a worktree has no directory
+   * to read, so it can be browsed or compared but not viewed as a working tree.
+   */
+  readonly branches: readonly string[]
+  /** Whether the host cut {@link branches} short at its cap. */
+  readonly branchesTruncated: boolean
+}
+
+/**
+ * `gitWorkbench/syncStatus`: where the current branch stands against its upstream.
+ *
+ * `upstream: null` and "level with the upstream" are different states and the
+ * drawer treats them differently — the first is what makes the first push pass
+ * `--set-upstream`, and both otherwise read as zero ahead and zero behind.
+ */
+export interface SyncStatus {
+  readonly branch: string
+  readonly upstream: string | null
+  readonly ahead: number
+  readonly behind: number
+  readonly detached: boolean
+  /** Whether the repository has any remote at all. No remote, no sync bar. */
+  readonly hasRemote: boolean
+}
+
+/** Why a write operation failed, in terms the drawer can explain. `stale` is
+ *  a sha the host re-derived and refused; `invalid` an argument combination
+ *  the host rejected before running anything. */
+export type GitOpFailure =
+  | 'auth' | 'network' | 'no-upstream' | 'diverged' | 'conflict'
+  | 'nothing-to-commit' | 'dirty' | 'stale' | 'invalid' | 'unknown'
+
+export interface GitOpResult {
+  readonly ok: boolean
+  readonly failure?: GitOpFailure
+  /** git's own message on failure. Shown verbatim: a classification is a hint. */
+  readonly error?: string
+  readonly output?: string
+}
+
+/** The host endpoints under `gitWorkbench/` that change something. */
+export type GitOpName = 'stage' | 'unstage' | 'commit' | 'fetch' | 'pull' | 'push' | 'discardFile' | 'applyBlocks'
+
+/** Extra arguments an operation needs beyond the worktree path. */
+export interface GitOpPayload {
+  readonly paths?: readonly string[]
+  readonly message?: string
+  readonly amend?: boolean
+  /** `pull` picks how to integrate; `applyBlocks` which block mutation. One
+   *  field serves both because the payload is a flat bag keyed by op — the
+   *  host narrows and validates it per endpoint. */
+  readonly mode?: 'ff-only' | 'rebase' | 'merge' | BlockMode
+  /** `discardFile` and `applyBlocks`, and deliberately singular: the one
+   *  irreversible thing the drawer does takes one file per call, so a mistaken
+   *  click costs one file. */
+  readonly path?: string
+  /** `discardFile` only: the effect the confirmation stated. The host refuses
+   *  if the file changed underneath the dialog and now means something else. */
+  readonly expectedEffect?: string
+  /** `applyBlocks` only: the layer whose diff the `diffSha` is over, and the
+   *  block's hunk-line indices (`side-rows.blockLines`). The host re-fetches
+   *  that layer's diff and refuses unless the sha still matches. */
+  readonly layer?: SideLayer
+  readonly diffSha?: string
+  readonly lines?: readonly number[]
+}
+
+export type { DiscardAnswer, DiscardNext, DiscardPreview } from './discard-flow.ts'
+export type { WriteResult } from './side-edit.ts'
+
+/** Which side of the index a side-by-side pane shows: `unstaged` is
+ *  index→worktree (the editable side), `staged` is HEAD→index (read-only). */
+export type SideLayer = 'unstaged' | 'staged'
+
+/** A block mutation the side pane's buttons request: `stage` and `discard` act
+ *  on the unstaged layer, `unstage` on the staged one. The host enforces the
+ *  same matrix. */
+export type BlockMode = 'stage' | 'unstage' | 'discard'
+
+/**
+ * What one block action acts on, snapshotted from the diff the pane had
+ * rendered when the click (or its confirmation) happened.
+ *
+ * The snapshot is the point: `diffSha` proves the file has not changed since
+ * the pane rendered it, and `lines` — the block's hunk-line indices — only
+ * mean anything against exactly that diff. A confirmed roll-back carries the
+ * ask it opened with, so the answer cannot drift under the dialog.
+ */
+export interface BlockAsk {
+  readonly path: string
+  readonly layer: SideLayer
+  readonly diffSha: string
+  readonly lines: readonly number[]
+  /** The block's line tallies, for the roll-back confirmation's wording. */
+  readonly added: number
+  readonly deleted: number
+  /** Whether the block is the file's entire content — the untracked case,
+   *  whose roll-back DELETES the file and whose confirmation says so. */
+  readonly wholeFile: boolean
+}
+
+/**
+ * `gitWorkbench/fileSides`: one layer of one file for the side-by-side pane.
+ * Mirrors the host's `FileSides` (the client re-declares host shapes rather
+ * than importing the host module, which pulls node and the RPC decorators).
+ */
+export interface FileSides {
+  /** Unified diff at full context; '' when the layer has no change. */
+  readonly diff: string
+  /** sha1 of `diff`, echoed back by mutations to prove the same snapshot. */
+  readonly diffSha: string
+  /** Whole right-hand text, the editor's initial buffer. */
+  readonly targetText: string
+  /** Blob sha of the right-hand side; '' when it does not exist. */
+  readonly targetSha: string
+  readonly binary: boolean
+  /** True when the file is past the size guard; the client shows the old view. */
+  readonly tooLarge: boolean
+  /** True when the working-tree file is not valid UTF-8; the pane shows the
+   *  diff but withholds the editor. Optional so an older host half reads as
+   *  "fine" rather than as a refusal this client cannot explain. */
+  readonly lossyEncoding?: boolean
+}
+
+/**
+ * `gitWorkbench/fileImage`: one working-tree file's bytes, when the host's
+ * signature check confirms they are an image a browser can draw.
+ *
+ * Every field is present in both outcomes — an image and a refusal — because
+ * the gateway's payloads carry no `undefined`. `reason` is '' exactly when
+ * `ok`, and names the refusal otherwise: 'notImage', 'tooLarge', 'missing'.
+ */
+export interface FileImage {
+  readonly ok: boolean
+  /** MIME type to label the blob with; '' when declined. */
+  readonly mime: string
+  /** Short label for the caption — 'PNG', 'WebP', 'SVG'; '' when declined. */
+  readonly kind: string
+  /** The whole file, base64; '' when declined. */
+  readonly base64: string
+  /** The file's size in bytes, reported either way. */
+  readonly bytes: number
+  readonly reason: string
+}
+
+/** One line's provenance, as `gitWorkbench/blame` reports it. */
+export interface BlameLine {
+  /** Full commit sha; all zeros for a line not committed yet. */
+  readonly hash: string
+  readonly author: string
+  /** Author time, unix seconds; 0 when git did not say. */
+  readonly time: number
+  readonly summary: string
+  readonly uncommitted: boolean
+}
+
+/** `gitWorkbench/blame`'s answer. `error` is present only on failure. */
+export interface BlameAnswer {
+  readonly lines: readonly BlameLine[]
+  /** Whether the file was longer than the gutter's cap. */
+  readonly truncated: boolean
+  readonly error?: string
+}
+
+/** Translate a key of this plugin's namespace, with optional `{name}` params. */
+export type Translate = (key: string, params?: Record<string, string | number>) => string

package/src/client/locales.ts

@@ -28,7 +28,7 @@ export type WorkbenchKey =
   | 'filesUnsavedAsk' | 'filesDiscardOpen' | 'filesMore' | 'filesVanished' | 'fileReadOnlyCrlf' | 'fileReadOnlyEncoding'
   | 'blameWhileEditing' | 'blameLine' | 'blamePick' | 'blameInHistory'
   | 'imageBroken' | 'imageFit' | 'imageActual' | 'imageTooLarge' | 'imageSource' | 'imagePreview'
-  | 'prevChange' | 'nextChange' | 'prevChangeHint' | 'nextChangeHint' | 'changeCount'
+  | 'prevChange' | 'nextChange' | 'prevChangeHint' | 'nextChangeHint' | 'changeCount' | 'changePosition'
   | 'sourceLabel' | 'workingTree'
   | 'loadingCommit' | 'renamedFrom' | 'binaryFile' | 'loadingDiff' | 'noTextDiff'
   | 'noCommits' | 'historyLabel' | 'historyEnd' | 'loading' | 'maximize' | 'restore'
@@ -62,7 +62,7 @@ export type WorkbenchKey =
   | 'discardAction' | 'discardTitle' | 'discardConfirm' | 'discardCancel'
   | 'discardBodyRestore' | 'discardBodyDelete' | 'discardBodyUnrename'
   // side-by-side block actions: the three buttons and the roll-back confirmation's wording
-  | 'blockStage' | 'blockDiscard' | 'blockUnstage' | 'blockDiscardBody' | 'blockDiscardBodyDelete'
+  | 'blockStage' | 'blockDiscard' | 'blockUnstage' | 'fileUnstage' | 'blockActionsDirty' | 'blockDiscardBody' | 'blockDiscardBodyDelete'
   // side-by-side editing: arm the editor, save, revert, the stale/conflict
   // banner, the CRLF refusal notice, and the unsaved-changes prompt that
   // guards every gesture dropping the buffer (tab, file, close)
@@ -171,6 +171,7 @@ export const zh: Record<WorkbenchKey, string> = {
   prevChangeHint: '上一处变更（Shift+F7）',
   nextChangeHint: '下一处变更（F7）',
   changeCount: '变更 {n} 处',
+  changePosition: '第 {current} / {total} 处变更',
   loadingDiff: '加载 diff…',
   noTextDiff: '无文本差异',
   // The side-by-side pane's layer tabs: unstaged is index→worktree, staged is
@@ -267,9 +268,11 @@ export const zh: Record<WorkbenchKey, string> = {
   discardBodyUnrename: '撤销重命名：{path} 改回 {previousPath}，改名期间的内容改动一并丢弃。',
   // One BLOCK, not the whole file: the side pane's roll-back states exactly
   // which lines leave and that the working-tree file is rewritten to do it.
-  blockStage: '暂存这块',
-  blockDiscard: '撤回这块',
-  blockUnstage: '取消暂存这块',
+  blockStage: '暂存此变更块',
+  blockDiscard: '恢复此变更块',
+  blockUnstage: '取消暂存此变更块',
+  fileUnstage: '取消暂存整个文件',
+  blockActionsDirty: '请先保存或放弃编辑器修改，再操作当前变更块',
   blockDiscardBody: '{path} 的这一块改动（{added} 行新增、{deleted} 行删除）将被撤回，工作区文件随之改写，无法找回。',
   // The untracked case: the file's whole content is the one block, so rolling
   // the block back reverse-applies the new-file patch and DELETES the file —
@@ -408,6 +411,7 @@ export const en: Record<WorkbenchKey, string> = {
   prevChangeHint: 'Previous change (Shift+F7)',
   nextChangeHint: 'Next change (F7)',
   changeCount: 'changes: {n}',
+  changePosition: 'change {current} / {total}',
   loadingDiff: 'Loading diff…',
   noTextDiff: 'No text changes',
   tabUnstaged: 'Unstaged',
@@ -489,9 +493,11 @@ export const en: Record<WorkbenchKey, string> = {
   discardBodyUnrename: 'Undo the rename: {path} goes back to {previousPath}, and content changed along the way is lost.',
   // One BLOCK, not the whole file: the side pane's roll-back states exactly
   // which lines leave and that the working-tree file is rewritten to do it.
-  blockStage: 'Stage block',
-  blockDiscard: 'Roll back block',
-  blockUnstage: 'Unstage block',
+  blockStage: 'Stage hunk',
+  blockDiscard: 'Revert hunk',
+  blockUnstage: 'Unstage hunk',
+  fileUnstage: 'Unstage file',
+  blockActionsDirty: 'Save or discard editor changes before operating on this hunk.',
   blockDiscardBody: 'This block of {path} ({added} added, {deleted} deleted lines) is rolled back and the working-tree file rewritten to do it. This cannot be undone.',
   // The untracked case: the file's whole content is the one block, so rolling
   // the block back reverse-applies the new-file patch and DELETES the file —

package/src/client/row-window.ts

@@ -72,6 +72,29 @@ export interface RowWindow {
   readonly padBottom: number
 }
 
+/** Whether two windows paint the same rows AND reserve the same total height.
+ * Comparing only start/end leaves a previous file's bottom spacer behind when
+ * two long files happen to expose the same viewport-sized row range. */
+export function sameRowWindow(a: RowWindow, b: RowWindow): boolean {
+  return a.start === b.start && a.end === b.end
+    && a.padTop === b.padTop && a.padBottom === b.padBottom
+}
+
+/** A rendered window is reusable only for the exact mounted diff. Equal-length
+ * files can be at different scroll positions, so row count alone is not an identity. */
+export interface HeldRowWindow {
+  readonly mountKey: string
+  readonly rowCount: number
+  readonly win: RowWindow
+}
+
+/** Return the held window when it belongs to this diff, otherwise a fresh top window. */
+export function rowWindowForMount(held: HeldRowWindow, rowCount: number, mountKey: string): RowWindow {
+  return held.rowCount === rowCount && held.mountKey === mountKey
+    ? held.win
+    : rowWindow(0, 0, rowCount)
+}
+
 /**
  * @param value - a number from the DOM, which can be NaN or negative.
  * @param fallback - used when it is neither finite nor usable.

package/src/client/side-rows.ts

@@ -174,6 +174,17 @@ export function blockLines(rows: readonly SideRow[], block: number): readonly nu
   return [...indices].sort((a, b) => a - b)
 }
 
+/** Every changed hunk-line index, for a whole-layer Stage/Unstage action. */
+export function allBlockLines(rows: readonly SideRow[]): readonly number[] {
+  const indices = new Set<number>()
+  for (const row of rows) {
+    if (row.block < 0) continue
+    if (row.leftIndex !== -1) indices.add(row.leftIndex)
+    if (row.rightIndex !== -1) indices.add(row.rightIndex)
+  }
+  return [...indices].sort((a, b) => a - b)
+}
+
 /**
  * How many change blocks the rows hold.
  *
@@ -186,6 +197,49 @@ export function blockCount(rows: readonly SideRow[]): number {
   return max + 1
 }
 
+export type BlockEdge = 'single' | 'first' | 'middle' | 'last'
+
+/** Where one present side-cell sits on its block's visible perimeter. Absent
+ * cells return null: an addition-only block must not draw a blue cage through
+ * the empty left pane, and a deletion-only block does the symmetric thing. */
+export function blockEdge(rows: readonly SideRow[], index: number, side: 'left' | 'right'): BlockEdge | null {
+  const row = rows[index]
+  if (row === undefined || row.block < 0 || row[side] === null) return null
+  const before = index > 0 && rows[index - 1]!.block === row.block && rows[index - 1]![side] !== null
+  const after = index + 1 < rows.length && rows[index + 1]!.block === row.block && rows[index + 1]![side] !== null
+  if (!before && !after) return 'single'
+  if (!before) return 'first'
+  return after ? 'middle' : 'last'
+}
+
+/** The selected Git block exposed by the fixed pane toolbar. Visibility is
+ * independent of buffer dirtiness: the component keeps actions mounted and
+ * disables unsafe ones. A refreshed diff may carry fewer blocks, so an invalid
+ * selection safely falls back to the first one. */
+export function currentActionBlock(totalBlocks: number, actionsVisible: boolean, selectedBlock: number): number | null {
+  if (!actionsVisible || totalBlocks <= 0) return null
+  return Number.isInteger(selectedBlock) && selectedBlock >= 0 && selectedBlock < totalBlocks ? selectedBlock : 0
+}
+
+/** Git hunk operations wait for a clean editor buffer and for the prior Git
+ * operation to settle. This rule disables controls; it never hides them. */
+export function blockActionsDisabled(dirty: boolean, pendingBlock: number | null): boolean {
+  return dirty || pendingBlock !== null
+}
+
+/**
+ * Whether the first rendered row is already inside a change block.
+ *
+ * The block action bar normally floats one row above its first cell. When the
+ * file itself starts with a change there is no preceding row, so the columns
+ * must reserve that bar's clearance inside their own clipping boxes. This is
+ * derived from the full row model rather than hover state, avoiding a layout
+ * jump when the pointer enters line 1.
+ */
+export function needsFirstBlockClearance(rows: readonly SideRow[]): boolean {
+  return rows.length > 0 && rows[0]!.block >= 0
+}
+
 /**
  * Whether a block is the file's ENTIRE content: the one block of a diff with
  * no context row at all.
@@ -256,3 +310,15 @@ export function blockTally(rows: readonly SideRow[], block: number): { readonly
   }
   return { added, deleted }
 }
+
+/** Whole-layer tallies, paired with {@link allBlockLines}. */
+export function allBlockTally(rows: readonly SideRow[]): { readonly added: number; readonly deleted: number } {
+  let added = 0
+  let deleted = 0
+  for (const row of rows) {
+    if (row.block < 0) continue
+    if (row.left !== null) deleted += 1
+    if (row.right !== null) added += 1
+  }
+  return { added, deleted }
+}