saeeol 1.3.0 → 1.3.1

package/test/saeeol/patch.test.ts

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

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

@@ -0,0 +1,174 @@
+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)
+  })
+})