@stonerzju/opencode 1.2.17 → 1.2.19

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,160 +0,0 @@
-import { describe, test, expect, afterAll } from "bun:test"
-import { Truncate } from "../../src/tool/truncation"
-import { Identifier } from "../../src/id/id"
-import { Filesystem } from "../../src/util/filesystem"
-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 Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json"))
-      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 Filesystem.readText(path.join(FIXTURES_DIR, "models-api.json"))
-      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 Filesystem.readText(result.outputPath!)
-      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 Filesystem.write(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 Filesystem.write(recentFile, "recent content")
-
-      await Truncate.cleanup()
-
-      // Old file should be deleted
-      expect(await Filesystem.exists(oldFile)).toBe(false)
-
-      // Recent file should still exist
-      expect(await Filesystem.exists(recentFile)).toBe(true)
-    })
-  })
-})

package/test/tool/webfetch.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { Instance } from "../../src/project/instance"
-import { WebFetchTool } from "../../src/tool/webfetch"
-
-const projectRoot = path.join(import.meta.dir, "../..")
-
-const ctx = {
-  sessionID: "test",
-  messageID: "message",
-  callID: "",
-  agent: "build",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => {},
-  ask: async () => {},
-}
-
-async function withFetch(
-  mockFetch: (input: string | URL | Request, init?: RequestInit) => Promise<Response>,
-  fn: () => Promise<void>,
-) {
-  const originalFetch = globalThis.fetch
-  globalThis.fetch = mockFetch as unknown as typeof fetch
-  try {
-    await fn()
-  } finally {
-    globalThis.fetch = originalFetch
-  }
-}
-
-describe("tool.webfetch", () => {
-  test("returns image responses as file attachments", async () => {
-    const bytes = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10])
-    await withFetch(
-      async () => new Response(bytes, { status: 200, headers: { "content-type": "IMAGE/PNG; charset=binary" } }),
-      async () => {
-        await Instance.provide({
-          directory: projectRoot,
-          fn: async () => {
-            const webfetch = await WebFetchTool.init()
-            const result = await webfetch.execute({ url: "https://example.com/image.png", format: "markdown" }, ctx)
-            expect(result.output).toBe("Image fetched successfully")
-            expect(result.attachments).toBeDefined()
-            expect(result.attachments?.length).toBe(1)
-            expect(result.attachments?.[0].type).toBe("file")
-            expect(result.attachments?.[0].mime).toBe("image/png")
-            expect(result.attachments?.[0].url.startsWith("data:image/png;base64,")).toBe(true)
-            expect(result.attachments?.[0]).not.toHaveProperty("id")
-            expect(result.attachments?.[0]).not.toHaveProperty("sessionID")
-            expect(result.attachments?.[0]).not.toHaveProperty("messageID")
-          },
-        })
-      },
-    )
-  })
-
-  test("keeps svg as text output", async () => {
-    const svg = '<svg xmlns="http://www.w3.org/2000/svg"><text>hello</text></svg>'
-    await withFetch(
-      async () =>
-        new Response(svg, {
-          status: 200,
-          headers: { "content-type": "image/svg+xml; charset=UTF-8" },
-        }),
-      async () => {
-        await Instance.provide({
-          directory: projectRoot,
-          fn: async () => {
-            const webfetch = await WebFetchTool.init()
-            const result = await webfetch.execute({ url: "https://example.com/image.svg", format: "html" }, ctx)
-            expect(result.output).toContain("<svg")
-            expect(result.attachments).toBeUndefined()
-          },
-        })
-      },
-    )
-  })
-
-  test("keeps text responses as text output", async () => {
-    await withFetch(
-      async () =>
-        new Response("hello from webfetch", {
-          status: 200,
-          headers: { "content-type": "text/plain; charset=utf-8" },
-        }),
-      async () => {
-        await Instance.provide({
-          directory: projectRoot,
-          fn: async () => {
-            const webfetch = await WebFetchTool.init()
-            const result = await webfetch.execute({ url: "https://example.com/file.txt", format: "text" }, ctx)
-            expect(result.output).toBe("hello from webfetch")
-            expect(result.attachments).toBeUndefined()
-          },
-        })
-      },
-    )
-  })
-})