bincode-cli 1.0.1

package/src/file/ripgrep.ts

@@ -0,0 +1,393 @@
+// Ripgrep utility functions
+import path from "path"
+import { Global } from "../global"
+import fs from "fs/promises"
+import z from "zod"
+import { NamedError } from "@bincode-ai/util/error"
+import { lazy } from "../util/lazy"
+import { $ } from "bun"
+
+import { ZipReader, BlobReader, BlobWriter } from "@zip.js/zip.js"
+import { Log } from "@/util/log"
+
+export namespace Ripgrep {
+  const log = Log.create({ service: "ripgrep" })
+  const Stats = z.object({
+    elapsed: z.object({
+      secs: z.number(),
+      nanos: z.number(),
+      human: z.string(),
+    }),
+    searches: z.number(),
+    searches_with_match: z.number(),
+    bytes_searched: z.number(),
+    bytes_printed: z.number(),
+    matched_lines: z.number(),
+    matches: z.number(),
+  })
+
+  const Begin = z.object({
+    type: z.literal("begin"),
+    data: z.object({
+      path: z.object({
+        text: z.string(),
+      }),
+    }),
+  })
+
+  export const Match = z.object({
+    type: z.literal("match"),
+    data: z.object({
+      path: z.object({
+        text: z.string(),
+      }),
+      lines: z.object({
+        text: z.string(),
+      }),
+      line_number: z.number(),
+      absolute_offset: z.number(),
+      submatches: z.array(
+        z.object({
+          match: z.object({
+            text: z.string(),
+          }),
+          start: z.number(),
+          end: z.number(),
+        }),
+      ),
+    }),
+  })
+
+  const End = z.object({
+    type: z.literal("end"),
+    data: z.object({
+      path: z.object({
+        text: z.string(),
+      }),
+      binary_offset: z.number().nullable(),
+      stats: Stats,
+    }),
+  })
+
+  const Summary = z.object({
+    type: z.literal("summary"),
+    data: z.object({
+      elapsed_total: z.object({
+        human: z.string(),
+        nanos: z.number(),
+        secs: z.number(),
+      }),
+      stats: Stats,
+    }),
+  })
+
+  const Result = z.union([Begin, Match, End, Summary])
+
+  export type Result = z.infer<typeof Result>
+  export type Match = z.infer<typeof Match>
+  export type Begin = z.infer<typeof Begin>
+  export type End = z.infer<typeof End>
+  export type Summary = z.infer<typeof Summary>
+  const PLATFORM = {
+    "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
+    "arm64-linux": {
+      platform: "aarch64-unknown-linux-gnu",
+      extension: "tar.gz",
+    },
+    "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
+    "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
+    "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" },
+  } as const
+
+  export const ExtractionFailedError = NamedError.create(
+    "RipgrepExtractionFailedError",
+    z.object({
+      filepath: z.string(),
+      stderr: z.string(),
+    }),
+  )
+
+  export const UnsupportedPlatformError = NamedError.create(
+    "RipgrepUnsupportedPlatformError",
+    z.object({
+      platform: z.string(),
+    }),
+  )
+
+  export const DownloadFailedError = NamedError.create(
+    "RipgrepDownloadFailedError",
+    z.object({
+      url: z.string(),
+      status: z.number(),
+    }),
+  )
+
+  const state = lazy(async () => {
+    let filepath = Bun.which("rg")
+    if (filepath) return { filepath }
+    filepath = path.join(Global.Path.bin, "rg" + (process.platform === "win32" ? ".exe" : ""))
+
+    const file = Bun.file(filepath)
+    if (!(await file.exists())) {
+      const platformKey = `${process.arch}-${process.platform}` as keyof typeof PLATFORM
+      const config = PLATFORM[platformKey]
+      if (!config) throw new UnsupportedPlatformError({ platform: platformKey })
+
+      const version = "14.1.1"
+      const filename = `ripgrep-${version}-${config.platform}.${config.extension}`
+      const url = `https://github.com/BurntSushi/ripgrep/releases/download/${version}/${filename}`
+
+      const response = await fetch(url)
+      if (!response.ok) throw new DownloadFailedError({ url, status: response.status })
+
+      const buffer = await response.arrayBuffer()
+      const archivePath = path.join(Global.Path.bin, filename)
+      await Bun.write(archivePath, buffer)
+      if (config.extension === "tar.gz") {
+        const args = ["tar", "-xzf", archivePath, "--strip-components=1"]
+
+        if (platformKey.endsWith("-darwin")) args.push("--include=*/rg")
+        if (platformKey.endsWith("-linux")) args.push("--wildcards", "*/rg")
+
+        const proc = Bun.spawn(args, {
+          cwd: Global.Path.bin,
+          stderr: "pipe",
+          stdout: "pipe",
+        })
+        await proc.exited
+        if (proc.exitCode !== 0)
+          throw new ExtractionFailedError({
+            filepath,
+            stderr: await Bun.readableStreamToText(proc.stderr),
+          })
+      }
+      if (config.extension === "zip") {
+        if (config.extension === "zip") {
+          const zipFileReader = new ZipReader(new BlobReader(new Blob([await Bun.file(archivePath).arrayBuffer()])))
+          const entries = await zipFileReader.getEntries()
+          let rgEntry: any
+          for (const entry of entries) {
+            if (entry.filename.endsWith("rg.exe")) {
+              rgEntry = entry
+              break
+            }
+          }
+
+          if (!rgEntry) {
+            throw new ExtractionFailedError({
+              filepath: archivePath,
+              stderr: "rg.exe not found in zip archive",
+            })
+          }
+
+          const rgBlob = await rgEntry.getData(new BlobWriter())
+          if (!rgBlob) {
+            throw new ExtractionFailedError({
+              filepath: archivePath,
+              stderr: "Failed to extract rg.exe from zip archive",
+            })
+          }
+          await Bun.write(filepath, await rgBlob.arrayBuffer())
+          await zipFileReader.close()
+        }
+      }
+      await fs.unlink(archivePath)
+      if (!platformKey.endsWith("-win32")) await fs.chmod(filepath, 0o755)
+    }
+
+    return {
+      filepath,
+    }
+  })
+
+  export async function filepath() {
+    const { filepath } = await state()
+    return filepath
+  }
+
+  export async function* files(input: { cwd: string; glob?: string[] }) {
+    const args = [await filepath(), "--files", "--follow", "--hidden", "--glob=!.git/*"]
+    if (input.glob) {
+      for (const g of input.glob) {
+        args.push(`--glob=${g}`)
+      }
+    }
+
+    // Bun.spawn should throw this, but it incorrectly reports that the executable does not exist.
+    // See https://github.com/oven-sh/bun/issues/24012
+    if (!(await fs.stat(input.cwd).catch(() => undefined))?.isDirectory()) {
+      throw Object.assign(new Error(`No such file or directory: '${input.cwd}'`), {
+        code: "ENOENT",
+        errno: -2,
+        path: input.cwd,
+      })
+    }
+
+    const proc = Bun.spawn(args, {
+      cwd: input.cwd,
+      stdout: "pipe",
+      stderr: "ignore",
+      maxBuffer: 1024 * 1024 * 20,
+    })
+
+    const reader = proc.stdout.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ""
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        // Handle both Unix (\n) and Windows (\r\n) line endings
+        const lines = buffer.split(/\r?\n/)
+        buffer = lines.pop() || ""
+
+        for (const line of lines) {
+          if (line) yield line
+        }
+      }
+
+      if (buffer) yield buffer
+    } finally {
+      reader.releaseLock()
+      await proc.exited
+    }
+  }
+
+  export async function tree(input: { cwd: string; limit?: number }) {
+    log.info("tree", input)
+    const files = await Array.fromAsync(Ripgrep.files({ cwd: input.cwd }))
+    interface Node {
+      path: string[]
+      children: Node[]
+    }
+
+    function getPath(node: Node, parts: string[], create: boolean) {
+      if (parts.length === 0) return node
+      let current = node
+      for (const part of parts) {
+        let existing = current.children.find((x) => x.path.at(-1) === part)
+        if (!existing) {
+          if (!create) return
+          existing = {
+            path: current.path.concat(part),
+            children: [],
+          }
+          current.children.push(existing)
+        }
+        current = existing
+      }
+      return current
+    }
+
+    const root: Node = {
+      path: [],
+      children: [],
+    }
+    for (const file of files) {
+      if (file.includes(".bincode")) continue
+      const parts = file.split(path.sep)
+      getPath(root, parts, true)
+    }
+
+    function sort(node: Node) {
+      node.children.sort((a, b) => {
+        if (!a.children.length && b.children.length) return 1
+        if (!b.children.length && a.children.length) return -1
+        return a.path.at(-1)!.localeCompare(b.path.at(-1)!)
+      })
+      for (const child of node.children) {
+        sort(child)
+      }
+    }
+    sort(root)
+
+    let current = [root]
+    const result: Node = {
+      path: [],
+      children: [],
+    }
+
+    let processed = 0
+    const limit = input.limit ?? 50
+    while (current.length > 0) {
+      const next = []
+      for (const node of current) {
+        if (node.children.length) next.push(...node.children)
+      }
+      const max = Math.max(...current.map((x) => x.children.length))
+      for (let i = 0; i < max && processed < limit; i++) {
+        for (const node of current) {
+          const child = node.children[i]
+          if (!child) continue
+          getPath(result, child.path, true)
+          processed++
+          if (processed >= limit) break
+        }
+      }
+      if (processed >= limit) {
+        for (const node of [...current, ...next]) {
+          const compare = getPath(result, node.path, false)
+          if (!compare) continue
+          if (compare?.children.length !== node.children.length) {
+            const diff = node.children.length - compare.children.length
+            compare.children.push({
+              path: compare.path.concat(`[${diff} truncated]`),
+              children: [],
+            })
+          }
+        }
+        break
+      }
+      current = next
+    }
+
+    const lines: string[] = []
+
+    function render(node: Node, depth: number) {
+      const indent = "\t".repeat(depth)
+      lines.push(indent + node.path.at(-1) + (node.children.length ? "/" : ""))
+      for (const child of node.children) {
+        render(child, depth + 1)
+      }
+    }
+    result.children.map((x) => render(x, 0))
+
+    return lines.join("\n")
+  }
+
+  export async function search(input: { cwd: string; pattern: string; glob?: string[]; limit?: number }) {
+    const args = [`${await filepath()}`, "--json", "--hidden", "--glob='!.git/*'"]
+
+    if (input.glob) {
+      for (const g of input.glob) {
+        args.push(`--glob=${g}`)
+      }
+    }
+
+    if (input.limit) {
+      args.push(`--max-count=${input.limit}`)
+    }
+
+    args.push("--")
+    args.push(input.pattern)
+
+    const command = args.join(" ")
+    const result = await $`${{ raw: command }}`.cwd(input.cwd).quiet().nothrow()
+    if (result.exitCode !== 0) {
+      return []
+    }
+
+    // Handle both Unix (\n) and Windows (\r\n) line endings
+    const lines = result.text().trim().split(/\r?\n/).filter(Boolean)
+    // Parse JSON lines from ripgrep output
+
+    return lines
+      .map((line) => JSON.parse(line))
+      .map((parsed) => Result.parse(parsed))
+      .filter((r) => r.type === "match")
+      .map((r) => r.data)
+  }
+}

package/src/file/time.ts

@@ -0,0 +1,64 @@
+import { Instance } from "../project/instance"
+import { Log } from "../util/log"
+
+export namespace FileTime {
+  const log = Log.create({ service: "file.time" })
+  // Per-session read times plus per-file write locks.
+  // All tools that overwrite existing files should run their
+  // assert/read/write/update sequence inside withLock(filepath, ...)
+  // so concurrent writes to the same file are serialized.
+  export const state = Instance.state(() => {
+    const read: {
+      [sessionID: string]: {
+        [path: string]: Date | undefined
+      }
+    } = {}
+    const locks = new Map<string, Promise<void>>()
+    return {
+      read,
+      locks,
+    }
+  })
+
+  export function read(sessionID: string, file: string) {
+    log.info("read", { sessionID, file })
+    const { read } = state()
+    read[sessionID] = read[sessionID] || {}
+    read[sessionID][file] = new Date()
+  }
+
+  export function get(sessionID: string, file: string) {
+    return state().read[sessionID]?.[file]
+  }
+
+  export async function withLock<T>(filepath: string, fn: () => Promise<T>): Promise<T> {
+    const current = state()
+    const currentLock = current.locks.get(filepath) ?? Promise.resolve()
+    let release: () => void = () => {}
+    const nextLock = new Promise<void>((resolve) => {
+      release = resolve
+    })
+    const chained = currentLock.then(() => nextLock)
+    current.locks.set(filepath, chained)
+    await currentLock
+    try {
+      return await fn()
+    } finally {
+      release()
+      if (current.locks.get(filepath) === chained) {
+        current.locks.delete(filepath)
+      }
+    }
+  }
+
+  export async function assert(sessionID: string, filepath: string) {
+    const time = get(sessionID, filepath)
+    if (!time) throw new Error(`You must read the file ${filepath} before overwriting it. Use the Read tool first`)
+    const stats = await Bun.file(filepath).stat()
+    if (stats.mtime.getTime() > time.getTime()) {
+      throw new Error(
+        `File ${filepath} has been modified since it was last read.\nLast modification: ${stats.mtime.toISOString()}\nLast read: ${time.toISOString()}\n\nPlease read the file again before modifying it.`,
+      )
+    }
+  }
+}

package/src/file/watcher.ts

@@ -0,0 +1,103 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import z from "zod"
+import { Instance } from "../project/instance"
+import { Log } from "../util/log"
+import { FileIgnore } from "./ignore"
+import { Config } from "../config/config"
+import path from "path"
+// @ts-ignore
+import { createWrapper } from "@parcel/watcher/wrapper"
+import { lazy } from "@/util/lazy"
+import type ParcelWatcher from "@parcel/watcher"
+import { $ } from "bun"
+import { Flag } from "@/flag/flag"
+
+declare const BINCODE_LIBC: string | undefined
+
+export namespace FileWatcher {
+  const log = Log.create({ service: "file.watcher" })
+
+  export const Event = {
+    Updated: BusEvent.define(
+      "file.watcher.updated",
+      z.object({
+        file: z.string(),
+        event: z.union([z.literal("add"), z.literal("change"), z.literal("unlink")]),
+      }),
+    ),
+  }
+
+  const watcher = lazy(() => {
+    const binding = require(
+      `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${BINCODE_LIBC || "glibc"}` : ""}`,
+    )
+    return createWrapper(binding) as typeof import("@parcel/watcher")
+  })
+
+  const state = Instance.state(
+    async () => {
+      if (Instance.project.vcs !== "git") return {}
+      log.info("init")
+      const cfg = await Config.get()
+      const backend = (() => {
+        if (process.platform === "win32") return "windows"
+        if (process.platform === "darwin") return "fs-events"
+        if (process.platform === "linux") return "inotify"
+      })()
+      if (!backend) {
+        log.error("watcher backend not supported", { platform: process.platform })
+        return {}
+      }
+      log.info("watcher backend", { platform: process.platform, backend })
+      const subscribe: ParcelWatcher.SubscribeCallback = (err, evts) => {
+        if (err) return
+        for (const evt of evts) {
+          if (evt.type === "create") Bus.publish(Event.Updated, { file: evt.path, event: "add" })
+          if (evt.type === "update") Bus.publish(Event.Updated, { file: evt.path, event: "change" })
+          if (evt.type === "delete") Bus.publish(Event.Updated, { file: evt.path, event: "unlink" })
+        }
+      }
+
+      const subs: ParcelWatcher.AsyncSubscription[] = []
+      const cfgIgnores = cfg.watcher?.ignore ?? []
+
+      if (Flag.BINCODE_EXPERIMENTAL_FILEWATCHER) {
+        subs.push(
+          await watcher().subscribe(Instance.directory, subscribe, {
+            ignore: [...FileIgnore.PATTERNS, ...cfgIgnores],
+            backend,
+          }),
+        )
+      }
+
+      const vcsDir = await $`git rev-parse --git-dir`
+        .quiet()
+        .nothrow()
+        .cwd(Instance.worktree)
+        .text()
+        .then((x) => path.resolve(Instance.worktree, x.trim()))
+      if (vcsDir && !cfgIgnores.includes(".git") && !cfgIgnores.includes(vcsDir)) {
+        subs.push(
+          await watcher().subscribe(vcsDir, subscribe, {
+            ignore: ["hooks", "info", "logs", "objects", "refs", "worktrees", "modules", "lfs"],
+            backend,
+          }),
+        )
+      }
+
+      return { subs }
+    },
+    async (state) => {
+      if (!state.subs) return
+      await Promise.all(state.subs.map((sub) => sub?.unsubscribe()))
+    },
+  )
+
+  export function init() {
+    if (Flag.BINCODE_EXPERIMENTAL_DISABLE_FILEWATCHER) {
+      return
+    }
+    state()
+  }
+}

package/src/flag/flag.ts

@@ -0,0 +1,46 @@
+export namespace Flag {
+  export const BINCODE_AUTO_SHARE = truthy("BINCODE_AUTO_SHARE")
+  export const BINCODE_GIT_BASH_PATH = process.env["BINCODE_GIT_BASH_PATH"]
+  export const BINCODE_CONFIG = process.env["BINCODE_CONFIG"]
+  export const BINCODE_CONFIG_DIR = process.env["BINCODE_CONFIG_DIR"]
+  export const BINCODE_CONFIG_CONTENT = process.env["BINCODE_CONFIG_CONTENT"]
+  export const BINCODE_DISABLE_AUTOUPDATE = truthy("BINCODE_DISABLE_AUTOUPDATE")
+  export const BINCODE_DISABLE_PRUNE = truthy("BINCODE_DISABLE_PRUNE")
+  export const BINCODE_DISABLE_TERMINAL_TITLE = truthy("BINCODE_DISABLE_TERMINAL_TITLE")
+  export const BINCODE_PERMISSION = process.env["BINCODE_PERMISSION"]
+  export const BINCODE_DISABLE_DEFAULT_PLUGINS = truthy("BINCODE_DISABLE_DEFAULT_PLUGINS")
+  export const BINCODE_DISABLE_LSP_DOWNLOAD = truthy("BINCODE_DISABLE_LSP_DOWNLOAD")
+  export const BINCODE_ENABLE_EXPERIMENTAL_MODELS = truthy("BINCODE_ENABLE_EXPERIMENTAL_MODELS")
+  export const BINCODE_DISABLE_AUTOCOMPACT = truthy("BINCODE_DISABLE_AUTOCOMPACT")
+  export const BINCODE_DISABLE_MODELS_FETCH = truthy("BINCODE_DISABLE_MODELS_FETCH")
+  export const BINCODE_FAKE_VCS = process.env["BINCODE_FAKE_VCS"]
+  export const BINCODE_CLIENT = process.env["BINCODE_CLIENT"] ?? "cli"
+
+  // Experimental
+  export const BINCODE_EXPERIMENTAL = truthy("BINCODE_EXPERIMENTAL")
+  export const BINCODE_EXPERIMENTAL_FILEWATCHER = truthy("BINCODE_EXPERIMENTAL_FILEWATCHER")
+  export const BINCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = truthy("BINCODE_EXPERIMENTAL_DISABLE_FILEWATCHER")
+  export const BINCODE_EXPERIMENTAL_ICON_DISCOVERY =
+    BINCODE_EXPERIMENTAL || truthy("BINCODE_EXPERIMENTAL_ICON_DISCOVERY")
+  export const BINCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = truthy("BINCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT")
+  export const BINCODE_ENABLE_EXA =
+    truthy("BINCODE_ENABLE_EXA") || BINCODE_EXPERIMENTAL || truthy("BINCODE_EXPERIMENTAL_EXA")
+  export const BINCODE_EXPERIMENTAL_BASH_MAX_OUTPUT_LENGTH = number("BINCODE_EXPERIMENTAL_BASH_MAX_OUTPUT_LENGTH")
+  export const BINCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = number("BINCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS")
+  export const BINCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX = number("BINCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX")
+  export const BINCODE_EXPERIMENTAL_OXFMT = BINCODE_EXPERIMENTAL || truthy("BINCODE_EXPERIMENTAL_OXFMT")
+  export const BINCODE_EXPERIMENTAL_LSP_TY = truthy("BINCODE_EXPERIMENTAL_LSP_TY")
+  export const BINCODE_EXPERIMENTAL_LSP_TOOL = BINCODE_EXPERIMENTAL || truthy("BINCODE_EXPERIMENTAL_LSP_TOOL")
+
+  function truthy(key: string) {
+    const value = process.env[key]?.toLowerCase()
+    return value === "true" || value === "1"
+  }
+
+  function number(key: string) {
+    const value = process.env[key]
+    if (!value) return undefined
+    const parsed = Number(value)
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined
+  }
+}