innocode 1.0.0 → 1.0.229

package/test/tool/registry.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import fs from "fs/promises"
-import { tmpdir } from "../fixture/fixture"
-import { Instance } from "../../src/project/instance"
-import { ToolRegistry } from "../../src/tool/registry"
-
-describe("tool.registry", () => {
-  test("loads tools from .opencode/tool (singular)", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        const opencodeDir = path.join(dir, ".opencode")
-        await fs.mkdir(opencodeDir, { recursive: true })
-
-        const toolDir = path.join(opencodeDir, "tool")
-        await fs.mkdir(toolDir, { recursive: true })
-
-        await Bun.write(
-          path.join(toolDir, "hello.ts"),
-          [
-            "export default {",
-            "  description: 'hello tool',",
-            "  args: {},",
-            "  execute: async () => {",
-            "    return 'hello world'",
-            "  },",
-            "}",
-            "",
-          ].join("\n"),
-        )
-      },
-    })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const ids = await ToolRegistry.ids()
-        expect(ids).toContain("hello")
-      },
-    })
-  })
-
-  test("loads tools from .opencode/tools (plural)", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        const opencodeDir = path.join(dir, ".opencode")
-        await fs.mkdir(opencodeDir, { recursive: true })
-
-        const toolsDir = path.join(opencodeDir, "tools")
-        await fs.mkdir(toolsDir, { recursive: true })
-
-        await Bun.write(
-          path.join(toolsDir, "hello.ts"),
-          [
-            "export default {",
-            "  description: 'hello tool',",
-            "  args: {},",
-            "  execute: async () => {",
-            "    return 'hello world'",
-            "  },",
-            "}",
-            "",
-          ].join("\n"),
-        )
-      },
-    })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const ids = await ToolRegistry.ids()
-        expect(ids).toContain("hello")
-      },
-    })
-  })
-
-  test("loads tools with external dependencies without crashing", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        const opencodeDir = path.join(dir, ".opencode")
-        await fs.mkdir(opencodeDir, { recursive: true })
-
-        const toolsDir = path.join(opencodeDir, "tools")
-        await fs.mkdir(toolsDir, { recursive: true })
-
-        await Bun.write(
-          path.join(opencodeDir, "package.json"),
-          JSON.stringify({
-            name: "custom-tools",
-            dependencies: {
-              "@opencode-ai/plugin": "^0.0.0",
-              cowsay: "^1.6.0",
-            },
-          }),
-        )
-
-        await Bun.write(
-          path.join(toolsDir, "cowsay.ts"),
-          [
-            "import { say } from 'cowsay'",
-            "export default {",
-            "  description: 'tool that imports cowsay at top level',",
-            "  args: { text: { type: 'string' } },",
-            "  execute: async ({ text }: { text: string }) => {",
-            "    return say({ text })",
-            "  },",
-            "}",
-            "",
-          ].join("\n"),
-        )
-      },
-    })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const ids = await ToolRegistry.ids()
-        expect(ids).toContain("cowsay")
-      },
-    })
-  })
-})

package/test/tool/skill.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { pathToFileURL } from "url"
-import type { PermissionNext } from "../../src/permission/next"
-import type { Tool } from "../../src/tool/tool"
-import { Instance } from "../../src/project/instance"
-import { SkillTool } from "../../src/tool/skill"
-import { tmpdir } from "../fixture/fixture"
-
-const baseCtx: Omit<Tool.Context, "ask"> = {
-  sessionID: "test",
-  messageID: "",
-  callID: "",
-  agent: "build",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => {},
-}
-
-describe("tool.skill", () => {
-  test("description lists skill location URL", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      init: async (dir) => {
-        const skillDir = path.join(dir, ".opencode", "skill", "tool-skill")
-        await Bun.write(
-          path.join(skillDir, "SKILL.md"),
-          `---
-name: tool-skill
-description: Skill for tool tests.
----
-
-# Tool Skill
-`,
-        )
-      },
-    })
-
-    const home = process.env.OPENCODE_TEST_HOME
-    process.env.OPENCODE_TEST_HOME = tmp.path
-
-    try {
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const tool = await SkillTool.init()
-          const skillPath = path.join(tmp.path, ".opencode", "skill", "tool-skill", "SKILL.md")
-          expect(tool.description).toContain(`<location>${pathToFileURL(skillPath).href}</location>`)
-        },
-      })
-    } finally {
-      process.env.OPENCODE_TEST_HOME = home
-    }
-  })
-
-  test("execute returns skill content block with files", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      init: async (dir) => {
-        const skillDir = path.join(dir, ".opencode", "skill", "tool-skill")
-        await Bun.write(
-          path.join(skillDir, "SKILL.md"),
-          `---
-name: tool-skill
-description: Skill for tool tests.
----
-
-# Tool Skill
-
-Use this skill.
-`,
-        )
-        await Bun.write(path.join(skillDir, "scripts", "demo.txt"), "demo")
-      },
-    })
-
-    const home = process.env.OPENCODE_TEST_HOME
-    process.env.OPENCODE_TEST_HOME = tmp.path
-
-    try {
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const tool = await SkillTool.init()
-          const requests: Array<Omit<PermissionNext.Request, "id" | "sessionID" | "tool">> = []
-          const ctx: Tool.Context = {
-            ...baseCtx,
-            ask: async (req) => {
-              requests.push(req)
-            },
-          }
-
-          const result = await tool.execute({ name: "tool-skill" }, ctx)
-          const dir = path.join(tmp.path, ".opencode", "skill", "tool-skill")
-          const file = path.resolve(dir, "scripts", "demo.txt")
-
-          expect(requests.length).toBe(1)
-          expect(requests[0].permission).toBe("skill")
-          expect(requests[0].patterns).toContain("tool-skill")
-          expect(requests[0].always).toContain("tool-skill")
-
-          expect(result.metadata.dir).toBe(dir)
-          expect(result.output).toContain(`<skill_content name="tool-skill">`)
-          expect(result.output).toContain(`Base directory for this skill: ${pathToFileURL(dir).href}`)
-          expect(result.output).toContain(`<file>${file}</file>`)
-        },
-      })
-    } finally {
-      process.env.OPENCODE_TEST_HOME = home
-    }
-  })
-})

package/test/tool/truncation.test.ts

@@ -1,159 +0,0 @@
-import { describe, test, expect, afterAll } from "bun:test"
-import { Truncate } from "../../src/tool/truncation"
-import { Identifier } from "../../src/id/id"
-import fs from "fs/promises"
-import path from "path"
-
-const FIXTURES_DIR = path.join(import.meta.dir, "fixtures")
-
-describe("Truncate", () => {
-  describe("output", () => {
-    test("truncates large json file by bytes", async () => {
-      const content = await Bun.file(path.join(FIXTURES_DIR, "models-api.json")).text()
-      const result = await Truncate.output(content)
-
-      expect(result.truncated).toBe(true)
-      expect(result.content).toContain("truncated...")
-      if (result.truncated) expect(result.outputPath).toBeDefined()
-    })
-
-    test("returns content unchanged when under limits", async () => {
-      const content = "line1\nline2\nline3"
-      const result = await Truncate.output(content)
-
-      expect(result.truncated).toBe(false)
-      expect(result.content).toBe(content)
-    })
-
-    test("truncates by line count", async () => {
-      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-      const result = await Truncate.output(lines, { maxLines: 10 })
-
-      expect(result.truncated).toBe(true)
-      expect(result.content).toContain("...90 lines truncated...")
-    })
-
-    test("truncates by byte count", async () => {
-      const content = "a".repeat(1000)
-      const result = await Truncate.output(content, { maxBytes: 100 })
-
-      expect(result.truncated).toBe(true)
-      expect(result.content).toContain("truncated...")
-    })
-
-    test("truncates from head by default", async () => {
-      const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
-      const result = await Truncate.output(lines, { maxLines: 3 })
-
-      expect(result.truncated).toBe(true)
-      expect(result.content).toContain("line0")
-      expect(result.content).toContain("line1")
-      expect(result.content).toContain("line2")
-      expect(result.content).not.toContain("line9")
-    })
-
-    test("truncates from tail when direction is tail", async () => {
-      const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
-      const result = await Truncate.output(lines, { maxLines: 3, direction: "tail" })
-
-      expect(result.truncated).toBe(true)
-      expect(result.content).toContain("line7")
-      expect(result.content).toContain("line8")
-      expect(result.content).toContain("line9")
-      expect(result.content).not.toContain("line0")
-    })
-
-    test("uses default MAX_LINES and MAX_BYTES", () => {
-      expect(Truncate.MAX_LINES).toBe(2000)
-      expect(Truncate.MAX_BYTES).toBe(50 * 1024)
-    })
-
-    test("large single-line file truncates with byte message", async () => {
-      const content = await Bun.file(path.join(FIXTURES_DIR, "models-api.json")).text()
-      const result = await Truncate.output(content)
-
-      expect(result.truncated).toBe(true)
-      expect(result.content).toContain("bytes truncated...")
-      expect(Buffer.byteLength(content, "utf-8")).toBeGreaterThan(Truncate.MAX_BYTES)
-    })
-
-    test("writes full output to file when truncated", async () => {
-      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-      const result = await Truncate.output(lines, { maxLines: 10 })
-
-      expect(result.truncated).toBe(true)
-      expect(result.content).toContain("The tool call succeeded but the output was truncated")
-      expect(result.content).toContain("Grep")
-      if (!result.truncated) throw new Error("expected truncated")
-      expect(result.outputPath).toBeDefined()
-      expect(result.outputPath).toContain("tool_")
-
-      const written = await Bun.file(result.outputPath).text()
-      expect(written).toBe(lines)
-    })
-
-    test("suggests Task tool when agent has task permission", async () => {
-      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-      const agent = { permission: [{ permission: "task", pattern: "*", action: "allow" as const }] }
-      const result = await Truncate.output(lines, { maxLines: 10 }, agent as any)
-
-      expect(result.truncated).toBe(true)
-      expect(result.content).toContain("Grep")
-      expect(result.content).toContain("Task tool")
-    })
-
-    test("omits Task tool hint when agent lacks task permission", async () => {
-      const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
-      const agent = { permission: [{ permission: "task", pattern: "*", action: "deny" as const }] }
-      const result = await Truncate.output(lines, { maxLines: 10 }, agent as any)
-
-      expect(result.truncated).toBe(true)
-      expect(result.content).toContain("Grep")
-      expect(result.content).not.toContain("Task tool")
-    })
-
-    test("does not write file when not truncated", async () => {
-      const content = "short content"
-      const result = await Truncate.output(content)
-
-      expect(result.truncated).toBe(false)
-      if (result.truncated) throw new Error("expected not truncated")
-      expect("outputPath" in result).toBe(false)
-    })
-  })
-
-  describe("cleanup", () => {
-    const DAY_MS = 24 * 60 * 60 * 1000
-    let oldFile: string
-    let recentFile: string
-
-    afterAll(async () => {
-      await fs.unlink(oldFile).catch(() => {})
-      await fs.unlink(recentFile).catch(() => {})
-    })
-
-    test("deletes files older than 7 days and preserves recent files", async () => {
-      await fs.mkdir(Truncate.DIR, { recursive: true })
-
-      // Create an old file (10 days ago)
-      const oldTimestamp = Date.now() - 10 * DAY_MS
-      const oldId = Identifier.create("tool", false, oldTimestamp)
-      oldFile = path.join(Truncate.DIR, oldId)
-      await Bun.write(Bun.file(oldFile), "old content")
-
-      // Create a recent file (3 days ago)
-      const recentTimestamp = Date.now() - 3 * DAY_MS
-      const recentId = Identifier.create("tool", false, recentTimestamp)
-      recentFile = path.join(Truncate.DIR, recentId)
-      await Bun.write(Bun.file(recentFile), "recent content")
-
-      await Truncate.cleanup()
-
-      // Old file should be deleted
-      expect(await Bun.file(oldFile).exists()).toBe(false)
-
-      // Recent file should still exist
-      expect(await Bun.file(recentFile).exists()).toBe(true)
-    })
-  })
-})

package/test/util/filesystem.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import os from "node:os"
-import path from "node:path"
-import { mkdtemp, mkdir, rm } from "node:fs/promises"
-import { Filesystem } from "../../src/util/filesystem"
-
-describe("util.filesystem", () => {
-  test("exists() is true for files and directories", async () => {
-    const tmp = await mkdtemp(path.join(os.tmpdir(), "opencode-filesystem-"))
-    const dir = path.join(tmp, "dir")
-    const file = path.join(tmp, "file.txt")
-    const missing = path.join(tmp, "missing")
-
-    await mkdir(dir, { recursive: true })
-    await Bun.write(file, "hello")
-
-    const cases = await Promise.all([Filesystem.exists(dir), Filesystem.exists(file), Filesystem.exists(missing)])
-
-    expect(cases).toEqual([true, true, false])
-
-    await rm(tmp, { recursive: true, force: true })
-  })
-
-  test("isDir() is true only for directories", async () => {
-    const tmp = await mkdtemp(path.join(os.tmpdir(), "opencode-filesystem-"))
-    const dir = path.join(tmp, "dir")
-    const file = path.join(tmp, "file.txt")
-    const missing = path.join(tmp, "missing")
-
-    await mkdir(dir, { recursive: true })
-    await Bun.write(file, "hello")
-
-    const cases = await Promise.all([Filesystem.isDir(dir), Filesystem.isDir(file), Filesystem.isDir(missing)])
-
-    expect(cases).toEqual([true, false, false])
-
-    await rm(tmp, { recursive: true, force: true })
-  })
-})

package/test/util/format.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { formatDuration } from "../../src/util/format"
-
-describe("util.format", () => {
-  describe("formatDuration", () => {
-    test("returns empty string for zero or negative values", () => {
-      expect(formatDuration(0)).toBe("")
-      expect(formatDuration(-1)).toBe("")
-      expect(formatDuration(-100)).toBe("")
-    })
-
-    test("formats seconds under a minute", () => {
-      expect(formatDuration(1)).toBe("1s")
-      expect(formatDuration(30)).toBe("30s")
-      expect(formatDuration(59)).toBe("59s")
-    })
-
-    test("formats minutes under an hour", () => {
-      expect(formatDuration(60)).toBe("1m")
-      expect(formatDuration(61)).toBe("1m 1s")
-      expect(formatDuration(90)).toBe("1m 30s")
-      expect(formatDuration(120)).toBe("2m")
-      expect(formatDuration(330)).toBe("5m 30s")
-      expect(formatDuration(3599)).toBe("59m 59s")
-    })
-
-    test("formats hours under a day", () => {
-      expect(formatDuration(3600)).toBe("1h")
-      expect(formatDuration(3660)).toBe("1h 1m")
-      expect(formatDuration(7200)).toBe("2h")
-      expect(formatDuration(8100)).toBe("2h 15m")
-      expect(formatDuration(86399)).toBe("23h 59m")
-    })
-
-    test("formats days under a week", () => {
-      expect(formatDuration(86400)).toBe("~1 day")
-      expect(formatDuration(172800)).toBe("~2 days")
-      expect(formatDuration(259200)).toBe("~3 days")
-      expect(formatDuration(604799)).toBe("~6 days")
-    })
-
-    test("formats weeks", () => {
-      expect(formatDuration(604800)).toBe("~1 week")
-      expect(formatDuration(1209600)).toBe("~2 weeks")
-      expect(formatDuration(1609200)).toBe("~2 weeks")
-    })
-
-    test("handles boundary values correctly", () => {
-      expect(formatDuration(59)).toBe("59s")
-      expect(formatDuration(60)).toBe("1m")
-      expect(formatDuration(3599)).toBe("59m 59s")
-      expect(formatDuration(3600)).toBe("1h")
-      expect(formatDuration(86399)).toBe("23h 59m")
-      expect(formatDuration(86400)).toBe("~1 day")
-      expect(formatDuration(604799)).toBe("~6 days")
-      expect(formatDuration(604800)).toBe("~1 week")
-    })
-  })
-})

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/lock.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Lock } from "../../src/util/lock"
-
-function tick() {
-  return new Promise<void>((r) => queueMicrotask(r))
-}
-
-async function flush(n = 5) {
-  for (let i = 0; i < n; i++) await tick()
-}
-
-describe("util.lock", () => {
-  test("writer exclusivity: blocks reads and other writes while held", async () => {
-    const key = "lock:" + Math.random().toString(36).slice(2)
-
-    const state = {
-      writer2: false,
-      reader: false,
-      writers: 0,
-    }
-
-    // Acquire writer1
-    using writer1 = await Lock.write(key)
-    state.writers++
-    expect(state.writers).toBe(1)
-
-    // Start writer2 candidate (should block)
-    const writer2Task = (async () => {
-      const w = await Lock.write(key)
-      state.writers++
-      expect(state.writers).toBe(1)
-      state.writer2 = true
-      // Hold for a tick so reader cannot slip in
-      await tick()
-      return w
-    })()
-
-    // Start reader candidate (should block)
-    const readerTask = (async () => {
-      const r = await Lock.read(key)
-      state.reader = true
-      return r
-    })()
-
-    // Flush microtasks and assert neither acquired
-    await flush()
-    expect(state.writer2).toBe(false)
-    expect(state.reader).toBe(false)
-
-    // Release writer1
-    writer1[Symbol.dispose]()
-    state.writers--
-
-    // writer2 should acquire next
-    const writer2 = await writer2Task
-    expect(state.writer2).toBe(true)
-
-    // Reader still blocked while writer2 held
-    await flush()
-    expect(state.reader).toBe(false)
-
-    // Release writer2
-    writer2[Symbol.dispose]()
-    state.writers--
-
-    // Reader should now acquire
-    const reader = await readerTask
-    expect(state.reader).toBe(true)
-
-    reader[Symbol.dispose]()
-  })
-})

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")
-  })
-})