cerebras-cli 1.0.1 → 1.0.4

package/test/tool/__snapshots__/tool.test.ts.snap

@@ -1,9 +0,0 @@
-// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
-
-exports[`tool.ls basic 1`] = `
-"packages/opencode/test/fixtures/example/
-  broken.ts
-  cli.ts
-  ink.tsx
-"
-`;

package/test/tool/bash.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { BashTool } from "../../src/tool/bash"
-import { Instance } from "../../src/project/instance"
-import { Permission } from "../../src/permission"
-
-const ctx = {
-  sessionID: "test",
-  messageID: "",
-  toolCallID: "",
-  agent: "build",
-  abort: AbortSignal.any([]),
-  metadata: () => {},
-}
-
-const projectRoot = path.join(__dirname, "../..")
-
-describe("tool.bash", () => {
-  test("basic", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        const bash = await BashTool.init()
-        const result = await bash.execute(
-          {
-            command: "echo 'test'",
-            description: "Echo test message",
-          },
-          ctx,
-        )
-        expect(result.metadata.exit).toBe(0)
-        expect(result.metadata.output).toContain("test")
-      },
-    })
-  })
-
-  // TODO: better test
-  // test("cd ../ should ask for permission for external directory", async () => {
-  //   await Instance.provide({
-  //     directory: projectRoot,
-  //     fn: async () => {
-  //       bash.execute(
-  //         {
-  //           command: "cd ../",
-  //           description: "Try to cd to parent directory",
-  //         },
-  //         ctx,
-  //       )
-  //       // Give time for permission to be asked
-  //       await new Promise((resolve) => setTimeout(resolve, 1000))
-  //       expect(Permission.pending()[ctx.sessionID]).toBeDefined()
-  //     },
-  //   })
-  // })
-})

package/test/tool/patch.test.ts

@@ -1,259 +0,0 @@
-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: "build",
-  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/util/iife.test.ts

@@ -1,36 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

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