chad-code 1.3.1

package/test/tool/read.test.ts

@@ -0,0 +1,167 @@
+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"
+import { PermissionNext } from "../../src/permission/next"
+import { Agent } from "../../src/agent/agent"
+
+const ctx = {
+  sessionID: "test",
+  messageID: "",
+  callID: "",
+  agent: "build",
+  abort: AbortSignal.any([]),
+  metadata: () => {},
+  ask: async () => {},
+}
+
+describe("tool.read external_directory permission", () => {
+  test("allows reading absolute path inside project directory", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "test.txt"), "hello world")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const read = await ReadTool.init()
+        const result = await read.execute({ filePath: path.join(tmp.path, "test.txt") }, ctx)
+        expect(result.output).toContain("hello world")
+      },
+    })
+  })
+
+  test("allows reading file in subdirectory inside project directory", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "test.txt"), "nested content")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const read = await ReadTool.init()
+        const result = await read.execute({ filePath: path.join(tmp.path, "subdir", "test.txt") }, ctx)
+        expect(result.output).toContain("nested content")
+      },
+    })
+  })
+
+  test("asks for external_directory permission when reading absolute path outside project", async () => {
+    await using outerTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "secret.txt"), "secret data")
+      },
+    })
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const read = await ReadTool.init()
+        const requests: Array<Omit<PermissionNext.Request, "id" | "sessionID" | "tool">> = []
+        const testCtx = {
+          ...ctx,
+          ask: async (req: Omit<PermissionNext.Request, "id" | "sessionID" | "tool">) => {
+            requests.push(req)
+          },
+        }
+        await read.execute({ filePath: path.join(outerTmp.path, "secret.txt") }, testCtx)
+        const extDirReq = requests.find((r) => r.permission === "external_directory")
+        expect(extDirReq).toBeDefined()
+        expect(extDirReq!.patterns.some((p) => p.includes(outerTmp.path))).toBe(true)
+      },
+    })
+  })
+
+  test("asks for external_directory permission when reading relative path outside project", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const read = await ReadTool.init()
+        const requests: Array<Omit<PermissionNext.Request, "id" | "sessionID" | "tool">> = []
+        const testCtx = {
+          ...ctx,
+          ask: async (req: Omit<PermissionNext.Request, "id" | "sessionID" | "tool">) => {
+            requests.push(req)
+          },
+        }
+        // This will fail because file doesn't exist, but we can check if permission was asked
+        await read.execute({ filePath: "../outside.txt" }, testCtx).catch(() => {})
+        const extDirReq = requests.find((r) => r.permission === "external_directory")
+        expect(extDirReq).toBeDefined()
+      },
+    })
+  })
+
+  test("does not ask for external_directory permission when reading inside project", async () => {
+    await using tmp = await tmpdir({
+      git: true,
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "internal.txt"), "internal content")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const read = await ReadTool.init()
+        const requests: Array<Omit<PermissionNext.Request, "id" | "sessionID" | "tool">> = []
+        const testCtx = {
+          ...ctx,
+          ask: async (req: Omit<PermissionNext.Request, "id" | "sessionID" | "tool">) => {
+            requests.push(req)
+          },
+        }
+        await read.execute({ filePath: path.join(tmp.path, "internal.txt") }, testCtx)
+        const extDirReq = requests.find((r) => r.permission === "external_directory")
+        expect(extDirReq).toBeUndefined()
+      },
+    })
+  })
+})
+
+describe("tool.read env file blocking", () => {
+  const cases: [string, boolean][] = [
+    [".env", true],
+    [".env.local", true],
+    [".env.production", true],
+    [".env.development.local", true],
+    [".env.example", false],
+    [".envrc", false],
+    ["environment.ts", false],
+  ]
+
+  describe.each(["build", "plan"])("agent=%s", (agentName) => {
+    test.each(cases)("%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 agent = await Agent.get(agentName)
+          const ctxWithPermissions = {
+            ...ctx,
+            ask: async (req: Omit<PermissionNext.Request, "id" | "sessionID" | "tool">) => {
+              for (const pattern of req.patterns) {
+                const rule = PermissionNext.evaluate(req.permission, pattern, agent.permission)
+                if (rule.action === "deny") {
+                  throw new PermissionNext.DeniedError(agent.permission)
+                }
+              }
+            },
+          }
+          const read = await ReadTool.init()
+          const promise = read.execute({ filePath: path.join(tmp.path, filename) }, ctxWithPermissions)
+          if (blocked) {
+            await expect(promise).rejects.toThrow(PermissionNext.DeniedError)
+          } 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/*"]
+    }
+  }
+}