saeeol 1.2.5 → 1.2.8

package/test/saeeol/patch.test.ts

@@ -1,172 +0,0 @@
-// Tests the saeeol-specific patch module guarantees:
-// - Files retain their original encoding after an update (UTF-8 BOM, UTF-16,
-//   legacy single-byte, CJK).
-// - Plain UTF-8 files do not gain a spurious BOM.
-// - Moved files keep the original encoding at the new path.
-// These round-trip through Patch.applyPatch directly so we exercise the
-// encoding + BOM integration in patch/index.ts without the tool stack.
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { tmpdir } from "os"
-import iconv from "iconv-lite"
-import { Patch } from "../../src/patch"
-
-const UTF8_BOM = Buffer.from([0xef, 0xbb, 0xbf])
-const UTF16_LE_BOM = Buffer.from([0xff, 0xfe])
-
-describe("Patch encoding preservation", () => {
-  let dir: string
-
-  beforeEach(async () => {
-    dir = await fs.mkdtemp(path.join(tmpdir(), "saeeol-patch-"))
-  })
-
-  afterEach(async () => {
-    await fs.rm(dir, { recursive: true, force: true })
-  })
-
-  test("preserves UTF-8 BOM through update", async () => {
-    const file = path.join(dir, "doc.txt")
-    await fs.writeFile(file, Buffer.concat([UTF8_BOM, Buffer.from("line 1\nline 2\n", "utf-8")]))
-
-    const patch = `*** Begin Patch
-*** Update File: ${file}
-@@
- line 1
--line 2
-+line 2 updated
-*** End Patch`
-
-    await Patch.applyPatch(patch)
-
-    const bytes = await fs.readFile(file)
-    expect(bytes.subarray(0, 3).equals(UTF8_BOM)).toBe(true)
-    expect(bytes.subarray(3).toString("utf-8")).toBe("line 1\nline 2 updated\n")
-  })
-
-  test("does not introduce BOM for plain UTF-8 files", async () => {
-    const file = path.join(dir, "plain.txt")
-    await fs.writeFile(file, "line 1\nline 2\n", "utf-8")
-
-    const patch = `*** Begin Patch
-*** Update File: ${file}
-@@
- line 1
--line 2
-+line 2 updated
-*** End Patch`
-
-    await Patch.applyPatch(patch)
-
-    const bytes = await fs.readFile(file)
-    expect(bytes[0]).not.toBe(0xef)
-    expect(bytes.toString("utf-8")).toBe("line 1\nline 2 updated\n")
-  })
-
-  test("preserves UTF-16 LE encoding through update", async () => {
-    const file = path.join(dir, "utf16.txt")
-    await fs.writeFile(file, Buffer.concat([UTF16_LE_BOM, iconv.encode("line 1\nline 2\n", "utf-16le")]))
-
-    const patch = `*** Begin Patch
-*** Update File: ${file}
-@@
- line 1
--line 2
-+line 2 updated
-*** End Patch`
-
-    await Patch.applyPatch(patch)
-
-    const bytes = await fs.readFile(file)
-    expect(bytes.subarray(0, 2).equals(UTF16_LE_BOM)).toBe(true)
-    expect(iconv.decode(bytes.subarray(2), "utf-16le")).toBe("line 1\nline 2 updated\n")
-  })
-
-  test("preserves iso-8859-1 encoding through update", async () => {
-    const file = path.join(dir, "latin1.txt")
-    await fs.writeFile(file, iconv.encode("café\nñandú\n", "iso-8859-1"))
-
-    const patch = `*** Begin Patch
-*** Update File: ${file}
-@@
- café
--ñandú
-+águila
-*** End Patch`
-
-    await Patch.applyPatch(patch)
-
-    const bytes = await fs.readFile(file)
-    expect(iconv.decode(bytes, "iso-8859-1")).toBe("café\náguila\n")
-    // á and ñ are two bytes in UTF-8, one byte in ISO-8859-1. If the file had
-    // been silently re-encoded as UTF-8 the byte length would differ.
-    expect(bytes.length).toBe("café\náguila\n".length)
-  })
-
-  test("preserves Shift_JIS encoding through update", async () => {
-    const file = path.join(dir, "jp.txt")
-    // chardet needs enough characteristic bytes to identify Shift_JIS. A
-    // single 19-byte phrase looks like windows-1252, so the sample is padded
-    // to match the body of Japanese text the tool tests already rely on.
-    const sample = "こんにちは、世界！日本語のテストです。"
-    await fs.writeFile(file, iconv.encode(`line1\n${sample}\nline3\n`, "Shift_JIS"))
-
-    const patch = `*** Begin Patch
-*** Update File: ${file}
-@@
- line1
--${sample}
-+さようなら、世界！
- line3
-*** End Patch`
-
-    await Patch.applyPatch(patch)
-
-    const bytes = await fs.readFile(file)
-    expect(iconv.decode(bytes, "Shift_JIS")).toBe("line1\nさようなら、世界！\nline3\n")
-    const utf8Rendered = Buffer.from("line1\nさようなら、世界！\nline3\n", "utf-8")
-    expect(bytes.equals(utf8Rendered)).toBe(false)
-  })
-
-  test("preserves UTF-8 BOM when file is moved", async () => {
-    const from = path.join(dir, "old.txt")
-    const to = path.join(dir, "new.txt")
-    await fs.writeFile(from, Buffer.concat([UTF8_BOM, Buffer.from("original\n", "utf-8")]))
-
-    const patch = `*** Begin Patch
-*** Update File: ${from}
-*** Move to: ${to}
-@@
--original
-+updated
-*** End Patch`
-
-    await Patch.applyPatch(patch)
-
-    const moved = await fs.readFile(to)
-    expect(moved.subarray(0, 3).equals(UTF8_BOM)).toBe(true)
-    expect(moved.subarray(3).toString("utf-8")).toBe("updated\n")
-
-    const oldExists = await fs
-      .access(from)
-      .then(() => true)
-      .catch(() => false)
-    expect(oldExists).toBe(false)
-  })
-
-  test("new files added via patch are written as plain UTF-8", async () => {
-    const file = path.join(dir, "new.txt")
-    const patch = `*** Begin Patch
-*** Add File: ${file}
-+hello world
-*** End Patch`
-
-    await Patch.applyPatch(patch)
-
-    const bytes = await fs.readFile(file)
-    expect(bytes[0]).not.toBe(0xef)
-    expect(bytes.toString("utf-8")).toBe("hello world")
-  })
-})

package/test/saeeol/paths.test.ts

@@ -1,265 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { SaeeolPaths } from "../../src/overlay/paths"
-import { tmpdir } from "../fixture/fixture"
-import path from "path"
-import fs from "fs/promises"
-
-async function withHome<T>(home: string, fn: () => Promise<T>): Promise<T> {
-  const prev = process.env.HOME
-  process.env.HOME = home
-  try {
-    return await fn()
-  } finally {
-    if (prev) process.env.HOME = prev
-    else delete process.env.HOME
-  }
-}
-
-describe("SaeeolPaths", () => {
-  describe("skillDirectories", () => {
-    test("discovers skills from .saeeol/skills/", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          const skillDir = path.join(dir, ".saeeol", "skills", "test-skill")
-          await fs.mkdir(skillDir, { recursive: true })
-          await Bun.write(
-            path.join(skillDir, "SKILL.md"),
-            `---
-name: test-skill
-description: A test skill
----
-# Test instructions`,
-          )
-        },
-      })
-
-      const result = await SaeeolPaths.skillDirectories({
-        projectDir: tmp.path,
-        worktreeRoot: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toEndWith(".saeeol")
-    })
-
-    test("returns empty array when no .saeeol/skills/ exists", async () => {
-      await using tmp = await tmpdir()
-
-      const result = await SaeeolPaths.skillDirectories({
-        projectDir: tmp.path,
-        worktreeRoot: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result).toHaveLength(0)
-    })
-
-    test("discovers skills from nested .saeeol directories", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          // Root level skill
-          const rootSkillDir = path.join(dir, ".saeeol", "skills", "root-skill")
-          await fs.mkdir(rootSkillDir, { recursive: true })
-          await Bun.write(
-            path.join(rootSkillDir, "SKILL.md"),
-            `---
-name: root-skill
-description: Root level skill
----
-# Root instructions`,
-          )
-
-          // Nested project skill
-          const nestedDir = path.join(dir, "packages", "nested")
-          const nestedSkillDir = path.join(nestedDir, ".saeeol", "skills", "nested-skill")
-          await fs.mkdir(nestedSkillDir, { recursive: true })
-          await Bun.write(
-            path.join(nestedSkillDir, "SKILL.md"),
-            `---
-name: nested-skill
-description: Nested skill
----
-# Nested instructions`,
-          )
-        },
-      })
-
-      // Run from nested directory, should find both
-      const nestedPath = path.join(tmp.path, "packages", "nested")
-      const result = await SaeeolPaths.skillDirectories({
-        projectDir: nestedPath,
-        worktreeRoot: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result).toHaveLength(2)
-      const nested = path.join("packages", "nested")
-      expect(result.some((d) => d.includes(nested))).toBe(true)
-      expect(result.some((d) => !d.includes(nested))).toBe(true)
-    })
-
-    test("handles .saeeol directory without skills subdirectory", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          // Create .saeeol but not skills/
-          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "config.json"), "{}")
-        },
-      })
-
-      const result = await SaeeolPaths.skillDirectories({
-        projectDir: tmp.path,
-        worktreeRoot: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result).toHaveLength(0)
-    })
-
-    test("handles symlinked skill directories", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          // Create actual skill in a different location
-          const actualDir = path.join(dir, "shared-skills", "my-skill")
-          await fs.mkdir(actualDir, { recursive: true })
-          await Bun.write(
-            path.join(actualDir, "SKILL.md"),
-            `---
-name: my-skill
-description: Symlinked skill
----
-# Instructions`,
-          )
-
-          // Create .saeeol/skills/ and symlink the skill
-          const skillsDir = path.join(dir, ".saeeol", "skills")
-          await fs.mkdir(skillsDir, { recursive: true })
-          await fs.symlink(actualDir, path.join(skillsDir, "my-skill"))
-        },
-      })
-
-      const result = await SaeeolPaths.skillDirectories({
-        projectDir: tmp.path,
-        worktreeRoot: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toEndWith(".saeeol")
-    })
-
-    test("discovers skills from .saeeol/skills/", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          const skillDir = path.join(dir, ".saeeol", "skills", "legacy-skill")
-          await fs.mkdir(skillDir, { recursive: true })
-          await Bun.write(
-            path.join(skillDir, "SKILL.md"),
-            `---
-name: legacy-skill
-description: A legacy skill
----
-# Legacy instructions`,
-          )
-        },
-      })
-
-      const result = await SaeeolPaths.skillDirectories({
-        projectDir: tmp.path,
-        worktreeRoot: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toEndWith(".saeeol")
-    })
-
-    test("returns skill dirs from .saeeol", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          // .saeeol skill
-          const saeeolSkillDir = path.join(dir, ".saeeol", "skills", "new-skill")
-          await fs.mkdir(saeeolSkillDir, { recursive: true })
-          await Bun.write(path.join(saeeolSkillDir, "SKILL.md"), "# New skill")
-
-          // .saeeol skill
-          const legacySkillDir = path.join(dir, ".saeeol", "skills", "old-skill")
-          await fs.mkdir(legacySkillDir, { recursive: true })
-          await Bun.write(path.join(legacySkillDir, "SKILL.md"), "# Old skill")
-        },
-      })
-
-      const result = await SaeeolPaths.skillDirectories({
-        projectDir: tmp.path,
-        worktreeRoot: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result).toHaveLength(1)
-      expect(result[0]).toEndWith(".saeeol")
-    })
-
-    test("discovers global skills from ~/.saeeol/skills/", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          const skillDir = path.join(dir, ".saeeol", "skills", "global-skill")
-          await fs.mkdir(skillDir, { recursive: true })
-          await Bun.write(path.join(skillDir, "SKILL.md"), "# Global skill")
-          await fs.mkdir(path.join(dir, "repo"), { recursive: true })
-        },
-      })
-
-      const result = await withHome(tmp.path, () =>
-        SaeeolPaths.skillDirectories({
-          projectDir: path.join(tmp.path, "repo"),
-          worktreeRoot: path.join(tmp.path, "repo"),
-        }),
-      )
-
-      expect(result.some((d) => d.endsWith(".saeeol"))).toBe(true)
-    })
-
-    test("discovers multiple skills in same directory", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          const skillsDir = path.join(dir, ".saeeol", "skills")
-
-          // First skill
-          const skill1 = path.join(skillsDir, "skill-one")
-          await fs.mkdir(skill1, { recursive: true })
-          await Bun.write(
-            path.join(skill1, "SKILL.md"),
-            `---
-name: skill-one
-description: First skill
----
-# First`,
-          )
-
-          // Second skill
-          const skill2 = path.join(skillsDir, "skill-two")
-          await fs.mkdir(skill2, { recursive: true })
-          await Bun.write(
-            path.join(skill2, "SKILL.md"),
-            `---
-name: skill-two
-description: Second skill
----
-# Second`,
-          )
-        },
-      })
-
-      const result = await SaeeolPaths.skillDirectories({
-        projectDir: tmp.path,
-        worktreeRoot: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      // Should return the .saeeol directory (not skills/ subdirectory)
-      expect(result).toHaveLength(1)
-      expect(result[0]).toEndWith(".saeeol")
-    })
-  })
-})

package/test/saeeol/permission/config-paths.test.ts

@@ -1,174 +0,0 @@
-import path from "path"
-import { describe, expect, test } from "bun:test"
-import { ConfigProtection } from "../../../src/overlay/permission/config-paths"
-import { Global } from "@saeeol/core/global"
-import { SaeeolPaths } from "../../../src/overlay/paths"
-
-describe("ConfigProtection.isRequest", () => {
-  const config = path.resolve(Global.Path.config)
-  const legacy = SaeeolPaths.globalDirs().map((d) => path.resolve(d))
-
-  // --- external_directory: bash-originated (empty metadata) ---
-
-  test("returns true for bash external_directory targeting global config", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "external_directory",
-      patterns: [config + "/*"],
-      metadata: {},
-    })
-    expect(result).toBe(true)
-  })
-
-  test("returns true for bash external_directory targeting skill dir", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "external_directory",
-      patterns: [path.join(config, "skills", "my-skill") + "/*"],
-      metadata: {},
-    })
-    expect(result).toBe(true)
-  })
-
-  test("returns true for bash external_directory targeting legacy global dir", () => {
-    for (const dir of legacy) {
-      const result = ConfigProtection.isRequest({
-        permission: "external_directory",
-        patterns: [dir + "/*"],
-        metadata: {},
-      })
-      expect(result).toBe(true)
-    }
-  })
-
-  // --- external_directory: file-tool-originated (has metadata.filepath) ---
-
-  test("returns false for file-tool external_directory targeting global config", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "external_directory",
-      patterns: [config + "/*"],
-      metadata: { filepath: path.join(config, "saeeol.json"), parentDir: config },
-    })
-    expect(result).toBe(false)
-  })
-
-  test("returns false for file-tool external_directory targeting global config root dir", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "external_directory",
-      patterns: [config + "/*"],
-      metadata: { filepath: config, parentDir: config },
-    })
-    expect(result).toBe(false)
-  })
-
-  test("returns false for file-tool external_directory targeting readable global command dir", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "external_directory",
-      patterns: [path.join(config, "command") + "/*"],
-      metadata: { filepath: path.join(config, "command", "foo.md"), parentDir: path.join(config, "command") },
-    })
-    expect(result).toBe(false)
-  })
-
-  test("returns false for file-tool external_directory targeting readable global skill dir", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "external_directory",
-      patterns: [path.join(config, "skills") + "/*"],
-      metadata: {
-        filepath: path.join(config, "skills", "my-skill", "SKILL.md"),
-        parentDir: path.join(config, "skills"),
-      },
-    })
-    expect(result).toBe(false)
-  })
-
-  // --- external_directory: non-config dirs ---
-
-  test("returns false for bash external_directory targeting non-config dir", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "external_directory",
-      patterns: ["/tmp/some-project/*"],
-      metadata: {},
-    })
-    expect(result).toBe(false)
-  })
-
-  // --- edit permission ---
-
-  test("returns true for edit targeting global config file via metadata.filepath", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "edit",
-      patterns: [],
-      metadata: { filepath: path.join(config, "config.json") },
-    })
-    expect(result).toBe(true)
-  })
-
-  test("returns true for edit targeting skill file via metadata.filepath", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "edit",
-      patterns: [],
-      metadata: { filepath: path.join(config, "skills", "my-skill", "SKILL.md") },
-    })
-    expect(result).toBe(true)
-  })
-
-  test("returns true for edit targeting legacy global dir via metadata.filepath", () => {
-    for (const dir of legacy) {
-      const result = ConfigProtection.isRequest({
-        permission: "edit",
-        patterns: [],
-        metadata: { filepath: path.join(dir, "config.json") },
-      })
-      expect(result).toBe(true)
-    }
-  })
-
-  test("returns true for edit targeting relative config path via patterns", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "edit",
-      patterns: [".saeeol/command/foo.md"],
-    })
-    expect(result).toBe(true)
-  })
-
-  test("returns false for edit targeting excluded subdir (plans)", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "edit",
-      patterns: [".saeeol/plans/plan.md"],
-    })
-    expect(result).toBe(false)
-  })
-
-  test("returns false for read permission", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "read",
-      patterns: [".saeeol/config.json"],
-    })
-    expect(result).toBe(false)
-  })
-
-  test("returns false for bash permission", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "bash",
-      patterns: ["cat " + path.join(config, "config.json")],
-    })
-    expect(result).toBe(false)
-  })
-
-  test("returns true for edit targeting root config files", () => {
-    for (const file of ["saeeol.json", "saeeol.jsonc", "AGENTS.md"]) {
-      const result = ConfigProtection.isRequest({
-        permission: "edit",
-        patterns: [file],
-      })
-      expect(result).toBe(true)
-    }
-  })
-
-  test("returns false for edit targeting non-config files", () => {
-    const result = ConfigProtection.isRequest({
-      permission: "edit",
-      patterns: ["src/index.ts"],
-    })
-    expect(result).toBe(false)
-  })
-})