opencode-extended-sidebar 0.2.90

package/src/pware.oc.core/pware.oc.core.layout.ts

@@ -0,0 +1,234 @@
+/**
+ * Vertical row budget for the sidebar. Pure — no OpenTUI, unit tested directly.
+ * Same idea as `packChips` in pulse.ts, one axis over: under pressure the worst
+ * rank gives up rows first, and nothing drops below its `min` until every
+ * section has already reached it.
+ */
+
+/**
+ * Rows OpenCode's own TUI takes around the `sidebar_content` slot. Measured
+ * from the opencode TUI source (`packages/tui/src/routes/session/sidebar.tsx`,
+ * stable across v1.18.27 = HEAD): the sidebar column has no border — its frame
+ * is `paddingTop` 1 + a fixed footer (`sidebar_footer`, outside the scrollbox:
+ * 1 spacer + path row + 1 gap + version row) + `paddingBottom` 1.
+ */
+const HOST_SIDEBAR_CHROME = 6
+
+/**
+ * Rows the host's `sidebar_title` fallback block (same scrollbox, above the
+ * content slot) takes before the plugin's first content row: a typical session
+ * shows a bold title + workspace (2 rows) plus the 1-row `gap` separator, and
+ * a wrapping title or the optional channel/share lines add more. Kept at 4 so
+ * `PANEL_CHROME` still covers the old flat-10 headroom.
+ */
+const HOST_SIDEBAR_TITLE_RESERVE = 4
+
+/** Fixed chrome the sidebar slot's own host takes above the content rows. */
+const PANEL_CHROME = HOST_SIDEBAR_CHROME + HOST_SIDEBAR_TITLE_RESERVE
+const PANEL_MIN_ROWS = 8
+
+/** Shared right rail for context actions (`switch new`, `view all`, …). */
+export const CONTEXT_ACTION_COL_WIDTH = 10
+
+/**
+ * Row width budget before the root box reports its measured layout width.
+ * `lineMax` used to be an oes.json option; it is now measured, and this is the
+ * pre-layout fallback (matches the old default).
+ */
+export const ROW_LINE_FALLBACK = 31
+
+/** Columns subtracted from the measured root width for the scrollbar reserve. */
+export const ROW_LINE_RESERVE = 1
+
+/** Realtime charts link on the OES row (`C` → fullscreen dialog). */
+export const RT_ACTION_COL_WIDTH = 1
+
+/** Compact sparkline body rows — sidebar inline chart removed; kept for docs/tests. */
+export const RT_CHART_ROWS = 3
+
+/** Per-series sparkline body rows in the realtime fullscreen dialog. */
+export const RT_DIALOG_CHART_ROWS = 8
+
+/**
+ * Host `api.ui.Dialog` inner box widths (`packages/opencode/.../dialog.tsx`).
+ * `maxWidth` is `terminal − 2`. `xlarge` is 116 on hosts that implement it
+ * (#44754); older builds only switch `large` (80) vs else (60).
+ */
+export const HOST_DIALOG_OUTER_WIDTH = { medium: 60, large: 80, xlarge: 116 } as const
+export type HostDialogSize = keyof typeof HOST_DIALOG_OUTER_WIDTH
+
+/** `maxWidth={dimensions().width - 2}` on the host inner box. */
+const HOST_DIALOG_MAX_INSET = 2
+/** `DialogPad` left + right, matching the host dialog bodies (`paddingLeft/Right 2`). */
+const DIALOG_PAD_X = 4
+
+/**
+ * Columns inside the padded dialog body. Subtracts the host box cap, the
+ * `maxWidth` inset, and DialogPad — this is the line budget a chart may use,
+ * including the asciiTrend min/max labels on the left of each row.
+ */
+export function dialogInnerWidth(termWidth: number, size: HostDialogSize): number {
+  const w = Number.isFinite(termWidth) && termWidth > 0 ? Math.floor(termWidth) : 80
+  const outer = Math.min(HOST_DIALOG_OUTER_WIDTH[size], Math.max(1, w - HOST_DIALOG_MAX_INSET))
+  return Math.max(8, outer - DIALOG_PAD_X)
+}
+
+/**
+ * One right-aligned action line padded to {@link CONTEXT_ACTION_COL_WIDTH}.
+ * Long labels keep their trailing characters so `view all` still fits the rail.
+ */
+export function contextActionsLine(labels: readonly string[]): string {
+  const text = labels.join(" ")
+  if (text.length >= CONTEXT_ACTION_COL_WIDTH) return text.slice(-CONTEXT_ACTION_COL_WIDTH)
+  return text.padStart(CONTEXT_ACTION_COL_WIDTH)
+}
+
+/** Usable rows in the sidebar slot for a terminal that tall. */
+export function panelRows(termHeight: number): number {
+  const h = Number.isFinite(termHeight) && termHeight > 0 ? termHeight : 24
+  return Math.max(PANEL_MIN_ROWS, Math.floor(h) - PANEL_CHROME)
+}
+
+/** Rows a section keeps before it is worth folding instead. */
+export const ROW_MIN = {
+  delegates: 2,
+  drafts: 2,
+  files: 3,
+  mywork: 2,
+  tools: 3,
+} as const
+
+/**
+ * Higher gives up rows first. Live activity outranks history: on Current the
+ * tool feed survives longest. My work is a queue of things awaiting the user,
+ * so it ties with the live feed.
+ */
+export const ROW_RANK = {
+  delegates: 3,
+  drafts: 3,
+  files: 2,
+  mywork: 1,
+  tools: 1,
+} as const
+
+export type Section<K extends string = string> = {
+  key: K
+  /** Rows the section would like — usually the matching `oes.json` value. */
+  want: number
+  min: number
+  rank: number
+}
+
+/**
+ * Split `budget - fixed` rows across the sections. Ties are broken by whoever
+ * currently holds the most rows, so equal ranks shrink together. A section that
+ * hits `min` while the budget is still short is handed `0` — the caller folds
+ * it rather than rendering a stub.
+ */
+export function packSections<K extends string>(
+  budget: number,
+  fixed: number,
+  sections: readonly Section<K>[],
+): Record<K, number> {
+  const live = sections.map((s) => {
+    const min = Math.max(0, Math.round(s.min))
+    return { key: s.key, min, rank: s.rank, rows: Math.max(min, Math.max(0, Math.round(s.want))) }
+  })
+  const available = Math.max(0, Math.round(budget) - Math.round(fixed))
+  const total = () => live.reduce((sum, s) => sum + s.rows, 0)
+
+  const worstAbove = (floor: (s: (typeof live)[number]) => number): number => {
+    let worst = -1
+    for (let i = 0; i < live.length; i += 1) {
+      const s = live[i]!
+      if (s.rows <= floor(s)) continue
+      const best = worst < 0 ? null : live[worst]!
+      if (!best || s.rank > best.rank || (s.rank === best.rank && s.rows > best.rows)) worst = i
+    }
+    return worst
+  }
+
+  while (total() > available) {
+    const i = worstAbove((s) => s.min)
+    if (i < 0) break
+    live[i]!.rows -= 1
+  }
+
+  // Everyone is at their minimum and it still does not fit: fold, worst first.
+  while (total() > available) {
+    const i = worstAbove(() => 0)
+    if (i < 0) break
+    live[i]!.rows = 0
+  }
+
+  const out = {} as Record<K, number>
+  for (const s of live) out[s.key] = s.rows
+  return out
+}
+
+/**
+ * Look up a packed section. A missing plan (Solid memo still computing,
+ * previous compute threw, owner disposed) or a missing / non-finite key
+ * returns `fallback` — the sidebar slot must not die on `plan[key]`.
+ */
+export function rowsForPlan(
+  plan: Readonly<Record<string, number>> | null | undefined,
+  key: string,
+  fallback: number,
+): number {
+  if (!plan || typeof plan !== "object") return fallback
+  const v = plan[key]
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback
+}
+
+/**
+ * Show `shown` rows and report how many a "more" control can still reveal.
+ * The expander is a separate clickable line (`RowList`) the caller renders
+ * below the list — no row is spent on the note.
+ */
+export function sliceShown<T>(
+  rows: readonly T[],
+  shown: number,
+): { rows: T[]; hidden: number } {
+  const s = Math.max(0, Math.round(shown))
+  const kept = rows.slice(0, s)
+  return { rows: kept, hidden: Math.max(0, rows.length - kept.length) }
+}
+
+/**
+ * Whether the "… +N more" / "… less" line is drawn at all. The expanded toggle
+ * keeps its "… less" line even when nothing is hidden; otherwise the line
+ * vanishes the moment there is nothing left to reveal.
+ */
+export function moreRevealVisible(hidden: number, expanded?: boolean): boolean {
+  return expanded === true || hidden > 0
+}
+
+/**
+ * Clamp a scroll offset into the window a `visible`-row view can show over
+ * `total` rows: the offset never goes below 0 or past the last full window.
+ */
+export function clampScrollOffset(total: number, visible: number, offset: number): number {
+  const t = Math.max(0, Math.round(total))
+  const v = Math.max(1, Math.round(visible))
+  const max = Math.max(0, t - v)
+  const o = Math.max(0, Math.round(offset))
+  return Math.min(o, max)
+}
+
+/**
+ * Move a scroll offset by one wheel `step`. Newest-first lists count the offset
+ * from the newest row, so "down" goes toward older rows and "up" back to the
+ * newest. The result stays inside the same clamped window as `clampScrollOffset`.
+ */
+export function scrollByStep(
+  total: number,
+  visible: number,
+  offset: number,
+  direction: "up" | "down",
+  step: number,
+): number {
+  const s = Math.max(1, Math.round(step))
+  const next = direction === "down" ? offset + s : offset - s
+  return clampScrollOffset(total, visible, next)
+}

package/src/pware.oc.core/pware.oc.core.oes.ts

@@ -0,0 +1,89 @@
+/**
+ * oes.json — OpenCode Extended Sidebar options.
+ * Merge: plugin defaults < ~/.config/opencode/oes.json < <project>/oes.json
+ */
+import path from "node:path"
+import { fileStamp, getOpenCodeConfigDir, pluginRoot, readJson } from "./pware.oc.core.paths.js"
+import { createStampCache } from "./pware.oc.core.cache.js"
+
+export type OesOptions = {
+  fileRows: number
+  /** Sessions compared under Perf → History. 0 hides the section. */
+  perfHistory: number
+  /** Rows per Perf section (models, tools, history). */
+  perfRows: number
+  /** How many recent turns Perf scans. Higher = longer history, slower read. */
+  perfTurns: number
+  /** Seconds between full open-question rescans when no event-driven hint arrives. */
+  questionReconcileSec: number
+  /** Sessions fetched for the recent-sessions window. */
+  sessionFetch: number
+  /** Hide Files that match the project's root .gitignore. Off by default. */
+  skipGitignore: boolean
+  toolRows: number
+  /** Tool-call history kept for the feed's `… +N more` revealer. Distinct from `toolRows`. */
+  toolFetch: number
+}
+
+export const OES_DEFAULTS: OesOptions = {
+  fileRows: 8,
+  perfHistory: 3,
+  perfRows: 5,
+  perfTurns: 120,
+  questionReconcileSec: 15,
+  sessionFetch: 20,
+  skipGitignore: false,
+  toolRows: 5,
+  toolFetch: 20,
+}
+
+function pluginOesPath(): string {
+  return path.join(pluginRoot(), "oes.json")
+}
+
+function clamp(n: unknown, min: number, max: number, fallback: number): number {
+  if (typeof n !== "number" || !Number.isFinite(n)) return fallback
+  return Math.round(Math.min(max, Math.max(min, n)))
+}
+
+/** Merge one oes.json object onto a base. Exported for tests. */
+export function pick(raw: Record<string, unknown> | null, base: OesOptions): OesOptions {
+  if (!raw) return base
+  const toolRows = clamp(raw.toolRows, 3, 20, base.toolRows)
+  return {
+    fileRows: clamp(raw.fileRows, 3, 20, base.fileRows),
+    perfHistory: clamp(raw.perfHistory, 0, 10, base.perfHistory),
+    perfRows: clamp(raw.perfRows, 3, 20, base.perfRows),
+    perfTurns: clamp(raw.perfTurns, 20, 500, base.perfTurns),
+    questionReconcileSec: clamp(raw.questionReconcileSec, 5, 300, base.questionReconcileSec),
+    sessionFetch: clamp(raw.sessionFetch, 2, 80, base.sessionFetch),
+    skipGitignore: typeof raw.skipGitignore === "boolean" ? raw.skipGitignore : base.skipGitignore,
+    toolRows,
+    toolFetch: clamp(raw.toolFetch, toolRows, 80, base.toolFetch),
+  }
+}
+
+export function oesPaths(projectRoot?: string | null): string[] {
+  const out = [pluginOesPath(), path.join(getOpenCodeConfigDir(), "oes.json")]
+  if (projectRoot) out.push(path.join(projectRoot, "oes.json"))
+  return out
+}
+
+export function oesStamp(projectRoot?: string | null): string {
+  return oesPaths(projectRoot).map(fileStamp).join("|")
+}
+
+const oesCache = createStampCache<OesOptions>()
+
+/** Drop the merged-options cache so the next getOes re-reads files. */
+export function resetOesCache(): void {
+  oesCache.reset()
+}
+
+export function getOes(projectRoot?: string | null): OesOptions {
+  return oesCache.get(oesStamp(projectRoot), () => {
+    let next = { ...OES_DEFAULTS }
+    for (const p of oesPaths(projectRoot)) next = pick(readJson(p), next)
+    return next
+  })
+}

package/src/pware.oc.core/pware.oc.core.paths.ts

@@ -0,0 +1,240 @@
+/**
+ * Resolve OpenCode data paths (XDG + Windows + OPENCODE_DB_PATH).
+ * Zero deps — node:fs / path / os only.
+ */
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+export type Env = Record<string, string | undefined>
+
+/** Absolute path to the plugin's root directory (one level above `src/`). */
+export function pluginRoot(): string {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..")
+}
+
+export function getDataDir(env: Env = process.env, homedir = os.homedir()): string {
+  let dataDir = env.XDG_DATA_HOME
+  if (dataDir) {
+    if (dataDir === "~") dataDir = homedir
+    else if (dataDir.startsWith("~/") || dataDir.startsWith("~\\")) {
+      dataDir = path.join(homedir, dataDir.slice(2).replace(/[\\/]+/g, path.sep))
+    }
+  }
+  return dataDir ?? path.join(homedir, ".local", "share")
+}
+
+export function getOpenCodeConfigDir(env: Env = process.env, homedir = os.homedir()): string {
+  const xdg = env.XDG_CONFIG_HOME
+  if (xdg) {
+    const root = xdg === "~" ? homedir : xdg.startsWith("~/") || xdg.startsWith("~\\")
+      ? path.join(homedir, xdg.slice(2).replace(/[\\/]+/g, path.sep))
+      : xdg
+    return path.join(root, "opencode")
+  }
+  return path.join(homedir, ".config", "opencode")
+}
+
+export function getOpenCodeRoot(env: Env = process.env, homedir = os.homedir()): string {
+  return path.join(getDataDir(env, homedir), "opencode")
+}
+
+/** Local agentize DB path relative to a project root, or null when absent. */
+export function localAgentizeDbPath(projectRoot: string): string | null {
+  const p = path.join(projectRoot, ".agentize", "opencode", "opencode.db")
+  return fs.existsSync(p) ? p : null
+}
+
+/**
+ * Resolve the opencode.db path — mirrors opencode's own resolution
+ * (`packages/opencode/src/storage/db.ts`): `OPENCODE_DB` first, then the
+ * XDG / home-based global path. agentize pins the exact DB with
+ * `OPENCODE_DB` (an absolute path), so it must win over the heuristics.
+ *
+ * Priority:
+ *   1. OPENCODE_DB env var (absolute → verbatim; relative → under the data dir)
+ *   2. OPENCODE_DB_PATH env var (legacy alias)
+ *   3. .agentize/opencode/opencode.db under projectRoot (when supplied)
+ *   4. XDG / home-based global path
+ */
+export function getOpenCodeDbPath(
+  env: Env = process.env,
+  homedir = os.homedir(),
+  projectRoot?: string | null,
+): string {
+  const db = env.OPENCODE_DB
+  if (db && db !== ":memory:") {
+    return path.isAbsolute(db)
+      ? path.resolve(db)
+      : path.join(getOpenCodeRoot(env, homedir), db)
+  }
+  if (env.OPENCODE_DB_PATH) return path.resolve(env.OPENCODE_DB_PATH)
+  if (projectRoot) {
+    const local = localAgentizeDbPath(projectRoot)
+    if (local) return local
+  }
+  return path.join(getOpenCodeRoot(env, homedir), "opencode.db")
+}
+
+export function getSessionDiffPath(
+  sessionId: string,
+  env: Env = process.env,
+  homedir = os.homedir(),
+): string {
+  return path.join(getOpenCodeRoot(env, homedir), "storage", "session_diff", `${sessionId}.json`)
+}
+
+export function realpathSafe(p: string): string | null {
+  try {
+    return fs.realpathSync(p)
+  } catch {
+    return null
+  }
+}
+
+/** Last path segment. Never a directory. */
+export function basenameOf(p: string): string {
+  const t = p.replace(/\\/g, "/").replace(/\/+$/, "").trim()
+  if (!t) return "file"
+  const i = t.lastIndexOf("/")
+  const base = i >= 0 ? t.slice(i + 1) : t
+  return base || "file"
+}
+
+/** Positive finite number, else 0. */
+export function finiteNum(v: unknown): number {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0
+}
+
+/** Trimmed non-empty string, else null. */
+export function str(v: unknown): string | null {
+  if (typeof v === "string" && v.trim()) return v.trim()
+  return null
+}
+
+export function canonicalizePath(p: string): string {
+  const resolved = path.resolve(p)
+  return path.normalize(realpathSafe(resolved) ?? resolved)
+}
+
+/**
+ * OpenCode/git often emit posix paths (`D:/a/b` or `/d/a/b`).
+ * Fold those onto the host path so Windows `D:\` matches.
+ */
+export function normalizeIncomingPath(p: string): string {
+  let t = p.trim().replace(/\\/g, "/")
+  const m = t.match(/^\/([A-Za-z])\/(.*)$/)
+  if (m) t = `${m[1]}:/${m[2]}`
+  return t
+}
+
+/**
+ * Fold an absolute path/directory into one comparison key so two spellings of
+ * the same location compare equal: posix separators (`D:/` and `D:\`), a
+ * git-bash drive prefix (`/d/…`), trailing slashes, and drive-letter case
+ * (`d:/` from git-bash vs `D:/`). Path case is folded only on Windows, where
+ * the filesystem is case-insensitive.
+ */
+export function foldPathKey(p: string | null | undefined): string {
+  if (!p) return ""
+  let t = normalizeIncomingPath(p).replace(/\/+$/, "")
+  const drive = t.match(/^([a-z]):\//)
+  if (drive) t = `${drive[1]!.toUpperCase()}:${t.slice(2)}`
+  return process.platform === "win32" ? t.toLowerCase() : t
+}
+
+/** True when two directory/file paths point at the same location. */
+export function samePath(a: string | null | undefined, b: string | null | undefined): boolean {
+  return foldPathKey(a) === foldPathKey(b)
+}
+
+function isInsideRoot(root: string, abs: string): boolean {
+  const rel = path.relative(root, abs)
+  if (!rel || path.isAbsolute(rel)) return false
+  const n = rel.replace(/\\/g, "/")
+  if (n === ".." || n.startsWith("../")) return false
+  return true
+}
+
+function asRootList(roots: string | readonly string[] | null | undefined): string[] {
+  if (!roots) return []
+  const list = typeof roots === "string" ? [roots] : [...roots]
+  const out: string[] = []
+  const seen = new Set<string>()
+  for (const r of list) {
+    if (!r || typeof r !== "string") continue
+    let key = r
+    try {
+      key = canonicalizePath(r)
+    } catch {
+      key = r
+    }
+    const fold = process.platform === "win32" ? key.toLowerCase() : key
+    if (seen.has(fold)) continue
+    seen.add(fold)
+    out.push(r)
+  }
+  return out
+}
+
+/** Absolute path + project-relative posix path, or null if outside / missing. */
+export function resolveProjectFile(
+  roots: string | readonly string[] | null | undefined,
+  filePath: string | null | undefined,
+): { abs: string; rel: string } | null {
+  if (!filePath) return null
+  const incoming = normalizeIncomingPath(filePath)
+  for (const rawRoot of asRootList(roots)) {
+    try {
+      const root = canonicalizePath(rawRoot)
+      const abs = path.isAbsolute(incoming)
+        ? canonicalizePath(incoming)
+        : canonicalizePath(path.join(root, incoming))
+      if (!isInsideRoot(root, abs)) continue
+      if (!fs.existsSync(abs)) continue
+      const rel = path.relative(root, abs).replace(/\\/g, "/")
+      if (!rel) continue
+      return { abs, rel }
+    } catch {
+      // next root
+    }
+  }
+  return null
+}
+
+/** Project-relative path for detail dialogs — never escapes above project root. */
+export function relativeProjectPath(
+  projectRoot: string | null | undefined,
+  filePath: string | null | undefined,
+): string | null {
+  return resolveProjectFile(projectRoot, filePath)?.rel ?? null
+}
+
+/** Read a JSON file as a plain object, soft-failing to null (missing / invalid / non-object). */
+export function readJson(p: string): Record<string, unknown> | null {
+  try {
+    if (!fs.existsSync(p)) return null
+    const raw = JSON.parse(fs.readFileSync(p, "utf8"))
+    return raw && typeof raw === "object" && !Array.isArray(raw)
+      ? (raw as Record<string, unknown>)
+      : null
+  } catch {
+    return null
+  }
+}
+
+export function fileStamp(p: string | null | undefined): string {
+  if (!p) return "0"
+  try {
+    const st = fs.statSync(p)
+    return `${st.mtimeMs}:${st.size}`
+  } catch {
+    return "0"
+  }
+}
+
+/** DB + WAL/SHM stamps — WAL writers change companion files, not always .db mtime. */
+export function dbStamp(dbPath: string): string {
+  return [dbPath, `${dbPath}-wal`, `${dbPath}-shm`].map(fileStamp).join("|")
+}

package/src/pware.oc.core/pware.oc.core.preview.ts

@@ -0,0 +1,74 @@
+/**
+ * File preview helpers (no OpenTUI). Unit tests import this, not the dialogs
+ * module (pware.oc.ui.menudialogs.tsx).
+ */
+import fs from "node:fs"
+import path from "node:path"
+
+const PREVIEW_MAX_LINES = 200
+const PREVIEW_MAX_BYTES = 128_000
+/** DialogPad bottom 1 + header 2 + footer 2 + slack 1. Extra is the optional relative-path line. */
+const PREVIEW_CHROME = 6
+const PREVIEW_MIN_ROWS = 8
+
+const PREVIEW_EXT = new Set([
+  ".md",
+  ".txt",
+  ".json",
+  ".jsonc",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".xml",
+  ".html",
+  ".css",
+  ".scss",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".sh",
+  ".py",
+  ".rs",
+  ".go",
+  ".sql",
+  ".csv",
+])
+
+export function previewViewportRows(termHeight: number, extraChrome = 0, tall = false): number {
+  const h = Number.isFinite(termHeight) && termHeight > 0 ? termHeight : 24
+  const ratio = tall ? 0.9 : 0.75
+  const min = tall ? 12 : PREVIEW_MIN_ROWS
+  return Math.max(min, Math.floor(h * ratio) - PREVIEW_CHROME - extraChrome)
+}
+
+export function canPreviewPath(filePath: string): boolean {
+  const ext = path.extname(filePath).toLowerCase()
+  return PREVIEW_EXT.has(ext)
+}
+
+export function isMarkdownPath(filePath: string): boolean {
+  return path.extname(filePath).toLowerCase() === ".md"
+}
+
+export function readTextPreview(absPath: string): { text: string; truncated: boolean } | null {
+  try {
+    const st = fs.statSync(absPath)
+    if (!st.isFile()) return null
+    const buf = fs.readFileSync(absPath)
+    const slice = buf.subarray(0, Math.min(buf.length, PREVIEW_MAX_BYTES))
+    if (slice.includes(0)) return null
+    let text = slice.toString("utf8")
+    const lines = text.split(/\r?\n/)
+    let truncated = buf.length > PREVIEW_MAX_BYTES
+    if (lines.length > PREVIEW_MAX_LINES) {
+      text = lines.slice(0, PREVIEW_MAX_LINES).join("\n")
+      truncated = true
+    }
+    return { text, truncated }
+  } catch {
+    return null
+  }
+}