rird 1.0.200

package/test/tool/patch.test.ts

@@ -0,0 +1,259 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import { PatchTool } from "../../src/tool/patch"
+import { Instance } from "../../src/project/instance"
+import { tmpdir } from "../fixture/fixture"
+import { Permission } from "../../src/permission"
+import * as fs from "fs/promises"
+
+const ctx = {
+  sessionID: "test",
+  messageID: "",
+  toolCallID: "",
+  agent: "act",
+  abort: AbortSignal.any([]),
+  metadata: () => {},
+}
+
+const patchTool = await PatchTool.init()
+
+describe("tool.patch", () => {
+  test("should validate required parameters", async () => {
+    await Instance.provide({
+      directory: "/tmp",
+      fn: async () => {
+        expect(patchTool.execute({ patchText: "" }, ctx)).rejects.toThrow("patchText is required")
+      },
+    })
+  })
+
+  test("should validate patch format", async () => {
+    await Instance.provide({
+      directory: "/tmp",
+      fn: async () => {
+        expect(patchTool.execute({ patchText: "invalid patch" }, ctx)).rejects.toThrow("Failed to parse patch")
+      },
+    })
+  })
+
+  test("should handle empty patch", async () => {
+    await Instance.provide({
+      directory: "/tmp",
+      fn: async () => {
+        const emptyPatch = `*** Begin Patch
+*** End Patch`
+
+        expect(patchTool.execute({ patchText: emptyPatch }, ctx)).rejects.toThrow("No file changes found in patch")
+      },
+    })
+  })
+
+  test.skip("should ask permission for files outside working directory", async () => {
+    await Instance.provide({
+      directory: "/tmp",
+      fn: async () => {
+        const maliciousPatch = `*** Begin Patch
+*** Add File: /etc/passwd
++malicious content
+*** End Patch`
+        patchTool.execute({ patchText: maliciousPatch }, ctx)
+        // TODO: this sucks
+        await new Promise((resolve) => setTimeout(resolve, 1000))
+        expect(Permission.pending()[ctx.sessionID]).toBeDefined()
+      },
+    })
+  })
+
+  test("should handle simple add file operation", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        const patchText = `*** Begin Patch
+*** Add File: test-file.txt
++Hello World
++This is a test file
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText }, ctx)
+
+        expect(result.title).toContain("files changed")
+        expect(result.metadata.diff).toBeDefined()
+        expect(result.output).toContain("Patch applied successfully")
+
+        // Verify file was created
+        const filePath = path.join(fixture.path, "test-file.txt")
+        const content = await fs.readFile(filePath, "utf-8")
+        expect(content).toBe("Hello World\nThis is a test file")
+      },
+    })
+  })
+
+  test("should handle file with context update", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        const patchText = `*** Begin Patch
+*** Add File: config.js
++const API_KEY = "test-key"
++const DEBUG = false
++const VERSION = "1.0"
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText }, ctx)
+
+        expect(result.title).toContain("files changed")
+        expect(result.metadata.diff).toBeDefined()
+        expect(result.output).toContain("Patch applied successfully")
+
+        // Verify file was created with correct content
+        const filePath = path.join(fixture.path, "config.js")
+        const content = await fs.readFile(filePath, "utf-8")
+        expect(content).toBe('const API_KEY = "test-key"\nconst DEBUG = false\nconst VERSION = "1.0"')
+      },
+    })
+  })
+
+  test("should handle multiple file operations", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        const patchText = `*** Begin Patch
+*** Add File: file1.txt
++Content of file 1
+*** Add File: file2.txt
++Content of file 2
+*** Add File: file3.txt
++Content of file 3
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText }, ctx)
+
+        expect(result.title).toContain("3 files changed")
+        expect(result.metadata.diff).toBeDefined()
+        expect(result.output).toContain("Patch applied successfully")
+
+        // Verify all files were created
+        for (let i = 1; i <= 3; i++) {
+          const filePath = path.join(fixture.path, `file${i}.txt`)
+          const content = await fs.readFile(filePath, "utf-8")
+          expect(content).toBe(`Content of file ${i}`)
+        }
+      },
+    })
+  })
+
+  test("should create parent directories when adding nested files", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        const patchText = `*** Begin Patch
+*** Add File: deep/nested/file.txt
++Deep nested content
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText }, ctx)
+
+        expect(result.title).toContain("files changed")
+        expect(result.output).toContain("Patch applied successfully")
+
+        // Verify nested file was created
+        const nestedPath = path.join(fixture.path, "deep", "nested", "file.txt")
+        const exists = await fs
+          .access(nestedPath)
+          .then(() => true)
+          .catch(() => false)
+        expect(exists).toBe(true)
+
+        const content = await fs.readFile(nestedPath, "utf-8")
+        expect(content).toBe("Deep nested content")
+      },
+    })
+  })
+
+  test("should generate proper unified diff in metadata", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        // First create a file with simple content
+        const patchText1 = `*** Begin Patch
+*** Add File: test.txt
++line 1
++line 2
++line 3
+*** End Patch`
+
+        await patchTool.execute({ patchText: patchText1 }, ctx)
+
+        // Now create an update patch
+        const patchText2 = `*** Begin Patch
+*** Update File: test.txt
+@@
+ line 1
+-line 2
++line 2 updated
+ line 3
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText: patchText2 }, ctx)
+
+        expect(result.metadata.diff).toBeDefined()
+        expect(result.metadata.diff).toContain("@@")
+        expect(result.metadata.diff).toContain("-line 2")
+        expect(result.metadata.diff).toContain("+line 2 updated")
+      },
+    })
+  })
+
+  test("should handle complex patch with multiple operations", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        const patchText = `*** Begin Patch
+*** Add File: new.txt
++This is a new file
++with multiple lines
+*** Add File: existing.txt
++old content
++new line
++more content
+*** Add File: config.json
++{
++  "version": "1.0",
++  "debug": true
++}
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText }, ctx)
+
+        expect(result.title).toContain("3 files changed")
+        expect(result.metadata.diff).toBeDefined()
+        expect(result.output).toContain("Patch applied successfully")
+
+        // Verify all files were created
+        const newPath = path.join(fixture.path, "new.txt")
+        const newContent = await fs.readFile(newPath, "utf-8")
+        expect(newContent).toBe("This is a new file\nwith multiple lines")
+
+        const existingPath = path.join(fixture.path, "existing.txt")
+        const existingContent = await fs.readFile(existingPath, "utf-8")
+        expect(existingContent).toBe("old content\nnew line\nmore content")
+
+        const configPath = path.join(fixture.path, "config.json")
+        const configContent = await fs.readFile(configPath, "utf-8")
+        expect(configContent).toBe('{\n  "version": "1.0",\n  "debug": true\n}')
+      },
+    })
+  })
+})

package/test/tool/read.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import { ReadTool } from "../../src/tool/read"
+import { Instance } from "../../src/project/instance"
+import { tmpdir } from "../fixture/fixture"
+
+const ctx = {
+  sessionID: "test",
+  messageID: "",
+  callID: "",
+  agent: "act",
+  abort: AbortSignal.any([]),
+  metadata: () => {},
+}
+
+describe("tool.read env file blocking", () => {
+  test.each([
+    [".env", true],
+    [".env.local", true],
+    [".env.production", true],
+    [".env.sample", false],
+    [".env.example", false],
+    [".envrc", false],
+    ["environment.ts", false],
+  ])("%s blocked=%s", async (filename, blocked) => {
+    await using tmp = await tmpdir({
+      init: (dir) => Bun.write(path.join(dir, filename), "content"),
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const read = await ReadTool.init()
+        const promise = read.execute({ filePath: path.join(tmp.path, filename) }, ctx)
+        if (blocked) {
+          await expect(promise).rejects.toThrow("blocked")
+        } else {
+          expect((await promise).output).toContain("content")
+        }
+      },
+    })
+  })
+})

package/test/util/iife.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test"
+import { iife } from "../../src/util/iife"
+
+describe("util.iife", () => {
+  test("should execute function immediately and return result", () => {
+    let called = false
+    const result = iife(() => {
+      called = true
+      return 42
+    })
+
+    expect(called).toBe(true)
+    expect(result).toBe(42)
+  })
+
+  test("should work with async functions", async () => {
+    let called = false
+    const result = await iife(async () => {
+      called = true
+      return "async result"
+    })
+
+    expect(called).toBe(true)
+    expect(result).toBe("async result")
+  })
+
+  test("should handle functions with no return value", () => {
+    let called = false
+    const result = iife(() => {
+      called = true
+    })
+
+    expect(called).toBe(true)
+    expect(result).toBeUndefined()
+  })
+})

package/test/util/lazy.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "bun:test"
+import { lazy } from "../../src/util/lazy"
+
+describe("util.lazy", () => {
+  test("should call function only once", () => {
+    let callCount = 0
+    const getValue = () => {
+      callCount++
+      return "expensive value"
+    }
+
+    const lazyValue = lazy(getValue)
+
+    expect(callCount).toBe(0)
+
+    const result1 = lazyValue()
+    expect(result1).toBe("expensive value")
+    expect(callCount).toBe(1)
+
+    const result2 = lazyValue()
+    expect(result2).toBe("expensive value")
+    expect(callCount).toBe(1)
+  })
+
+  test("should preserve the same reference", () => {
+    const obj = { value: 42 }
+    const lazyObj = lazy(() => obj)
+
+    const result1 = lazyObj()
+    const result2 = lazyObj()
+
+    expect(result1).toBe(obj)
+    expect(result2).toBe(obj)
+    expect(result1).toBe(result2)
+  })
+
+  test("should work with different return types", () => {
+    const lazyString = lazy(() => "string")
+    const lazyNumber = lazy(() => 123)
+    const lazyBoolean = lazy(() => true)
+    const lazyNull = lazy(() => null)
+    const lazyUndefined = lazy(() => undefined)
+
+    expect(lazyString()).toBe("string")
+    expect(lazyNumber()).toBe(123)
+    expect(lazyBoolean()).toBe(true)
+    expect(lazyNull()).toBe(null)
+    expect(lazyUndefined()).toBe(undefined)
+  })
+})

package/test/util/timeout.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "bun:test"
+import { withTimeout } from "../../src/util/timeout"
+
+describe("util.timeout", () => {
+  test("should resolve when promise completes before timeout", async () => {
+    const fastPromise = new Promise<string>((resolve) => {
+      setTimeout(() => resolve("fast"), 10)
+    })
+
+    const result = await withTimeout(fastPromise, 100)
+    expect(result).toBe("fast")
+  })
+
+  test("should reject when promise exceeds timeout", async () => {
+    const slowPromise = new Promise<string>((resolve) => {
+      setTimeout(() => resolve("slow"), 200)
+    })
+
+    await expect(withTimeout(slowPromise, 50)).rejects.toThrow("Operation timed out after 50ms")
+  })
+})

package/test/util/wildcard.test.ts

@@ -0,0 +1,55 @@
+import { test, expect } from "bun:test"
+import { Wildcard } from "../../src/util/wildcard"
+
+test("match handles glob tokens", () => {
+  expect(Wildcard.match("file1.txt", "file?.txt")).toBe(true)
+  expect(Wildcard.match("file12.txt", "file?.txt")).toBe(false)
+  expect(Wildcard.match("foo+bar", "foo+bar")).toBe(true)
+})
+
+test("all picks the most specific pattern", () => {
+  const rules = {
+    "*": "deny",
+    "git *": "ask",
+    "git status": "allow",
+  }
+  expect(Wildcard.all("git status", rules)).toBe("allow")
+  expect(Wildcard.all("git log", rules)).toBe("ask")
+  expect(Wildcard.all("echo hi", rules)).toBe("deny")
+})
+
+test("allStructured matches command sequences", () => {
+  const rules = {
+    "git *": "ask",
+    "git status*": "allow",
+  }
+  expect(Wildcard.allStructured({ head: "git", tail: ["status", "--short"] }, rules)).toBe("allow")
+  expect(Wildcard.allStructured({ head: "npm", tail: ["run", "build", "--watch"] }, { "npm run *": "allow" })).toBe(
+    "allow",
+  )
+  expect(Wildcard.allStructured({ head: "ls", tail: ["-la"] }, rules)).toBeUndefined()
+})
+
+test("allStructured prioritizes flag-specific patterns", () => {
+  const rules = {
+    "find *": "allow",
+    "find * -delete*": "ask",
+    "sort*": "allow",
+    "sort -o *": "ask",
+  }
+  expect(Wildcard.allStructured({ head: "find", tail: ["src", "-delete"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "find", tail: ["src", "-print"] }, rules)).toBe("allow")
+  expect(Wildcard.allStructured({ head: "sort", tail: ["-o", "out.txt"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "sort", tail: ["--reverse"] }, rules)).toBe("allow")
+})
+
+test("allStructured handles sed flags", () => {
+  const rules = {
+    "sed * -i*": "ask",
+    "sed -n*": "allow",
+  }
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-i", "file"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-i.bak", "file"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-n", "1p", "file"] }, rules)).toBe("allow")
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-i", "-n", "/./p", "myfile.txt"] }, rules)).toBe("ask")
+})

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@tsconfig/bun/tsconfig.json",
+  "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "types": [],
+    "noUncheckedIndexedAccess": false,
+    "customConditions": ["browser"],
+    "paths": {
+      "@/*": ["./src/*"],
+      "@tui/*": ["./src/cli/cmd/tui/*"]
+    }
+  }
+}