@elefunc/send 0.1.0

package/src/tui/file-search-protocol.ts

@@ -0,0 +1,48 @@
+export interface FileSearchMatch {
+  relativePath: string
+  absolutePath: string
+  fileName: string
+  kind: "file" | "directory"
+  score: number
+  indices: number[]
+}
+
+export type FileSearchRequest =
+  | {
+      type: "create-session"
+      sessionId: string
+      workspaceRoot: string
+      resultLimit?: number
+    }
+  | {
+      type: "update-query"
+      sessionId: string
+      query: string
+    }
+  | {
+      type: "dispose-session"
+      sessionId: string
+    }
+
+export type FileSearchEvent =
+  | {
+      type: "update"
+      sessionId: string
+      query: string
+      matches: FileSearchMatch[]
+      walkComplete: boolean
+    }
+  | {
+      type: "complete"
+      sessionId: string
+      query: string
+    }
+  | {
+      type: "error"
+      sessionId: string
+      query: string
+      message: string
+    }
+
+export const FILE_SEARCH_RESULT_LIMIT = 20
+export const FILE_SEARCH_VISIBLE_ROWS = 8

package/src/tui/file-search.ts

@@ -0,0 +1,282 @@
+import { readFile, readdir, realpath, stat } from "node:fs/promises"
+import { join, relative, resolve, sep } from "node:path"
+import { expandHomePath, isHomeDirectoryPath } from "../core/paths"
+import type { FileSearchMatch } from "./file-search-protocol"
+
+export interface IndexedEntry {
+  absolutePath: string
+  relativePath: string
+  fileName: string
+  kind: "file" | "directory"
+}
+
+export interface FileSearchScope {
+  normalizedInput: string
+  workspaceRoot: string
+  displayPrefix: string
+  query: string
+}
+
+export interface MountInfoEntry {
+  mountPoint: string
+  fsType: string
+  source: string
+}
+
+export interface MountProbeResult {
+  mount: MountInfoEntry
+  probeMs: number
+  slow: boolean
+}
+
+export interface CrawlWorkspaceOptions {
+  mountTable?: readonly MountInfoEntry[]
+  probeThresholdMs?: number
+  probeMount?: (mount: MountInfoEntry) => Promise<number>
+}
+
+export class SlowSearchMountError extends Error {
+  readonly mountPoint: string
+  readonly probeMs: number
+
+  constructor(mountPoint: string, probeMs: number) {
+    super(`Preview search disabled for slow mount ${mountPoint} (${Math.round(probeMs)}ms probe).`)
+    this.name = "SlowSearchMountError"
+    this.mountPoint = mountPoint
+    this.probeMs = probeMs
+  }
+}
+
+const SKIPPED_DIRECTORIES = new Set([".git", "node_modules"])
+const BOUNDARY_CHARS = new Set(["/", "_", "-", "."])
+export const FILE_SEARCH_SLOW_MOUNT_MS = 250
+
+const trimTrailingCrLf = (value: string) => value.replace(/[\r\n]+$/u, "")
+const normalizeSeparators = (value: string) => value.replace(/\\/gu, "/")
+const pathChars = (value: string) => Array.from(value)
+const lower = (value: string) => value.toLocaleLowerCase("en-US")
+const renderedDisplayPrefix = (displayPrefix: string) => displayPrefix === "~" ? "~/" : displayPrefix
+const MOUNTINFO_PATH = "/proc/self/mountinfo"
+
+export const normalizeSearchQuery = (value: string) => normalizeSeparators(trimTrailingCrLf(value))
+export const normalizeRelativePath = (value: string) => normalizeSeparators(value.split(sep).join("/"))
+export const shouldSkipSearchDirectory = (name: string) => SKIPPED_DIRECTORIES.has(name)
+export const isCaseSensitiveQuery = (query: string) => /[A-Z]/u.test(query)
+export const isSlowMountProbe = (probeMs: number, thresholdMs = FILE_SEARCH_SLOW_MOUNT_MS) => probeMs >= thresholdMs
+
+const isBoundaryIndex = (chars: string[], index: number) => index === 0 || BOUNDARY_CHARS.has(chars[index - 1] || "")
+const decodeMountInfoValue = (value: string) => value.replace(/\\([0-7]{3})/gu, (_, octal: string) => String.fromCharCode(Number.parseInt(octal, 8)))
+const pathOnMount = (path: string, mountPoint: string) => mountPoint === "/" || path === mountPoint || path.startsWith(`${mountPoint}/`)
+const sortMountTable = (mounts: readonly MountInfoEntry[]) => [...mounts].sort((left, right) => right.mountPoint.length - left.mountPoint.length || left.mountPoint.localeCompare(right.mountPoint))
+
+const basenameStartIndex = (chars: string[]) => {
+  for (let index = chars.length - 1; index >= 0; index -= 1) if (chars[index] === "/") return index + 1
+  return 0
+}
+
+export const parseMountInfo = (text: string): MountInfoEntry[] => sortMountTable(text
+  .split(/\r?\n/u)
+  .map(line => line.trim())
+  .filter(Boolean)
+  .flatMap(line => {
+    const parts = line.split(" - ", 2)
+    if (parts.length !== 2) return []
+    const left = parts[0]!.split(" ")
+    const right = parts[1]!.split(" ")
+    if (left.length < 5 || right.length < 2) return []
+    return [{
+      mountPoint: decodeMountInfoValue(left[4]!),
+      fsType: right[0]!,
+      source: right[1]!,
+    } satisfies MountInfoEntry]
+  }))
+
+export const findMountForPath = (mounts: readonly MountInfoEntry[], path: string) => {
+  const absolute = resolve(path)
+  return sortMountTable(mounts).find(mount => pathOnMount(absolute, mount.mountPoint)) ?? null
+}
+
+const loadMountTable = async () => {
+  try {
+    return parseMountInfo(await readFile(MOUNTINFO_PATH, "utf8"))
+  } catch {
+    return []
+  }
+}
+
+const measureMountProbe = async (mount: MountInfoEntry) => {
+  const startedAt = performance.now()
+  await readdir(mount.mountPoint, { withFileTypes: true })
+  return performance.now() - startedAt
+}
+
+export const deriveFileSearchScope = (value: string, cwd = process.cwd()): FileSearchScope | null => {
+  const normalizedInput = normalizeSearchQuery(value)
+  if (!normalizedInput) return null
+  if (normalizedInput === "~") {
+    return {
+      normalizedInput,
+      workspaceRoot: expandHomePath(normalizedInput)!,
+      displayPrefix: "~",
+      query: "",
+    }
+  }
+  const slashIndex = normalizedInput.endsWith("/")
+    ? normalizedInput.length - 1
+    : normalizedInput.lastIndexOf("/")
+  const displayPrefix = slashIndex >= 0 ? normalizedInput.slice(0, slashIndex + 1) : ""
+  return {
+    normalizedInput,
+    workspaceRoot: isHomeDirectoryPath(displayPrefix || ".")
+      ? expandHomePath(displayPrefix || ".")!
+      : resolve(cwd, displayPrefix || "."),
+    displayPrefix,
+    query: normalizedInput.slice(displayPrefix.length),
+  }
+}
+
+export const formatFileSearchDisplayPath = (displayPrefix: string, relativePath: string) =>
+  !displayPrefix ? relativePath : renderedDisplayPrefix(displayPrefix) === "/" ? `/${relativePath}` : `${renderedDisplayPrefix(displayPrefix)}${relativePath}`
+
+export const offsetFileSearchMatchIndices = (displayPrefix: string, indices: number[]) => {
+  const offset = pathChars(renderedDisplayPrefix(displayPrefix)).length
+  return offset ? indices.map(index => index + offset) : indices
+}
+
+export const matchPathQuery = (relativePath: string, query: string) => {
+  const normalizedQuery = normalizeSearchQuery(query)
+  if (!normalizedQuery) return null
+  const chars = pathChars(relativePath)
+  const queryChars = pathChars(normalizedQuery)
+  const caseSensitive = isCaseSensitiveQuery(normalizedQuery)
+  const haystack = caseSensitive ? chars : chars.map(lower)
+  const needle = caseSensitive ? queryChars : queryChars.map(lower)
+  const indices: number[] = []
+  let cursor = 0
+  for (const token of needle) {
+    let found = -1
+    for (let index = cursor; index < haystack.length; index += 1) {
+      if (haystack[index] === token) {
+        found = index
+        break
+      }
+    }
+    if (found < 0) return null
+    indices.push(found)
+    cursor = found + 1
+  }
+  const basenameStart = basenameStartIndex(chars)
+  const contiguousBasenamePrefix = indices[0] === basenameStart && indices.every((value, index) => value === basenameStart + index)
+  let score = indices.length
+  if (indices[0] === basenameStart) score += 80
+  if (contiguousBasenamePrefix) score += 120
+  for (let index = 0; index < indices.length; index += 1) {
+    if (isBoundaryIndex(chars, indices[index]!)) score += 12
+    if (index > 0 && indices[index] === indices[index - 1]! + 1) score += 8
+  }
+  score -= Math.floor(chars.length / 16)
+  return { indices, score }
+}
+
+const browseEntries = (entries: readonly IndexedEntry[], resultLimit: number) => entries
+  .filter(entry => !entry.relativePath.includes("/"))
+  .sort((left, right) => (left.kind === right.kind ? 0 : left.kind === "directory" ? -1 : 1) || left.relativePath.localeCompare(right.relativePath))
+  .slice(0, resultLimit)
+  .map(entry => ({
+    relativePath: entry.relativePath,
+    absolutePath: entry.absolutePath,
+    fileName: entry.fileName,
+    kind: entry.kind,
+    score: 0,
+    indices: [],
+  } satisfies FileSearchMatch))
+
+export const searchEntries = (entries: readonly IndexedEntry[], query: string, resultLimit: number) => {
+  const normalizedQuery = normalizeSearchQuery(query)
+  if (!normalizedQuery) return browseEntries(entries, resultLimit)
+  const matches: FileSearchMatch[] = []
+  for (const entry of entries) {
+    const match = matchPathQuery(entry.relativePath, normalizedQuery)
+    if (!match) continue
+    matches.push({
+      relativePath: entry.relativePath,
+      absolutePath: entry.absolutePath,
+      fileName: entry.fileName,
+      kind: entry.kind,
+      score: match.score,
+      indices: match.indices,
+    })
+  }
+  matches.sort((left, right) => right.score - left.score || left.relativePath.localeCompare(right.relativePath))
+  return matches.slice(0, resultLimit)
+}
+
+export const searchResultSignature = (query: string, matches: readonly FileSearchMatch[], walkComplete: boolean) =>
+  `${normalizeSearchQuery(query)}|${walkComplete ? 1 : 0}|${matches.map(match => `${match.relativePath}:${match.kind}:${match.score}:${match.indices.join(",")}`).join("|")}`
+
+export const crawlWorkspaceEntries = async (workspaceRoot: string, onEntry: (entry: IndexedEntry) => void, options: CrawlWorkspaceOptions = {}) => {
+  const root = resolve(workspaceRoot)
+  const rootReal = await realpath(root)
+  const mounts = options.mountTable ? sortMountTable(options.mountTable) : await loadMountTable()
+  const rootMount = findMountForPath(mounts, rootReal) ?? findMountForPath(mounts, root)
+  const probeThresholdMs = options.probeThresholdMs ?? FILE_SEARCH_SLOW_MOUNT_MS
+  const probeMount = options.probeMount ?? measureMountProbe
+  const probeCache = new Map<string, MountProbeResult>()
+  const classifyMount = async (mount: MountInfoEntry | null) => {
+    if (!mount) return null
+    const cached = probeCache.get(mount.mountPoint)
+    if (cached) return cached
+    const probeMs = await probeMount(mount)
+    const result = { mount, probeMs, slow: isSlowMountProbe(probeMs, probeThresholdMs) } satisfies MountProbeResult
+    probeCache.set(mount.mountPoint, result)
+    return result
+  }
+
+  const rootProbe = await classifyMount(rootMount)
+  if (rootProbe?.slow) throw new SlowSearchMountError(rootProbe.mount.mountPoint, rootProbe.probeMs)
+
+  const stack: Array<{ absolutePath: string; ancestorReals: Set<string>; mount: MountInfoEntry | null }> = [{ absolutePath: root, ancestorReals: new Set([rootReal]), mount: rootMount }]
+
+  while (stack.length) {
+    const current = stack.pop()!
+    const children = await readdir(current.absolutePath, { withFileTypes: true })
+    for (const child of children) {
+      if (shouldSkipSearchDirectory(child.name) && child.isDirectory()) continue
+      const absolutePath = join(current.absolutePath, child.name)
+      try {
+        const info = await stat(absolutePath)
+        if (info.isDirectory()) {
+          if (shouldSkipSearchDirectory(child.name)) continue
+          const resolvedPath = await realpath(absolutePath)
+          if (current.ancestorReals.has(resolvedPath)) continue
+          const childMount = findMountForPath(mounts, resolvedPath) ?? current.mount
+          if (childMount && childMount.mountPoint !== current.mount?.mountPoint) {
+            const probe = await classifyMount(childMount)
+            if (probe?.slow) continue
+          }
+          const entry: IndexedEntry = {
+            absolutePath,
+            relativePath: normalizeRelativePath(relative(root, absolutePath)),
+            fileName: child.name,
+            kind: "directory",
+          }
+          onEntry(entry)
+          const ancestorReals = new Set(current.ancestorReals)
+          ancestorReals.add(resolvedPath)
+          stack.push({ absolutePath, ancestorReals, mount: childMount })
+          continue
+        }
+        if (info.isFile()) {
+          onEntry({
+            absolutePath,
+            relativePath: normalizeRelativePath(relative(root, absolutePath)),
+            fileName: child.name,
+            kind: "file",
+          })
+        }
+      } catch {
+        continue
+      }
+    }
+  }
+}

package/src/tui/file-search.worker.ts

@@ -0,0 +1,127 @@
+/// <reference lib="webworker" />
+import { crawlWorkspaceEntries, searchEntries, searchResultSignature, type IndexedEntry } from "./file-search"
+import { FILE_SEARCH_RESULT_LIMIT, type FileSearchEvent, type FileSearchRequest } from "./file-search-protocol"
+
+type WorkerSession = {
+  sessionId: string
+  workspaceRoot: string
+  resultLimit: number
+  latestQuery: string
+  queryActive: boolean
+  walkComplete: boolean
+  disposed: boolean
+  entries: IndexedEntry[]
+  pendingNotify: ReturnType<typeof setTimeout> | null
+  lastSignature: string | null
+  completedQuery: string | null
+  rootError: string | null
+}
+
+const sessions = new Map<string, WorkerSession>()
+
+const emit = (event: FileSearchEvent) => postMessage(event)
+const emitError = (session: WorkerSession, message: string) => emit({
+  type: "error",
+  sessionId: session.sessionId,
+  query: session.latestQuery,
+  message,
+})
+
+const emitCompleteIfNeeded = (session: WorkerSession) => {
+  if (!session.walkComplete || !session.queryActive || session.completedQuery === session.latestQuery) return
+  session.completedQuery = session.latestQuery
+  emit({ type: "complete", sessionId: session.sessionId, query: session.latestQuery })
+}
+
+const recompute = (session: WorkerSession) => {
+  if (session.disposed || !session.queryActive) return
+  const matches = searchEntries(session.entries, session.latestQuery, session.resultLimit)
+  const signature = searchResultSignature(session.latestQuery, matches, session.walkComplete)
+  if (signature !== session.lastSignature) {
+    session.lastSignature = signature
+    emit({
+      type: "update",
+      sessionId: session.sessionId,
+      query: session.latestQuery,
+      matches,
+      walkComplete: session.walkComplete,
+    })
+  }
+  emitCompleteIfNeeded(session)
+}
+
+const scheduleRecompute = (session: WorkerSession) => {
+  if (session.disposed || !session.queryActive || session.pendingNotify !== null) return
+  session.pendingNotify = setTimeout(() => {
+    session.pendingNotify = null
+    recompute(session)
+  }, 12)
+}
+
+const createSession = async (request: Extract<FileSearchRequest, { type: "create-session" }>) => {
+  const previous = sessions.get(request.sessionId)
+  if (previous) {
+    previous.disposed = true
+    if (previous.pendingNotify) clearTimeout(previous.pendingNotify)
+    sessions.delete(request.sessionId)
+  }
+  const session: WorkerSession = {
+    sessionId: request.sessionId,
+    workspaceRoot: request.workspaceRoot,
+    resultLimit: request.resultLimit ?? FILE_SEARCH_RESULT_LIMIT,
+    latestQuery: "",
+    queryActive: false,
+    walkComplete: false,
+    disposed: false,
+    entries: [],
+    pendingNotify: null,
+    lastSignature: null,
+    completedQuery: null,
+    rootError: null,
+  }
+  sessions.set(session.sessionId, session)
+
+  try {
+    await crawlWorkspaceEntries(session.workspaceRoot, entry => {
+      if (session.disposed) return
+      session.entries.push(entry)
+      scheduleRecompute(session)
+    })
+    session.walkComplete = true
+    recompute(session)
+  } catch (error) {
+    session.rootError = error instanceof Error ? error.message : `${error}`
+    session.walkComplete = true
+    emitError(session, session.rootError)
+  }
+}
+
+const updateQuery = (request: Extract<FileSearchRequest, { type: "update-query" }>) => {
+  const session = sessions.get(request.sessionId)
+  if (!session || session.disposed) return
+  session.latestQuery = request.query
+  session.queryActive = true
+  session.completedQuery = null
+  session.lastSignature = null
+  if (session.rootError) {
+    emitError(session, session.rootError)
+    return
+  }
+  recompute(session)
+}
+
+const disposeSession = (request: Extract<FileSearchRequest, { type: "dispose-session" }>) => {
+  const session = sessions.get(request.sessionId)
+  if (!session) return
+  session.disposed = true
+  if (session.pendingNotify) clearTimeout(session.pendingNotify)
+  sessions.delete(request.sessionId)
+}
+
+self.onmessage = (event: MessageEvent<FileSearchRequest>) => {
+  const request = event.data
+  if (!request || typeof request !== "object") return
+  if (request.type === "create-session") void createSession(request)
+  if (request.type === "update-query") updateQuery(request)
+  if (request.type === "dispose-session") disposeSession(request)
+}

package/src/tui/rezi-checkbox-click.ts

@@ -0,0 +1,63 @@
+import { WidgetRenderer } from "../../node_modules/@rezi-ui/core/dist/app/widgetRenderer.js"
+
+const PATCH_FLAG = Symbol.for("send.rezi.checkboxClickPatchInstalled")
+const CLICKABLE_CHECKBOX_IDS = Symbol.for("send.rezi.checkboxClickPressableIds")
+
+type CheckboxProps = {
+  checked: boolean
+  disabled?: boolean
+  onChange?: (checked: boolean) => void
+}
+
+type CheckboxRuntime = {
+  checkboxById: Map<string, CheckboxProps>
+  pressableIds: Set<string>
+  [CLICKABLE_CHECKBOX_IDS]?: Set<string>
+}
+
+type PatchedWidgetRendererClass = typeof WidgetRenderer & {
+  [PATCH_FLAG]?: boolean
+}
+
+const syncClickableCheckboxIds = (renderer: CheckboxRuntime) => {
+  const nextIds = new Set<string>()
+  for (const [id, checkbox] of renderer.checkboxById) {
+    if (checkbox.disabled === true || typeof checkbox.onChange !== "function") continue
+    nextIds.add(id)
+  }
+  const previousIds = renderer[CLICKABLE_CHECKBOX_IDS] ?? new Set<string>()
+  for (const id of previousIds) {
+    if (!nextIds.has(id)) renderer.pressableIds.delete(id)
+  }
+  for (const id of nextIds) renderer.pressableIds.add(id)
+  renderer[CLICKABLE_CHECKBOX_IDS] = nextIds
+}
+
+export const installCheckboxClickPatch = () => {
+  const WidgetRendererClass = WidgetRenderer as PatchedWidgetRendererClass
+  if (WidgetRendererClass[PATCH_FLAG]) return
+  WidgetRendererClass[PATCH_FLAG] = true
+
+  const originalRouteEngineEvent = WidgetRenderer.prototype.routeEngineEvent as any
+
+  WidgetRenderer.prototype.routeEngineEvent = function (this: unknown, event: any) {
+    const renderer = this as CheckboxRuntime
+    syncClickableCheckboxIds(renderer)
+    const result = originalRouteEngineEvent.call(this, event) as any
+    const action = result?.action
+    if (event.kind !== "mouse" || !action || action.action !== "press") return result
+    const checkbox = renderer.checkboxById.get(action.id)
+    if (!checkbox || checkbox.disabled === true || typeof checkbox.onChange !== "function") return result
+    const nextChecked = !checkbox.checked
+    checkbox.onChange(nextChecked)
+    return Object.freeze({
+      ...result,
+      needsRender: true,
+      action: Object.freeze({
+        id: action.id,
+        action: "toggle",
+        checked: nextChecked,
+      }),
+    })
+  } as any
+}

package/src/types/bun-runtime.d.ts

@@ -0,0 +1,5 @@
+declare const Bun: {
+  file(path: string): Blob & { type: string }
+  write(path: string, data: string | Blob | ArrayBuffer | ArrayBufferView): Promise<number>
+  sleep(ms: number): Promise<void>
+}

package/src/types/bun-test.d.ts

@@ -0,0 +1,9 @@
+declare module "bun:test" {
+  export const describe: (label: string, fn: () => void) => void
+  export const test: (label: string, fn: () => void | Promise<void>) => void
+  export const expect: (value: unknown) => {
+    toBe(expected: unknown): void
+    toEqual(expected: unknown): void
+    toContain(expected: unknown): void
+  }
+}