dsh-remote-vs 0.0.0-stage → 0.8.3

package/src/client/scm/untracked-dirs.ts

@@ -0,0 +1,139 @@
+/**
+ * Untracked DIRECTORY rows, expanded in place.
+ *
+ * `git status -u normal` — the panel's performance mode — reports an untracked
+ * directory as ONE row (`dir/`), so the files inside it are invisible. Clicking
+ * that row runs a pathspec-limited `git status -uall -- dir/` (cost bounded by
+ * the directory, never the repository) and the rows it answers with are shown
+ * under the directory row. This module is the pure state half — expand,
+ * collapse, prune and the row projection; the probe itself lives in
+ * `scm/actions.ts` and the command in `git-ops.ts`.
+ *
+ * Rows keep their FULL repo-relative paths (`dir/sub/b.txt`), exactly like every
+ * other row in the panel: nesting is then a matter of indentation, and a row can
+ * never be ambiguous when two directories hold the same file name.
+ */
+import type { GitPathStatus, GitStatusDetail } from '../../protocol.ts'
+import { parseStatusDetail } from '../../git-ops.ts'
+import { isConflictStatus, type ChangeEntry } from './status-map.ts'
+
+/** Expanded directory rows: directory path (`dir/`) → the rows under it. */
+export type DirExpansions = ReadonlyMap<string, readonly ChangeEntry[]>
+
+/** True when a status record is an untracked DIRECTORY row (`?? dir/`). */
+export function isUntrackedDirRow(entry: GitPathStatus): boolean {
+  return entry.x === '?' && entry.y === '?' && entry.path.endsWith('/')
+}
+
+/**
+ * One probe record as the row the panel shows.
+ *
+ * Same precedence as `bucketStatus` (an untracked record is a `?` row, a
+ * conflict is `U`, an index half wins over the worktree half) but ONE row per
+ * path, in the order git answered — the expansion is a list under a parent row,
+ * not the two-section view.
+ */
+export function childRows(detail: GitStatusDetail): ChangeEntry[] {
+  const rows: ChangeEntry[] = []
+  for (const entry of detail.entries) {
+    const { path, x, y, origPath } = entry
+    const base = origPath === undefined ? {} : { oldPath: origPath }
+    if (x === '?' && y === '?') {
+      rows.push({ path, status: '?', staged: false, ...base })
+      continue
+    }
+    if (isConflictStatus(x, y)) {
+      rows.push({ path, status: 'U', staged: false, ...base })
+      continue
+    }
+    if (x !== ' ' && x !== '?') {
+      rows.push({ path, status: x, staged: true, ...base })
+      continue
+    }
+    rows.push({ path, status: y, staged: false, ...base })
+  }
+  return rows
+}
+
+/**
+ * Expand one directory row from a probe answer.
+ *
+ * @param current - the expansions in force.
+ * @param dirPath - the directory row that was clicked (`dir/`).
+ * @param stdout - the raw `-z` stdout of `statusDirCommand` for that directory.
+ * @returns a new map (the same one when the path is unusable).
+ */
+export function expandDir(current: DirExpansions, dirPath: string, stdout: string): DirExpansions {
+  if (dirPath === '') return current
+  const next = new Map(current)
+  next.set(dirPath, childRows(parseStatusDetail(stdout)))
+  return next
+}
+
+/**
+ * Collapse one directory row.
+ *
+ * @returns a new map, or the same one when nothing was expanded for that path.
+ */
+export function collapseDir(current: DirExpansions, dirPath: string): DirExpansions {
+  if (!current.has(dirPath)) return current
+  const next = new Map(current)
+  next.delete(dirPath)
+  return next
+}
+
+/**
+ * Drop rows that are no longer untracked from the expansions.
+ *
+ * A path that was just STAGED stops being an untracked row: it must leave the
+ * expansion (it now lives under "staged changes"), and a directory that was
+ * staged itself takes its whole expansion with it. Without this the same file
+ * would be listed twice — once as `??` under its directory and once as `A `.
+ *
+ * @param current - the expansions in force.
+ * @param paths - repo-relative paths that were just staged.
+ * @returns a new map, or the same one when nothing matched.
+ */
+export function dropExpandedRows(current: DirExpansions, paths: readonly string[]): DirExpansions {
+  if (paths.length === 0 || current.size === 0) return current
+  const gone = new Set(paths)
+  let next: Map<string, readonly ChangeEntry[]> | undefined
+  for (const [dirPath, rows] of current) {
+    if (gone.has(dirPath)) {
+      next = next ?? new Map(current)
+      next.delete(dirPath)
+      continue
+    }
+    const kept = rows.filter(row => !gone.has(row.path))
+    if (kept.length === rows.length) continue
+    next = next ?? new Map(current)
+    // Nothing left under it: collapse rather than show an empty expansion.
+    if (kept.length === 0) next.delete(dirPath)
+    else next.set(dirPath, kept)
+  }
+  return next ?? current
+}
+
+/**
+ * Drop the expansions whose directory row is gone from the status.
+ *
+ * This is what keeps an expansion honest across a full refresh: it survives
+ * while git still reports the same untracked directory row, and disappears the
+ * moment that row does — staged, deleted, or simply no longer untracked. It is
+ * applied to EVERY status the panel adopts (a refresh, or a local stage), so a
+ * stale expansion can never outlive the row it hangs from.
+ *
+ * @param current - the expansions in force.
+ * @param detail - the status the panel is about to show.
+ * @returns a new map, or the same one when every expansion still applies.
+ */
+export function pruneDirExpansions(current: DirExpansions, detail: GitStatusDetail): DirExpansions {
+  let next: Map<string, readonly ChangeEntry[]> | undefined
+  for (const dirPath of current.keys()) {
+    const alive = detail.entries.some(entry => entry.path === dirPath && isUntrackedDirRow(entry))
+    if (alive) continue
+    next = next ?? new Map(current)
+    next.delete(dirPath)
+  }
+  return next ?? current
+}

package/src/client/selection-popup.ts

@@ -0,0 +1,157 @@
+/**
+ * The floating "add selection to conversation" popup for the remote code
+ * viewer: a viewport-anchored button portaled to `document.body`, kept alive
+ * across the selection gesture and committed on click. Vendored
+ * behavior-identical from dsh-better-sidebar 0.25.0 (`selection-popup.ts`);
+ * the only adaptation is this header (the remote viewer is CodeMirror-only,
+ * so there is no preview/edit mode flip to hide on — the caller still hides
+ * on surface scrolls, selection collapse and gate flips).
+ *
+ * Dismissal contract (fixes upstream issue #425): the popup must never
+ * outlive its editor surface. The sidebar keeps every tab MOUNTED —
+ * switching tabs only flips the pane cell to `display:none` and collapsing
+ * the panel translates it off-screen — while the portaled `position:fixed`
+ * button stays pinned to its viewport anchor, ignoring both. The caller
+ * already hides on surface scrolls, selection collapse and mode flips; this
+ * hook adds the global dismissal that covers everything else:
+ *
+ * - any `mousedown` outside the button (tab bar, composer, another pane,
+ *   the collapse toggle, …) closes it;
+ * - `Escape` closes it;
+ * - the document going hidden (`visibilitychange`) or the window losing
+ *   focus closes it;
+ * - an `IntersectionObserver` on the editor surface closes it as soon as the
+ *   surface leaves the viewport — the tab-switch (`display:none`) and
+ *   panel-collapse (translated off-screen) paths have no DOM events of their
+ *   own, so the geometry signal is the only reliable one.
+ *
+ * The button's own `mousedown` is never treated as an outside click: the
+ * caller preventDefaults it to keep the selection/caret alive until the
+ * click commits (the hook's capture-phase listener runs first and must not
+ * hide for it).
+ */
+import { useEffect, useRef, useState, type RefObject } from 'react'
+
+/** The floating "add to conversation" action: payload + viewport anchor. */
+export interface SelectionPopup {
+  insert: string
+  left: number
+  top: number
+}
+
+export interface SelectionPopupOptions {
+  /** Commit the payload into the composer draft (button click). */
+  onCommit(insert: string): void
+  /**
+   * The DOM surface that must stay on screen for the popup to live: the
+   * CodeMirror host. Called lazily (refs are null until the content loads).
+   */
+  getSurface(): HTMLElement | null
+}
+
+export interface SelectionPopupControls {
+  /** The current popup (null = hidden). */
+  popup: SelectionPopup | null
+  /** Attach to the portaled button element. */
+  buttonRef: RefObject<HTMLButtonElement>
+  /** Anchor the popup above a selection (viewport-clamped). */
+  show(insert: string, left: number, top: number): void
+  /** Hide the popup (idempotent). */
+  hide(): void
+  /** The button's click: commit the stored payload, then hide. */
+  commit(): void
+}
+
+export function useSelectionPopup(options: SelectionPopupOptions): SelectionPopupControls {
+  // Latest-callback refs: the dismissal listeners live for the mount's
+  // lifetime, so they must not capture stale closures across renders.
+  const onCommitRef = useRef(options.onCommit)
+  const getSurfaceRef = useRef(options.getSurface)
+  onCommitRef.current = options.onCommit
+  getSurfaceRef.current = options.getSurface
+
+  const [popup, setPopup] = useState<SelectionPopup | null>(null)
+  /** Live mirror for click/event-time reads (no re-render race). */
+  const popupRef = useRef<SelectionPopup | null>(null)
+  /** The portaled button itself (for the outside-click guard). */
+  const buttonRef = useRef<HTMLButtonElement>(null)
+  /** The surface visibility observer (created lazily on open). */
+  const observerRef = useRef<IntersectionObserver | null>(null)
+
+  const show = (insert: string, left: number, top: number): void => {
+    const next: SelectionPopup = {
+      insert,
+      left: Math.min(Math.max(left, 80), window.innerWidth - 80),
+      top,
+    }
+    popupRef.current = next
+    setPopup(next)
+  }
+
+  const hide = (): void => {
+    popupRef.current = null
+    setPopup(null)
+  }
+
+  const commit = (): void => {
+    const current = popupRef.current
+    if (current === null) return
+    onCommitRef.current(current.insert)
+    hide()
+  }
+
+  // Global dismissal listeners, registered once; every handler reads the
+  // live popup ref so it no-ops while no popup is open.
+  useEffect(() => {
+    const onMouseDown = (event: MouseEvent): void => {
+      if (popupRef.current === null) return
+      const button = buttonRef.current
+      if (button !== null && (button === event.target || button.contains(event.target as Node))) return
+      hide()
+    }
+    const onKeyDown = (event: KeyboardEvent): void => {
+      if (event.key === 'Escape' && popupRef.current !== null) hide()
+    }
+    const onVisibilityChange = (): void => {
+      if (document.hidden && popupRef.current !== null) hide()
+    }
+    const onWindowBlur = (): void => {
+      if (popupRef.current !== null) hide()
+    }
+    document.addEventListener('mousedown', onMouseDown, true)
+    document.addEventListener('keydown', onKeyDown, true)
+    document.addEventListener('visibilitychange', onVisibilityChange)
+    window.addEventListener('blur', onWindowBlur)
+    return () => {
+      document.removeEventListener('mousedown', onMouseDown, true)
+      document.removeEventListener('keydown', onKeyDown, true)
+      document.removeEventListener('visibilitychange', onVisibilityChange)
+      window.removeEventListener('blur', onWindowBlur)
+      observerRef.current?.disconnect()
+      observerRef.current = null
+    }
+  }, [])
+
+  // Re-target the visibility observer whenever a popup opens: the surface
+  // refs may have been null at mount (content loads async), so the surface
+  // is only trustworthy at open time. The boolean flip is the only thing
+  // that must re-run this; an anchor move while open keeps the same surface.
+  const popupOpen = popup !== null
+  useEffect(() => {
+    if (!popupOpen) return
+    observerRef.current?.disconnect()
+    observerRef.current = null
+    if (typeof IntersectionObserver === 'undefined') return
+    const surface = getSurfaceRef.current()
+    if (surface === null) return
+    const observer = new IntersectionObserver((entries) => {
+      for (const entry of entries) {
+        if (!entry.isIntersecting) hide()
+      }
+    }, { threshold: 0 })
+    observerRef.current = observer
+    observer.observe(surface)
+  }, [popupOpen])
+
+  return { popup, buttonRef, show, hide, commit }
+}