@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/fsutil.ts

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs"
+import { join, resolve } from "node:path"
+import type { Project } from "./session/types.ts"
+
+/** The home folder readers and writers work in: $BRAIN_HOME in tests, else the real one. */
+export function homeDir(): string {
+  return process.env.BRAIN_HOME ?? process.env.HOME ?? ""
+}
+
+/** macOS application-support folder for a home. */
+export const appSupport = (home: string) => join(home, "Library", "Application Support")
+
+export const exists = (p: string) => existsSync(p)
+
+export function isDir(p: string): boolean {
+  try {
+    return statSync(p).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+export function mtime(p: string): string | undefined {
+  try {
+    return statSync(p).mtime.toISOString()
+  } catch {
+    return undefined
+  }
+}
+
+/** Directory entries, or none when the directory is missing or unreadable. */
+export function ls(dir: string): string[] {
+  try {
+    return readdirSync(dir)
+  } catch {
+    return []
+  }
+}
+
+/** Files under `dir` whose names match, depth-first, at most `depth` levels down. */
+export function findFiles(dir: string, match: (name: string) => boolean, depth = 4): string[] {
+  const out: string[] = []
+  const walk = (d: string, left: number) => {
+    for (const name of ls(d)) {
+      const p = join(d, name)
+      if (isDir(p)) {
+        if (left > 0) walk(p, left - 1)
+      } else if (match(name)) out.push(p)
+    }
+  }
+  walk(dir, depth)
+  return out
+}
+
+/** JSON from a file, or undefined when it is missing or not JSON. */
+export function readJson<T = unknown>(p: string): T | undefined {
+  try {
+    return JSON.parse(readFileSync(p, "utf8")) as T
+  } catch {
+    return undefined
+  }
+}
+
+/** Each line of a JSONL file parsed, skipping lines that are not JSON (a half-written last line, say); `bad` counts them. */
+export function readJsonl(p: string): { rows: Array<Record<string, any>>; bad: number } {
+  let text = ""
+  try {
+    text = readFileSync(p, "utf8")
+  } catch {
+    return { rows: [], bad: 0 }
+  }
+  const rows: Array<Record<string, any>> = []
+  let bad = 0
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue
+    try {
+      rows.push(JSON.parse(line))
+    } catch {
+      bad++
+    }
+  }
+  return { rows, bad }
+}
+
+/**
+ * Git remote, branch and commit for a folder, read from .git without running git; empty when it is not a
+ * repository. The walk up stops below the home folder: a dotfiles repository at ~/.git would otherwise make
+ * every project under home look like one project.
+ */
+export function gitInfo(cwd: string | undefined, home = homeDir()): Omit<Project, "cwd"> {
+  if (!cwd) return {}
+  const stop = home.replace(/\/+$/, "")
+  let dir = cwd
+  for (let i = 0; i < 30 && dir && dir !== "/" && dir !== stop; i++) {
+    const git = join(dir, ".git")
+    if (exists(git)) {
+      try {
+        // A worktree's .git is a file naming its git dir, absolute or relative to the worktree.
+        const gitDir = isDir(git) ? git : resolve(dir, readFileSync(git, "utf8").replace(/^gitdir:\s*/, "").trim())
+        const head = readFileSync(join(gitDir, "HEAD"), "utf8").trim()
+        const branch = head.startsWith("ref: refs/heads/") ? head.slice(16) : undefined
+        let commit: string | undefined = head.startsWith("ref:") ? undefined : head
+        if (branch) {
+          const ref = join(gitDir, "refs", "heads", branch)
+          commit = exists(ref) ? readFileSync(ref, "utf8").trim() : undefined
+        }
+        const config = exists(join(gitDir, "config")) ? readFileSync(join(gitDir, "config"), "utf8") : ""
+        const remote = config.match(/\[remote "origin"\][^[]*?url\s*=\s*(\S+)/)?.[1]
+        return { ...(remote ? { gitRemote: remote } : {}), ...(branch ? { gitBranch: branch } : {}), ...(commit ? { gitCommit: commit } : {}) }
+      } catch {
+        return {}
+      }
+    }
+    dir = dir.slice(0, dir.lastIndexOf("/"))
+  }
+  return {}
+}
+
+/** Whether a process with this exact name is running (a desktop app whose store must not be written while open). */
+export function isRunning(processName: string): boolean {
+  const p = Bun.spawnSync(["pgrep", "-x", processName], { stdout: "pipe", stderr: "pipe" })
+  return p.exitCode === 0
+}
+
+/** The first line of `<bin> --version`, or undefined when the binary is missing. */
+export function versionOf(bin: string): string | undefined {
+  try {
+    const p = Bun.spawnSync([bin, "--version"], { env: process.env, stdout: "pipe", stderr: "pipe", timeout: 10_000 })
+    return p.exitCode === 0 ? p.stdout.toString().trim().split("\n")[0] : undefined
+  } catch {
+    return undefined
+  }
+}