@young1lin/dsh-ui-gitworkbench 0.1.2 → 0.1.4

package/src/client/active-file.ts

@@ -0,0 +1,83 @@
+/**
+ * Which file a view opens on.
+ *
+ * The drawer keeps ONE selected path across commits, so walking down a
+ * filtered history is meant to be a walk through one file's life. That only
+ * works if the fallback — what happens when the selection is not in the
+ * commit you just clicked — knows about the path filter. It did not: the
+ * fallback was `files[0]`, so filtering by `xx/aa/dd.ts` and clicking a
+ * commit opened whatever sorted first in that commit, and the file the
+ * filter was ABOUT sat unhighlighted somewhere down the tree.
+ *
+ * Pure and React-free so it can be tested; the panel only wires it up.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/active-file
+ */
+
+/** Just the field this module reads off the view's file list. */
+export interface PathLike {
+  readonly path: string
+}
+
+/** No filter — a shared empty so callers keep a stable reference. */
+export const NO_PATHS: readonly string[] = []
+
+/**
+ * Whether a file is what a pathspec selected: the file itself, or anything in
+ * its subtree.
+ *
+ * A pathspec from the picker is either a file path or a directory path with no
+ * trailing slash (`dir.path` / the file's full path — `path-select.ts`), and
+ * the two cases are told apart by the file rather than by the spec: `===` is
+ * the file, `spec + '/'` prefix is the subtree. Guessing which KIND a spec is
+ * from its string alone is what a trailing-slash convention would force, and
+ * it would be wrong for any file without an extension.
+ */
+function covers(spec: string, path: string): boolean {
+  return path === spec || path.startsWith(`${spec}/`)
+}
+
+/**
+ * The file a view should highlight.
+ *
+ * The order of preference, and why it is this order:
+ *
+ * 1. **The selection, if this view has it.** Stepping down a filtered list is
+ *    the whole point of filtering; changing the file under the reader every
+ *    time they move a row would undo it. This also means an explicit click
+ *    outranks the filter — the reader looked somewhere on purpose.
+ * 2. **A file the filter names EXACTLY.** Ticking `xx/aa/dd.ts` is a statement
+ *    about that file; ticking `xx` is a statement about a region. When a
+ *    commit touches both kinds, the named file is the more specific intent, so
+ *    it wins. (The two can only coexist across disjoint trees: the picker's
+ *    invariant is that no ticked path covers another.)
+ * 3. **A file under a filtered directory.**
+ * 4. **The first file.** No filter, or nothing in this commit matched it —
+ *    the behaviour before any of this existed.
+ *
+ * Ties inside 2 and 3 go to the commit's own file order, which is the order
+ * the tree renders: the highlight lands on the topmost matching row, so it is
+ * where the reader is already looking and never needs a scroll to find. The
+ * alternative — first match in FILTER order — would be arbitrary, since that
+ * order is an artifact of the sequence the boxes were ticked in and is never
+ * shown anywhere.
+ *
+ * @param files - the view's files, in the order the tree shows them.
+ * @param filterPaths - active path filter; empty on views that have none.
+ * @param previous - the currently selected path, or null.
+ * @returns the path to highlight, or null when there are no files at all.
+ */
+export function preferredFile(
+  files: readonly PathLike[],
+  filterPaths: readonly string[],
+  previous: string | null,
+): string | null {
+  if (previous !== null && files.some(file => file.path === previous)) return previous
+  if (filterPaths.length > 0) {
+    const exact = files.find(file => filterPaths.some(spec => file.path === spec))
+    if (exact !== undefined) return exact.path
+    const under = files.find(file => filterPaths.some(spec => covers(spec, file.path)))
+    if (under !== undefined) return under.path
+  }
+  return files[0]?.path ?? null
+}

package/src/client/calendar.ts

@@ -0,0 +1,99 @@
+/**
+ * The pure arithmetic of the filter's calendar.
+ *
+ * A month is a fixed 6×7 grid, Monday-first: a stable height whatever the
+ * month (no layout jump when February needs four rows), with neighbouring
+ * months' days filling the lead-in and tail — greyed, still clickable, the
+ * way every modern calendar behaves. Everything here is pure and takes
+ * `todayIso` explicitly so tests are deterministic.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/calendar
+ */
+
+/** One day cell. `null` where the grid has no day at all (never, at 6×7). */
+export interface CalendarCell {
+  /** The day, `yyyy-mm-dd` — the grammar the filter speaks end to end. */
+  readonly iso: string
+  /** Day-of-month number shown in the cell. */
+  readonly day: number
+  /** Whether the cell belongs to the displayed month. */
+  readonly inMonth: boolean
+  /** Whether the cell is the supplied today. */
+  readonly isToday: boolean
+}
+
+const DAY_MS = 86_400_000
+
+function toIso(date: Date): string {
+  const m = String(date.getUTCMonth() + 1).padStart(2, '0')
+  const d = String(date.getUTCDate()).padStart(2, '0')
+  return `${date.getUTCFullYear()}-${m}-${d}`
+}
+
+/**
+ * The 6×7 Monday-first grid for one month.
+ * @param year - displayed year.
+ * @param month - displayed month, 0-based like `Date`.
+ * @param todayIso - what counts as today, for the accent; `''` accents nothing.
+ */
+export function monthGrid(year: number, month: number, todayIso: string): readonly (readonly (CalendarCell | null)[])[] {
+  // Day 1 of the month, at a UTC midnight so arithmetic never drifts an hour.
+  const first = new Date(Date.UTC(year, month, 1))
+  // getUTCDay is Sunday=0; Monday-first offset.
+  const lead = (first.getUTCDay() + 6) % 7
+  const start = new Date(first.getTime() - lead * DAY_MS)
+  const weeks: (CalendarCell | null)[][] = []
+  for (let w = 0; w < 6; w += 1) {
+    const row: (CalendarCell | null)[] = []
+    for (let d = 0; d < 7; d += 1) {
+      const date = new Date(start.getTime() + (w * 7 + d) * DAY_MS)
+      const iso = toIso(date)
+      row.push({ iso, day: date.getUTCDate(), inMonth: date.getUTCMonth() === month, isToday: iso === todayIso })
+    }
+    weeks.push(row)
+  }
+  return weeks
+}
+
+/**
+ * Single-letter weekday header row, Monday-first, via the viewer's own locale
+ * (or an explicit one, which is what the test does).
+ * @param locale - BCP 47 tag; undefined means the runtime default.
+ */
+export function weekdayLabels(locale?: string): readonly string[] {
+  // 2023-01-02..08 is a Monday..Sunday — label those, whatever the locale.
+  const labels: string[] = []
+  for (let d = 2; d <= 8; d += 1) {
+    labels.push(new Intl.DateTimeFormat(locale, { weekday: 'narrow' }).format(new Date(Date.UTC(2023, 0, d))))
+  }
+  return labels
+}
+
+/**
+ * Whether a day falls strictly BETWEEN the two bounds, so the grid can tint
+ * the span the filter admits rather than only its two endpoints.
+ *
+ * Both bounds have to be `yyyy-mm-dd` for a range to exist: the bounds also
+ * accept approxidate text (`1 week ago`), which names no grid day at all, and
+ * lexical comparison on iso dates is the same as chronological. An inverted
+ * pair (after > before) is a range git returns nothing for, and it tints
+ * nothing here for the same reason.
+ *
+ * @param iso - the cell's day.
+ * @param after - lower bound, exclusive here (it renders as an endpoint).
+ * @param before - upper bound, exclusive here.
+ */
+export function inCalRange(iso: string, after: string, before: string): boolean {
+  if (!ISO_DAY.test(after) || !ISO_DAY.test(before)) return false
+  return iso > after && iso < before
+}
+
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/
+
+/** Today as `yyyy-mm-dd` in the viewer's local timezone (for `todayIso`). */
+export function localTodayIso(): string {
+  const now = new Date()
+  const m = String(now.getMonth() + 1).padStart(2, '0')
+  const d = String(now.getDate()).padStart(2, '0')
+  return `${now.getFullYear()}-${m}-${d}`
+}

package/src/client/commit-filter.ts

@@ -0,0 +1,49 @@
+/**
+ * Exact-date rendering for the history hover card.
+ *
+ * The rows stay compact — abbreviated hash, name, "3 weeks ago" — and the
+ * details live in the hover card. An exact date cannot be derived from git's
+ * relative "%cr" prose, so the host log format carries `%cI` alongside
+ * (`src/git-log.ts`); this module renders it in the viewer's own clock.
+ *
+ * (The person-name MATCHING that once lived here is retired: history
+ * filtering is compiled into git log arguments host-side — `log-filter.ts`,
+ * `log-filter-query.ts` — so it runs over all history, not the loaded pages.)
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/commit-filter
+ */
+
+/** Options for {@link formatCommitDate}; both default to the viewer's own. */
+export interface CommitDateOptions {
+  /** BCP 47 locale for the formatter; undefined means the runtime default. */
+  readonly locale?: string
+  /** IANA timezone; undefined means the viewer's local timezone. */
+  readonly timeZone?: string
+}
+
+/**
+ * Render a commit's ISO 8601 date in full — "Aug 4, 2026, 5:30 PM", in the
+ * viewer's locale and timezone (or the overrides, which exist for tests).
+ *
+ * git's relative prose ("3 weeks ago") is right for the row and useless for
+ * the hover card, where the question is exactly WHEN. `%cI` is a strict ISO
+ * timestamp, so `new Date` parses it and the formatter renders local time —
+ * the same moment the viewer's own clock shows, which is the only timezone a
+ * hover card should speak. Unparsable input yields an empty string rather
+ * than a thrown RangeError: the card simply omits the line.
+ * @param iso - `%cI` string from the host log, possibly empty or absent.
+ * @param options - locale/timezone overrides; both optional.
+ */
+export function formatCommitDate(iso: string, options: CommitDateOptions = {}): string {
+  if (iso.length === 0) return ''
+  const date = new Date(iso)
+  if (Number.isNaN(date.getTime())) return ''
+  return new Intl.DateTimeFormat(options.locale, {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    ...(options.timeZone !== undefined ? { timeZone: options.timeZone } : {}),
+  }).format(date)
+}

package/src/client/dir-tree.ts

@@ -0,0 +1,112 @@
+/**
+ * Directory tree for the history filter's path picker, aggregated from a flat
+ * file list.
+ *
+ * The host sends `git ls-tree -r --name-only HEAD` verbatim; this module
+ * folds it into DIRECTORIES with their FILES as leaf rows — "when did this
+ * file change" is the question a file row answers, and it is the most common
+ * one. Everything is pure so the aggregation and the search are testable from
+ * a literal file list.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/dir-tree
+ */
+
+/** One directory in the picker. */
+export interface DirEntry {
+  readonly name: string
+  /** Repo-relative path — also the pathspec a tick produces. */
+  readonly path: string
+  /** Files in this SUBTREE — what ticking this row would match. */
+  readonly fileCount: number
+  /** File NAMES directly in this directory (leaf rows). */
+  readonly files: readonly string[]
+  /** Subdirectories, sorted by name. */
+  readonly children: readonly DirEntry[]
+}
+
+/** A mutable builder node; frozen into the readonly shape at the end. */
+interface BuildNode {
+  name: string
+  path: string
+  files: string[]
+  children: Map<string, BuildNode>
+}
+
+/**
+ * Fold a flat path list into a sorted directory tree carrying its files.
+ * Root-level files live on no directory; the SEARCH ({@link searchPaths}) is
+ * where they surface.
+ * @param paths - repo-relative file paths, any order, no duplicates assumed.
+ * @returns the top-level directories, children and files sorted by name.
+ */
+export function buildDirTree(paths: readonly string[]): readonly DirEntry[] {
+  const rootNode: BuildNode = { name: '', path: '', files: [], children: new Map() }
+  for (const path of paths) {
+    if (path.length === 0) continue
+    const parts = path.split('/')
+    // A trailing part is the file; every part before it must exist as a
+    // directory, whether or not any other file mentioned it.
+    let node = rootNode
+    for (let i = 0; i < parts.length - 1; i += 1) {
+      const name = parts[i]!
+      let child = node.children.get(name)
+      if (child === undefined) {
+        child = { name, path: parts.slice(0, i + 1).join('/'), files: [], children: new Map() }
+        node.children.set(name, child)
+      }
+      node = child
+    }
+    node.files.push(parts[parts.length - 1]!)
+  }
+
+  const freeze = (node: BuildNode): DirEntry => {
+    const children = [...node.children.values()].sort((a, b) => a.name.localeCompare(b.name)).map(freeze)
+    const files = [...node.files].sort((a, b) => a.localeCompare(b))
+    const subtreeCount = files.length + children.reduce((sum, child) => sum + child.fileCount, 0)
+    return { name: node.name, path: node.path, fileCount: subtreeCount, files, children }
+  }
+
+  return freeze(rootNode).children
+}
+
+/** One flat search hit: a directory or a file path, tickable as a pathspec. */
+export interface PathHit {
+  readonly path: string
+  readonly isFile: boolean
+}
+
+/**
+ * Search the repository's paths for a fragment — case-insensitive, over the
+ * full path. Results are FLAT: a search list is not a tree (the same honesty
+ * as the filtered commit list), and each hit ticks as a pathspec directly.
+ *
+ * Directories match too: every directory is some file's prefix, and ticking a
+ * directory covers its subtree — the search takes the raw path list the host
+ * sent, so root-level files and unexpanded directories are all in scope.
+ * @param paths - repo-relative file paths, exactly as `repoTree` returned.
+ * @param needle - raw search text; blank matches nothing (caller shows the tree).
+ */
+export function searchPaths(paths: readonly string[], needle: string): readonly PathHit[] {
+  const n = needle.trim().toLowerCase()
+  if (n.length === 0) return []
+  const hits: PathHit[] = []
+  const seen = new Set<string>()
+  for (const path of paths) {
+    if (path.toLowerCase().includes(n)) {
+      hits.push({ path, isFile: true })
+      seen.add(path)
+    }
+    // Every directory prefix is a candidate too; deduped via `seen`.
+    const parts = path.split('/')
+    for (let i = 1; i < parts.length; i += 1) {
+      const dir = parts.slice(0, i).join('/')
+      if (!seen.has(dir) && dir.toLowerCase().includes(n)) {
+        seen.add(dir)
+        hits.push({ path: dir, isFile: false })
+      }
+    }
+  }
+  // Files first — the common query is a file; the directory that contains it
+  // reads better below it than above.
+  return [...hits.filter(hit => hit.isFile), ...hits.filter(hit => !hit.isFile)]
+}

package/src/client/file-filter.ts

@@ -0,0 +1,66 @@
+/**
+ * Narrowing a file list by typing at it.
+ *
+ * A commit that touched 140 files is a scroll, not a list, and the drawer's
+ * tree is the same object in every tab — so the rule lives here once and both
+ * the working tree and a commit's contents get it.
+ *
+ * Two decisions worth stating, because both are the kind that get "simplified"
+ * later:
+ *
+ *   - **Terms are ANDed, in any order.** `panel css` finds
+ *     `src/client/GitWorkbenchPanel.module.css` — which is how anyone types
+ *     when they half-remember a path, and is the behaviour a single-substring
+ *     match gets wrong for exactly the paths that are long enough to need
+ *     filtering.
+ *   - **Smart case.** An all-lowercase query ignores case; the moment the
+ *     reader types a capital they mean it. `README` should not match
+ *     `readme-generator`, and `readme` should still find `README.md`.
+ *
+ * The result keeps the caller's order and its element type: the tree is built
+ * from whatever survives, so filtering never has to know what a file is beyond
+ * its path.
+ *
+ * @module @young1lin/dsh-ui-gitworkbench/client/file-filter
+ */
+
+/** Split a raw query into the terms every path must contain. */
+function termsOf(query: string): readonly string[] {
+  return query.split(/\s+/).filter(term => term.length > 0)
+}
+
+/**
+ * Whether one path satisfies a query.
+ *
+ * @param path - repo-relative path, as the tree lists it.
+ * @param query - raw text from the filter box; blank matches everything, so a
+ *                caller that renders `filterFiles` unconditionally shows the
+ *                whole list until something is typed.
+ */
+export function matchesPath(path: string, query: string): boolean {
+  const terms = termsOf(query)
+  if (terms.length === 0) return true
+  return terms.every(term => {
+    // Per TERM, not per query: `src README` is a sensible thing to type, and
+    // deciding the whole query's case from one capital would make the `src`
+    // half case-sensitive too.
+    const cased = term.toLowerCase() !== term
+    return cased ? path.includes(term) : path.toLowerCase().includes(term.toLowerCase())
+  })
+}
+
+/**
+ * Keep the files whose path satisfies the query, in the order given.
+ *
+ * @param files - anything carrying a `path`; the tree's own file objects.
+ * @param query - raw text from the filter box.
+ * @returns the same array instance when nothing is filtered out, so a blank
+ *          query costs no re-render downstream.
+ */
+export function filterFiles<T extends { readonly path: string }>(
+  files: readonly T[],
+  query: string,
+): readonly T[] {
+  if (termsOf(query).length === 0) return files
+  return files.filter(file => matchesPath(file.path, query))
+}

package/src/client/index.ts

@@ -19,10 +19,12 @@ import type {} from '@deepseek-ai/dsh-client-runtime' // informational inject ed
 import type {} from '@deepseek-ai/dsh-client-ui-slots' // SlotMap is reused, not extended
 import {
   GitWorkbenchPanel,
-  type GitCommit, type GitOpName, type GitOpPayload, type GitOpResult,
+  type DiscardPreview, type GitCommit, type GitOpName, type GitOpPayload, type GitOpResult,
   type WorkbenchStats, type SyncStatus, type WorktreeStatus,
 } from './GitWorkbenchPanel.tsx'
 import type { StyleEntry, StyleScope, StyleSettings } from './themes.ts'
+import type { LogFilter } from '../log-filter.ts'
+import type { AuthorEntry } from '../shortlog.ts'
 import { en, zh } from './locales.ts'
 
 /**
@@ -91,14 +93,35 @@ export function apply(ctx: ClientContext): void {
           return result.ok ? result.value : null
         },
         // One page of the commit log past what `stats` bundles, so the history
-        // list can grow instead of stopping at the first page.
-        fetchCommits: async (worktreePath: string | undefined, ref: string, skip: number, limit: number, signal: AbortSignal): Promise<{ commits: GitCommit[]; hasMore: boolean } | null> => {
+        // list can grow instead of stopping at the first page. The filter is
+        // compiled into git log arguments host-side (IDEA-style pushdown).
+        fetchCommits: async (worktreePath: string | undefined, ref: string, skip: number, limit: number, filter: LogFilter, signal: AbortSignal): Promise<{ commits: GitCommit[]; hasMore: boolean } | null> => {
           const result = await connection.rpc.call(
             '/api',
             'gitWorkbench/commits',
-            { args: { worktreePath: worktreePath ?? '', ref, skip, limit } },
+            { args: { worktreePath: worktreePath ?? '', ref, skip, limit, filter } },
             signal,
-          ) as { ok: true; value: { commits: GitCommit[]; hasMore: boolean } } | { ok: false; error: { message?: string } }
+          ) as { ok: true; value: { commits: GitCommit[]; hasMore: boolean; error?: string } } | { ok: false; error: { message?: string } }
+          return result.ok ? result.value : null
+        },
+        // Author roster for the ref the history walks, busiest first.
+        fetchAuthors: async (worktreePath: string | undefined, ref: string, signal: AbortSignal): Promise<{ authors: AuthorEntry[]; truncated: boolean } | null> => {
+          const result = await connection.rpc.call(
+            '/api',
+            'gitWorkbench/authors',
+            { args: { worktreePath: worktreePath ?? '', ref } },
+            signal,
+          ) as { ok: true; value: { authors: AuthorEntry[]; truncated: boolean } } | { ok: false; error: { message?: string } }
+          return result.ok ? result.value : null
+        },
+        // Every path on HEAD — the path picker's raw material.
+        fetchRepoTree: async (worktreePath: string | undefined, signal: AbortSignal): Promise<{ paths: string[]; truncated: boolean } | null> => {
+          const result = await connection.rpc.call(
+            '/api',
+            'gitWorkbench/repoTree',
+            { args: { worktreePath: worktreePath ?? '' } },
+            signal,
+          ) as { ok: true; value: { paths: string[]; truncated: boolean } } | { ok: false; error: { message?: string } }
           return result.ok ? result.value : null
         },
         // Two refs compared as `base...head`, in the same shape as every other
@@ -181,6 +204,22 @@ export function apply(ctx: ClientContext): void {
           ) as { ok: true; value: SyncStatus } | { ok: false; error: { message?: string } }
           return result.ok ? result.value : null
         },
+        // Read-only, and the only reason it is a separate call rather than a
+        // field on the file row: the confirmation must state what discarding
+        // this file would do NOW, not what the last poll saw. A row that says
+        // "modified" while git has since had the file staged, edited or removed
+        // is the difference between "goes back to its committed content" and
+        // "leaves the disk and cannot come back" — which is the entire question
+        // the dialog exists to ask.
+        fetchDiscardPlan: async (worktreePath: string | undefined, path: string, signal: AbortSignal): Promise<DiscardPreview | null> => {
+          const result = await connection.rpc.call(
+            '/api',
+            'gitWorkbench/discardPlan',
+            { args: { worktreePath: worktreePath ?? '', path } },
+            signal,
+          ) as { ok: true; value: DiscardPreview } | { ok: false; error: { message?: string } }
+          return result.ok ? result.value : null
+        },
         runGitOp: async (op: GitOpName, worktreePath: string | undefined, payload: GitOpPayload, signal: AbortSignal): Promise<GitOpResult> => {
           const result = await connection.rpc.call(
             '/api',

package/src/client/locales.ts

@@ -20,11 +20,17 @@
 /** Every key this plugin looks up — the two dictionaries below must both cover it. */
 export type WorkbenchKey =
   | 'aheadTitle' | 'behindTitle' | 'files'
+  | 'filterFiles' | 'filterFilesPlaceholder' | 'filterFilesClear' | 'filesFiltered' | 'filterNoMatch'
   | 'drawerLabel' | 'totalsDim' | 'refresh' | 'close'
   | 'tabsLabel' | 'tabChanges' | 'tabHistory' | 'tabCompare'
   | 'sourceLabel' | 'workingTree'
   | 'loadingCommit' | 'renamedFrom' | 'binaryFile' | 'loadingDiff' | 'noTextDiff'
   | 'noCommits' | 'historyLabel' | 'historyEnd' | 'loading' | 'maximize' | 'restore'
+  | 'commitAuthor' | 'commitCommitter' | 'commitDate' | 'historyFilterPlaceholder' | 'historyNoMatch'
+  | 'filterClearAll' | 'filterBy' | 'filterUsers' | 'filterUserSearch' | 'filterAuthorsMore'
+  | 'filterDate' | 'filterToday' | 'filterLast7' | 'filterLast30' | 'filterAfter' | 'filterBefore'
+  | 'filterPaths' | 'filterPathsMore' | 'allBranches' | 'filterPathSearch'
+  | 'filterCalendarSets' | 'filterSelected' | 'filterLocale'
   | 'compareBase' | 'compareHead' | 'comparePick' | 'compareCommits' | 'loadingCompare' | 'noBranches'
   | 'refSearch' | 'refNone' | 'refCount' | 'refTruncated' | 'refWorktrees' | 'refBranches' | 'historyRefLabel'
   | 'settings' | 'themeMode' | 'themePalette' | 'themeScope' | 'themeBackground' | 'themeCss'
@@ -42,6 +48,9 @@ export type WorkbenchKey =
   | 'stage' | 'unstage' | 'stageAll' | 'unstageAll' | 'stagedCount'
   | 'commit' | 'amend' | 'commitPlaceholder' | 'commitNeedMessage' | 'commitLead'
   | 'op.ok.stage' | 'op.ok.unstage' | 'op.ok.commit' | 'op.ok.fetch' | 'op.ok.pull' | 'op.ok.push'
+  | 'op.ok.discardFile'
+  | 'discardAction' | 'discardTitle' | 'discardConfirm' | 'discardCancel'
+  | 'discardBodyRestore' | 'discardBodyDelete' | 'discardBodyUnrename'
   | 'op.fail.auth' | 'op.fail.network' | 'op.fail.no-upstream' | 'op.fail.diverged' | 'op.fail.conflict'
   | 'op.fail.nothing-to-commit' | 'op.fail.dirty' | 'op.fail.unknown'
 
@@ -112,8 +121,44 @@ export const zh: Record<WorkbenchKey, string> = {
   noTextDiff: '无文本差异',
   noCommits: '无提交历史',
   historyLabel: '提交历史',
+  commitAuthor: '作者',
+  commitCommitter: '提交者',
+  commitDate: '提交时间',
+  historyFilterPlaceholder: '筛选：user: 名字 / path: 路径 / after: 日期 / 关键词',
+  historyNoMatch: '没有匹配的提交',
+  filterClearAll: '清除全部',
+  filterBy: '筛选条件',
+  filterUsers: '用户',
+  filterUserSearch: '搜索作者',
+  filterAuthorsMore: '仅显示提交最多的 500 位作者',
+  filterDate: '日期',
+  filterToday: '今天',
+  filterLast7: '最近 7 天',
+  filterLast30: '最近 30 天',
+  filterAfter: '之后',
+  filterBefore: '之前',
+  filterPaths: '路径',
+  filterPathsMore: '文件过多，目录树已截断',
+  filterPathSearch: '搜索文件或目录',
+  filterCalendarSets: '日历写入',
+  filterSelected: '已选 {count} 项',
+  // BCP-47 tag for the filter calendar. The month title and the weekday row
+  // used to come from `Intl.DateTimeFormat(undefined, …)`, i.e. the BROWSER's
+  // language — an English drawer on a zh-CN machine printed "2026年8月" over
+  // 一二三四五六日. The dictionary is what knows which language the drawer is
+  // speaking, so the tag lives here.
+  filterLocale: 'zh-CN',
+  allBranches: '全部分支',
   expandAll: '展开全部',
   collapseAll: '收起全部',
+  // Filtering the file list. Separate from the funnel above the commit list:
+  // that one asks git for a different set of commits, this one only hides rows
+  // already on screen.
+  filterFiles: '过滤文件',
+  filterFilesPlaceholder: '过滤文件，空格分隔多个关键字',
+  filterFilesClear: '清除过滤',
+  filesFiltered: '{shown} / {count} 文件',
+  filterNoMatch: '没有匹配的文件',
   noBranch: '(无分支)',
   copyCommit: '复制提交说明',
   copiedCommit: '已复制',
@@ -147,6 +192,19 @@ export const zh: Record<WorkbenchKey, string> = {
   'op.ok.fetch': '已获取远端信息',
   'op.ok.pull': '拉取完成',
   'op.ok.push': '推送成功',
+  'op.ok.discardFile': '已撤回',
+  // The row action, and the dialog it opens. IDEA calls this Rollback and
+  // means "take the file back to its committed state" — not "undo my last
+  // edit", which is the editor's job and a different promise.
+  discardAction: '撤回改动',
+  discardTitle: '撤回改动？',
+  discardConfirm: '撤回',
+  discardCancel: '取消',
+  // One body per consequence. The dialog never says a generic "are you sure":
+  // the whole point of it is to name which of these three is about to happen.
+  discardBodyRestore: '{path} 将还原成上次提交时的样子。这里的 {added} 行新增、{deleted} 行删除无法找回。',
+  discardBodyDelete: '{path} 从未被 git 记录过，删除后无法找回。',
+  discardBodyUnrename: '撤销重命名：{path} 改回 {previousPath}，改名期间的内容改动一并丢弃。',
   'op.fail.auth': '认证失败。凭据提示已被禁用，请先在终端里配置好凭据再重试。',
   'op.fail.network': '网络不可达：主机名解析失败或连接不上。检查网络与远程地址后重试。',
   'op.fail.no-upstream': '当前分支没有上游分支。',
@@ -224,8 +282,36 @@ export const en: Record<WorkbenchKey, string> = {
   noTextDiff: 'No text changes',
   noCommits: 'No commit history',
   historyLabel: 'Commit history',
+  commitAuthor: 'Author',
+  commitCommitter: 'Committer',
+  commitDate: 'Committed',
+  historyFilterPlaceholder: 'Filter: user: name / path: dir / after: date / text',
+  historyNoMatch: 'No matching commits',
+  filterClearAll: 'Clear all',
+  filterBy: 'Filter by',
+  filterUsers: 'Users',
+  filterUserSearch: 'Search authors',
+  filterAuthorsMore: 'Showing the 500 busiest authors only',
+  filterDate: 'Date',
+  filterToday: 'Today',
+  filterLast7: 'Last 7 days',
+  filterLast30: 'Last 30 days',
+  filterAfter: 'After',
+  filterBefore: 'Before',
+  filterPaths: 'Paths',
+  filterPathsMore: 'Too many files — tree truncated',
+  filterPathSearch: 'Search files or folders',
+  filterCalendarSets: 'Calendar sets',
+  filterSelected: '{count} selected',
+  filterLocale: 'en-US',
+  allBranches: 'All branches',
   expandAll: 'Expand all',
   collapseAll: 'Collapse all',
+  filterFiles: 'Filter files',
+  filterFilesPlaceholder: 'Filter files; space-separated terms',
+  filterFilesClear: 'Clear filter',
+  filesFiltered: '{shown} / {count} files',
+  filterNoMatch: 'No file matches',
   noBranch: '(no branch)',
   copyCommit: 'Copy message',
   copiedCommit: 'Copied',
@@ -259,6 +345,14 @@ export const en: Record<WorkbenchKey, string> = {
   'op.ok.fetch': 'Fetched',
   'op.ok.pull': 'Pulled',
   'op.ok.push': 'Pushed',
+  'op.ok.discardFile': 'Rolled back',
+  discardAction: 'Roll back changes',
+  discardTitle: 'Roll back changes?',
+  discardConfirm: 'Roll back',
+  discardCancel: 'Cancel',
+  discardBodyRestore: '{path} goes back to its committed content. The {added} added and {deleted} deleted lines here cannot be recovered.',
+  discardBodyDelete: '{path} was never recorded by git. Deleting it cannot be undone.',
+  discardBodyUnrename: 'Undo the rename: {path} goes back to {previousPath}, and content changed along the way is lost.',
   'op.fail.auth': 'Authentication failed. Credential prompts are disabled here — set your credentials up in a terminal first.',
   'op.fail.network': 'The network was unreachable — the host could not be resolved or the connection failed. Check connectivity and the remote URL, then retry.',
   'op.fail.no-upstream': 'This branch has no upstream.',