opencode-extended-sidebar 0.2.90

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

@@ -0,0 +1,237 @@
+/**
+ * Read-only git status for Files letters. No repo / no git → empty, never throws.
+ * Status is scoped to the listed paths — never the whole worktree.
+ * Spawn is async: the TUI keeps the last letters until git returns.
+ */
+import { spawn } from "node:child_process"
+import fs from "node:fs"
+import path from "node:path"
+import { fileStamp } from "../pware.oc.core.paths.js"
+
+/** Porcelain XY letters only. `?` is untracked. Do not invent extras here. */
+export type GitLetter = "M" | "A" | "D" | "R" | "C" | "U" | "T" | "?"
+
+const GIT_PATH_CAP = 40
+const GIT_DEBOUNCE_MS = 2500
+const GIT_TIMEOUT_MS = 1500
+
+export function findGitRoot(start?: string | null): string | null {
+  if (!start) return null
+  let dir = path.resolve(start)
+  for (let i = 0; i < 16; i++) {
+    try {
+      if (fs.existsSync(path.join(dir, ".git"))) return dir
+    } catch {
+      return null
+    }
+    const parent = path.dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return null
+}
+
+export function gitStatusStamp(projectRoot?: string | null): string {
+  const root = findGitRoot(projectRoot)
+  if (!root) return "0"
+  return [fileStamp(path.join(root, ".git")), fileStamp(path.join(root, ".git", "HEAD")), fileStamp(path.join(root, ".git", "index"))].join("|")
+}
+
+function porcelainLetter(xy: string): GitLetter | null {
+  if (xy === "??") return "?"
+  if (xy === "!!") return null
+  const x = xy[0] ?? " "
+  const y = xy[1] ?? " "
+  if (x === "U" || y === "U" || xy === "AA" || xy === "DD") return "U"
+  const rank = (c: string): GitLetter | null => {
+    if (c === "D") return "D"
+    if (c === "R") return "R"
+    if (c === "C") return "C"
+    if (c === "A") return "A"
+    if (c === "T") return "T"
+    if (c === "M") return "M"
+    return null
+  }
+  return rank(x) ?? rank(y)
+}
+
+function xIsRename(x: string): boolean {
+  return x === "R" || x === "C"
+}
+
+/** Parse `git status --porcelain -z` stdout. Exported for tests. */
+export function parsePorcelainZ(buf: string): Map<string, GitLetter> {
+  const out = new Map<string, GitLetter>()
+  let i = 0
+  while (i < buf.length) {
+    const xy = buf.slice(i, i + 2)
+    if (xy.length < 2) break
+    i += 2
+    if (buf[i] === " ") i += 1
+    const z = buf.indexOf("\0", i)
+    if (z < 0) break
+    const p1 = buf.slice(i, z).replace(/\\/g, "/")
+    i = z + 1
+    if (xIsRename(xy[0] ?? "")) {
+      const z2 = buf.indexOf("\0", i)
+      if (z2 >= 0) i = z2 + 1
+    }
+    const letter = porcelainLetter(xy)
+    if (letter && p1) out.set(p1.toLowerCase(), letter)
+  }
+  return out
+}
+
+export function relToGitRoot(posixPath: string, root: string): string {
+  const file = posixPath.replace(/\\/g, "/")
+  const base = root.replace(/\\/g, "/").replace(/\/+$/, "")
+  const lower = file.toLowerCase()
+  const rootLower = base.toLowerCase()
+  if (lower.startsWith(`${rootLower}/`)) return lower.slice(rootLower.length + 1)
+  return lower.replace(/^\.\//, "")
+}
+
+/** Pathspecs for `git status`: repo paths only, deduped, capped. Exported for tests. */
+export function relsFrom(posixPaths: string[], root: string): string[] {
+  const base = root.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase()
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const p of posixPaths) {
+    const file = p.replace(/\\/g, "/")
+    // git aborts the whole status with exit 128 on a single outside-repo
+    // pathspec — sessions touch temp/config files outside the tree all the time.
+    if (!file.toLowerCase().startsWith(`${base}/`)) continue
+    const rel = relToGitRoot(p, root)
+    if (!rel || seen.has(rel)) continue
+    seen.add(rel)
+    out.push(rel)
+    if (out.length >= GIT_PATH_CAP) break
+  }
+  return out
+}
+
+let cacheKey = ""
+let cacheMarks = new Map<string, GitLetter>()
+let cacheRoot: string | null = null
+let lastPathKey = ""
+let lastSpawn = 0
+let pendingKey = ""
+let spawnGen = 0
+let inFlight = false
+
+const listeners = new Set<() => void>()
+
+function notify(): void {
+  for (const fn of listeners) {
+    try {
+      fn()
+    } catch {
+      // sidebar teardown
+    }
+  }
+}
+
+/** Re-render when an async git status lands. Returns unsubscribe. */
+export function onGitMarksChange(fn: () => void): () => void {
+  listeners.add(fn)
+  return () => {
+    listeners.delete(fn)
+  }
+}
+
+/** Drop cached letters and in-flight spawn accounting (tests). */
+export function resetGitCache(): void {
+  spawnGen += 1
+  inFlight = false
+  cacheKey = ""
+  pendingKey = ""
+  lastPathKey = ""
+  lastSpawn = 0
+  cacheRoot = null
+  cacheMarks = new Map()
+}
+
+function runGit(root: string, rels: string[], key: string, gen: number): void {
+  let child: ReturnType<typeof spawn>
+  try {
+    child = spawn(
+      "git",
+      ["-c", "core.quotepath=false", "status", "--porcelain", "-z", "--", ...rels],
+      { cwd: root, windowsHide: true },
+    )
+  } catch {
+    if (gen === spawnGen) inFlight = false
+    return
+  }
+  let out = ""
+  const timer = setTimeout(() => {
+    try {
+      child.kill()
+    } catch {
+      // already gone
+    }
+  }, GIT_TIMEOUT_MS)
+  child.stdout?.setEncoding("utf8")
+  child.stdout?.on("data", (chunk: string) => {
+    out += chunk
+  })
+  child.stderr?.resume()
+  const finish = (ok: boolean) => {
+    clearTimeout(timer)
+    if (gen !== spawnGen) return
+    inFlight = false
+    cacheRoot = root
+    cacheKey = key
+    if (ok) cacheMarks = parsePorcelainZ(out)
+    notify()
+  }
+  child.on("error", () => finish(false))
+  child.on("close", (code) => finish(code === 0))
+}
+
+/**
+ * Last known porcelain letters. Never waits on git — a stale map is returned
+ * and a spawn is scheduled when the cache key is cold (2.5 s debounce on index noise).
+ */
+export function readGitMarksFor(
+  posixPaths: string[],
+  projectRoot?: string | null,
+): {
+  root: string | null
+  marks: Map<string, GitLetter>
+} {
+  const root = findGitRoot(projectRoot)
+  if (!root || posixPaths.length === 0) {
+    return { root, marks: new Map() }
+  }
+  const rels = relsFrom(posixPaths, root)
+  if (rels.length === 0) {
+    return { root, marks: new Map() }
+  }
+  const pathKey = rels.slice().sort().join("\0")
+  const stamp = gitStatusStamp(projectRoot)
+  const key = `${root}|${stamp}|${pathKey}`
+  cacheRoot = root
+  if (key === cacheKey) return { root, marks: cacheMarks }
+  if (inFlight && pendingKey === key) return { root, marks: cacheMarks }
+
+  const now = Date.now()
+  if (pathKey === lastPathKey && lastSpawn > 0 && now - lastSpawn < GIT_DEBOUNCE_MS) {
+    return { root, marks: cacheMarks }
+  }
+
+  pendingKey = key
+  lastPathKey = pathKey
+  lastSpawn = now
+  spawnGen += 1
+  inFlight = true
+  runGit(root, rels, key, spawnGen)
+  return { root, marks: cacheMarks }
+}
+
+export function gitLetterFor(posixPath: string, projectRoot?: string | null): GitLetter | null {
+  const { root, marks } = readGitMarksFor([posixPath], projectRoot)
+  if (!root || marks.size === 0) return null
+  const rel = relToGitRoot(posixPath, root)
+  return marks.get(rel) ?? marks.get(posixPath.replace(/\\/g, "/").toLowerCase()) ?? null
+}

package/src/pware.oc.core/git/pware.oc.core.gitignore.ts

@@ -0,0 +1,87 @@
+/**
+ * Ignore sources for the Files panel: the project `.gitignore` (only when
+ * `skipGitignore` is on) and `.oesignore` (always, when present). Both use the
+ * `ignore` package for full gitignore semantics.
+ */
+import fs from "node:fs"
+import path from "node:path"
+import ignore from "ignore"
+import { fileStamp } from "../pware.oc.core.paths.js"
+import { createStampCache } from "../pware.oc.core.cache.js"
+
+export function gitignorePath(projectRoot?: string | null): string | null {
+  if (!projectRoot) return null
+  return path.join(projectRoot, ".gitignore")
+}
+
+export function oesignorePath(projectRoot?: string | null): string | null {
+  if (!projectRoot) return null
+  return path.join(projectRoot, ".oesignore")
+}
+
+/** Stamp both ignore files so the fingerprint reloads when either changes. */
+export function gitignoreStamp(projectRoot?: string | null): string {
+  return [gitignorePath(projectRoot), oesignorePath(projectRoot)].map(fileStamp).join("|")
+}
+
+function readIfExists(p: string | null): string | null {
+  if (!p) return null
+  try {
+    if (!fs.existsSync(p)) return null
+    return fs.readFileSync(p, "utf8")
+  } catch {
+    return null
+  }
+}
+
+/** Absolute/relative path folded to a project-relative posix path, or null. */
+function toRelPath(posixFile: string, projectRoot: string): string | null {
+  const root = projectRoot.replace(/\\/g, "/").replace(/\/+$/, "")
+  const file = posixFile.replace(/\\/g, "/").replace(/\/+$/, "")
+  if (!root) return null
+  if (file.toLowerCase().startsWith(`${root.toLowerCase()}/`)) return file.slice(root.length + 1)
+  if (/^[a-z]:\//i.test(file) || file.startsWith("/")) return null
+  return file.replace(/^\.\//, "")
+}
+
+function compile(patterns: string | null): ReturnType<typeof ignore> {
+  const ig = ignore()
+  if (patterns != null) ig.add(patterns)
+  return ig
+}
+
+type IgnoreSet = { gitignore: ReturnType<typeof ignore>; oesignore: ReturnType<typeof ignore> }
+
+const ignoreCache = createStampCache<IgnoreSet>()
+
+function setFor(projectRoot: string): IgnoreSet {
+  return ignoreCache.get(`${projectRoot}|${gitignoreStamp(projectRoot)}`, () => ({
+    gitignore: compile(readIfExists(gitignorePath(projectRoot))),
+    oesignore: compile(readIfExists(oesignorePath(projectRoot))),
+  }))
+}
+
+function ignoredBy(
+  which: keyof IgnoreSet,
+  posixPath: string,
+  projectRoot?: string | null,
+): boolean {
+  if (!projectRoot) return false
+  const rel = toRelPath(posixPath, projectRoot)
+  if (!rel) return false
+  try {
+    return setFor(projectRoot)[which].ignores(rel)
+  } catch {
+    return false
+  }
+}
+
+/** True when the path matches the project's root `.gitignore`. */
+export function ignoredByGitignore(posixPath: string, projectRoot?: string | null): boolean {
+  return ignoredBy("gitignore", posixPath, projectRoot)
+}
+
+/** True when the path matches the project's `.oesignore` (always on when present). */
+export function ignoredByOesignore(posixPath: string, projectRoot?: string | null): boolean {
+  return ignoredBy("oesignore", posixPath, projectRoot)
+}

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

@@ -0,0 +1,18 @@
+/**
+ * pware.oc.core
+ *
+ * Shared infrastructure + pure logic. Core never imports a domain or the UI.
+ */
+export * from "./pware.oc.core.cache.js"
+export * from "./pware.oc.core.clipboard.js"
+export * from "./pware.oc.core.debug.js"
+export * from "./pware.oc.core.events.js"
+export * from "./pware.oc.core.layout.js"
+export * from "./pware.oc.core.oes.js"
+export * from "./pware.oc.core.paths.js"
+export * from "./pware.oc.core.preview.js"
+export * from "./pware.oc.core.pulse.js"
+export * from "./pware.oc.core.sqlite.js"
+export * from "./pware.oc.core.status.js"
+export * from "./pware.oc.core.bus.js"
+export * from "./git/index.js"

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

@@ -0,0 +1,42 @@
+export type PwareEvent = {
+  type: string
+  ts: number
+  data?: unknown
+}
+
+export type PwareEventListener = (evt: PwareEvent) => void
+
+export type PwareEventBus = {
+  emit: (evt: PwareEvent) => void
+  on: (type: string, listener: PwareEventListener) => () => void
+  off: (type: string, listener: PwareEventListener) => void
+}
+
+export function createEventBus(): PwareEventBus {
+  const byType = new Map<string, Set<PwareEventListener>>()
+
+  const off = (type: string, listener: PwareEventListener): void => {
+    const set = byType.get(type)
+    if (!set) return
+    set.delete(listener)
+    if (set.size === 0) byType.delete(type)
+  }
+
+  const on = (type: string, listener: PwareEventListener): (() => void) => {
+    const set = byType.get(type)
+    if (set) {
+      set.add(listener)
+    } else {
+      byType.set(type, new Set([listener]))
+    }
+    return () => off(type, listener)
+  }
+
+  const emit = (evt: PwareEvent): void => {
+    const set = byType.get(evt.type)
+    if (!set || set.size === 0) return
+    for (const listener of set) listener(evt)
+  }
+
+  return { emit, on, off }
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Stamp-keyed in-memory cache. Optional TTL for filesystem snapshots.
+ */
+
+export function createStampCache<T>(opts?: { ttlMs?: number }): {
+  get: (key: string, load: () => T) => T
+  peek: (key: string) => T | undefined
+  set: (key: string, value: T) => void
+  reset: () => void
+} {
+  const ttl = opts?.ttlMs
+  let cacheKey = ""
+  let cached: T | undefined
+  let at = 0
+  return {
+    get(key, load) {
+      const now = Date.now()
+      if (
+        key &&
+        key === cacheKey &&
+        cached !== undefined &&
+        (ttl == null || now - at < ttl)
+      ) {
+        return cached
+      }
+      const next = load()
+      cacheKey = key
+      cached = next
+      at = now
+      return next
+    },
+    peek(key) {
+      if (!key || key !== cacheKey || cached === undefined) return undefined
+      if (ttl != null && Date.now() - at >= ttl) return undefined
+      return cached
+    },
+    set(key, value) {
+      cacheKey = key
+      cached = value
+      at = Date.now()
+    },
+    reset() {
+      cacheKey = ""
+      cached = undefined
+      at = 0
+    },
+  }
+}

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

@@ -0,0 +1,97 @@
+/**
+ * Copy text to the system clipboard without npm deps.
+ * Native tools are async so a click never freezes the TUI.
+ * Windows prefers clip.exe; PowerShell is last resort (slow to start).
+ * OSC 52 is always sent so SSH / remote terminals can still receive the copy.
+ */
+import { spawn } from "node:child_process"
+import os from "node:os"
+
+const COPY_TIMEOUT_MS = 1500
+
+/** Terminal clipboard sequence (OSC 52). Exported for tests. */
+export function osc52Payload(text: string): string {
+  return `\x1b]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`
+}
+
+function writeOsc52(text: string): boolean {
+  try {
+    process.stdout.write(osc52Payload(text))
+    return true
+  } catch {
+    return false
+  }
+}
+
+function pipe(command: string, args: string[], input: string | Buffer): Promise<boolean> {
+  return new Promise((resolve) => {
+    let child: ReturnType<typeof spawn>
+    try {
+      child = spawn(command, args, {
+        windowsHide: true,
+        stdio: ["pipe", "ignore", "ignore"],
+      })
+    } catch {
+      resolve(false)
+      return
+    }
+    let done = false
+    const finish = (ok: boolean) => {
+      if (done) return
+      done = true
+      clearTimeout(timer)
+      resolve(ok)
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill()
+      } catch {
+        // already gone
+      }
+      finish(false)
+    }, COPY_TIMEOUT_MS)
+    child.on("error", () => finish(false))
+    child.on("close", (code) => finish(code === 0))
+    try {
+      if (!child.stdin) {
+        finish(false)
+        return
+      }
+      child.stdin.end(input)
+    } catch {
+      finish(false)
+    }
+  })
+}
+
+/** clip.exe expects UTF-16 LE with BOM for non-ASCII. */
+function clipUtf16(text: string): Buffer {
+  return Buffer.concat([Buffer.from([0xff, 0xfe]), Buffer.from(text, "utf16le")])
+}
+
+export async function copyText(text: string): Promise<boolean> {
+  if (!text) return false
+  const osc = writeOsc52(text)
+  const platform = os.platform()
+  if (platform === "win32") {
+    if (await pipe("clip", [], clipUtf16(text))) return true
+    if (
+      await pipe(
+        "powershell.exe",
+        ["-NoProfile", "-NonInteractive", "-Command", "$input | Set-Clipboard"],
+        text,
+      )
+    ) {
+      return true
+    }
+    return osc
+  }
+  if (platform === "darwin") {
+    if (await pipe("pbcopy", [], text)) return true
+    return osc
+  }
+  if (process.env.WAYLAND_DISPLAY && (await pipe("wl-copy", [], text))) return true
+  if (await pipe("xclip", ["-selection", "clipboard"], text)) return true
+  if (await pipe("xsel", ["--clipboard", "--input"], text)) return true
+  return osc
+}