saeeol 1.3.0 → 1.3.1

package/test/memory/abort-leak.test.ts

@@ -0,0 +1,128 @@
+import { describe, test, expect } from "bun:test"
+import path from "path"
+
+const projectRoot = path.join(import.meta.dir, "../..")
+const worker = path.join(import.meta.dir, "abort-leak-webfetch.ts")
+
+const MB = 1024 * 1024
+const ITERATIONS = 50
+
+const getHeapMB = () => {
+  Bun.gc(true)
+  return process.memoryUsage().heapUsed / MB
+}
+
+describe("memory: abort controller leak", () => {
+  test("webfetch does not leak memory over many invocations", async () => {
+    // Measure the abort-timed fetch path in a fresh process so shared tool
+    // runtime state does not dominate the heap signal.
+    const proc = Bun.spawn({
+      cmd: [process.execPath, worker],
+      cwd: projectRoot,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: process.env,
+    })
+
+    const [code, stdout, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ])
+
+    if (code !== 0) {
+      throw new Error(stderr.trim() || stdout.trim() || `worker exited with code ${code}`)
+    }
+
+    const result = JSON.parse(stdout.trim()) as {
+      baseline: number
+      after: number
+      growth: number
+    }
+
+    console.log(`Baseline: ${result.baseline.toFixed(2)} MB`)
+    console.log(`After ${ITERATIONS} fetches: ${result.after.toFixed(2)} MB`)
+    console.log(`Growth: ${result.growth.toFixed(2)} MB`)
+    // Memory growth should be well below the old closure pattern (~0.5MB/req = ~25MB).
+    // Windows Bun has higher per-fetch heap overhead (~13MB observed), so use a
+    // threshold that still catches the leak but accommodates platform variance.
+    expect(result.growth).toBeLessThan(20)
+  }, 60000)
+
+  test("compare closure vs bind pattern directly", async () => {
+    const ITERATIONS = 500
+
+    // Test OLD pattern: arrow function closure
+    // Store closures in a map keyed by content to force retention
+    const closureMap = new Map<string, () => void>()
+    const timers: Timer[] = []
+    const controllers: AbortController[] = []
+
+    Bun.gc(true)
+    Bun.sleepSync(100)
+    const baseline = getHeapMB()
+
+    for (let i = 0; i < ITERATIONS; i++) {
+      // Simulate large response body like webfetch would have
+      const content = `${i}:${"x".repeat(50 * 1024)}` // 50KB unique per iteration
+      const controller = new AbortController()
+      controllers.push(controller)
+
+      // OLD pattern - closure captures `content`
+      const handler = () => {
+        // Actually use content so it can't be optimized away
+        if (content.length > 1000000000) controller.abort()
+      }
+      closureMap.set(content, handler)
+      const timeoutId = setTimeout(handler, 30000)
+      timers.push(timeoutId)
+    }
+
+    Bun.gc(true)
+    Bun.sleepSync(100)
+    const after = getHeapMB()
+    const oldGrowth = after - baseline
+
+    console.log(`OLD pattern (closure): ${oldGrowth.toFixed(2)} MB growth (${closureMap.size} closures)`)
+
+    // Cleanup after measuring
+    timers.forEach(clearTimeout)
+    controllers.forEach((c) => c.abort())
+    closureMap.clear()
+
+    // Test NEW pattern: bind
+    Bun.gc(true)
+    Bun.sleepSync(100)
+    const baseline2 = getHeapMB()
+    const handlers2: (() => void)[] = []
+    const timers2: Timer[] = []
+    const controllers2: AbortController[] = []
+
+    for (let i = 0; i < ITERATIONS; i++) {
+      const _content = `${i}:${"x".repeat(50 * 1024)}` // 50KB - won't be captured
+      const controller = new AbortController()
+      controllers2.push(controller)
+
+      // NEW pattern - bind doesn't capture surrounding scope
+      const handler = controller.abort.bind(controller)
+      handlers2.push(handler)
+      const timeoutId = setTimeout(handler, 30000)
+      timers2.push(timeoutId)
+    }
+
+    Bun.gc(true)
+    Bun.sleepSync(100)
+    const after2 = getHeapMB()
+    const newGrowth = after2 - baseline2
+
+    // Cleanup after measuring
+    timers2.forEach(clearTimeout)
+    controllers2.forEach((c) => c.abort())
+    handlers2.length = 0
+
+    console.log(`NEW pattern (bind): ${newGrowth.toFixed(2)} MB growth`)
+    console.log(`Improvement: ${(oldGrowth - newGrowth).toFixed(2)} MB saved`)
+
+    expect(newGrowth).toBeLessThanOrEqual(oldGrowth)
+  })
+})

package/test/patch/patch.test.ts

@@ -0,0 +1,348 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import { Patch } from "../../src/patch"
+import * as fs from "fs/promises"
+import * as path from "path"
+import { tmpdir } from "os"
+
+describe("Patch namespace", () => {
+  let tempDir: string
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(tmpdir(), "patch-test-"))
+  })
+
+  afterEach(async () => {
+    // Clean up temp directory
+    await fs.rm(tempDir, { recursive: true, force: true })
+  })
+
+  describe("parsePatch", () => {
+    test("should parse simple add file patch", () => {
+      const patchText = `*** Begin Patch
+*** Add File: test.txt
++Hello World
+*** End Patch`
+
+      const result = Patch.parsePatch(patchText)
+      expect(result.hunks).toHaveLength(1)
+      expect(result.hunks[0]).toEqual({
+        type: "add",
+        path: "test.txt",
+        contents: "Hello World",
+      })
+    })
+
+    test("should parse delete file patch", () => {
+      const patchText = `*** Begin Patch
+*** Delete File: old.txt
+*** End Patch`
+
+      const result = Patch.parsePatch(patchText)
+      expect(result.hunks).toHaveLength(1)
+      const hunk = result.hunks[0]
+      expect(hunk.type).toBe("delete")
+      expect(hunk.path).toBe("old.txt")
+    })
+
+    test("should parse patch with multiple hunks", () => {
+      const patchText = `*** Begin Patch
+*** Add File: new.txt
++This is a new file
+*** Update File: existing.txt
+@@
+ old line
+-new line
++updated line
+*** End Patch`
+
+      const result = Patch.parsePatch(patchText)
+      expect(result.hunks).toHaveLength(2)
+      expect(result.hunks[0].type).toBe("add")
+      expect(result.hunks[1].type).toBe("update")
+    })
+
+    test("should parse file move operation", () => {
+      const patchText = `*** Begin Patch
+*** Update File: old-name.txt
+*** Move to: new-name.txt
+@@
+-Old content
++New content
+*** End Patch`
+
+      const result = Patch.parsePatch(patchText)
+      expect(result.hunks).toHaveLength(1)
+      const hunk = result.hunks[0]
+      expect(hunk.type).toBe("update")
+      expect(hunk.path).toBe("old-name.txt")
+      if (hunk.type === "update") {
+        expect(hunk.move_path).toBe("new-name.txt")
+      }
+    })
+
+    test("should throw error for invalid patch format", () => {
+      const invalidPatch = `This is not a valid patch`
+
+      expect(() => Patch.parsePatch(invalidPatch)).toThrow("Invalid patch format")
+    })
+  })
+
+  describe("maybeParseApplyPatch", () => {
+    test("should parse direct apply_patch command", () => {
+      const patchText = `*** Begin Patch
+*** Add File: test.txt
++Content
+*** End Patch`
+
+      const result = Patch.maybeParseApplyPatch(["apply_patch", patchText])
+      expect(result.type).toBe(Patch.MaybeApplyPatch.Body)
+      if (result.type === Patch.MaybeApplyPatch.Body) {
+        expect(result.args.patch).toBe(patchText)
+        expect(result.args.hunks).toHaveLength(1)
+      }
+    })
+
+    test("should parse applypatch command", () => {
+      const patchText = `*** Begin Patch
+*** Add File: test.txt
++Content
+*** End Patch`
+
+      const result = Patch.maybeParseApplyPatch(["applypatch", patchText])
+      expect(result.type).toBe(Patch.MaybeApplyPatch.Body)
+    })
+
+    test("should handle bash heredoc format", () => {
+      const script = `apply_patch <<'PATCH'
+*** Begin Patch
+*** Add File: test.txt
++Content
+*** End Patch
+PATCH`
+
+      const result = Patch.maybeParseApplyPatch(["bash", "-lc", script])
+      expect(result.type).toBe(Patch.MaybeApplyPatch.Body)
+      if (result.type === Patch.MaybeApplyPatch.Body) {
+        expect(result.args.hunks).toHaveLength(1)
+      }
+    })
+
+    test("should return NotApplyPatch for non-patch commands", () => {
+      const result = Patch.maybeParseApplyPatch(["echo", "hello"])
+      expect(result.type).toBe(Patch.MaybeApplyPatch.NotApplyPatch)
+    })
+  })
+
+  describe("applyPatch", () => {
+    test("should add a new file", async () => {
+      const patchText = `*** Begin Patch
+*** Add File: ${tempDir}/new-file.txt
++Hello World
++This is a new file
+*** End Patch`
+
+      const result = await Patch.applyPatch(patchText)
+      expect(result.added).toHaveLength(1)
+      expect(result.modified).toHaveLength(0)
+      expect(result.deleted).toHaveLength(0)
+
+      const content = await fs.readFile(result.added[0], "utf-8")
+      expect(content).toBe("Hello World\nThis is a new file")
+    })
+
+    test("should delete an existing file", async () => {
+      const filePath = path.join(tempDir, "to-delete.txt")
+      await fs.writeFile(filePath, "This file will be deleted")
+
+      const patchText = `*** Begin Patch
+*** Delete File: ${filePath}
+*** End Patch`
+
+      const result = await Patch.applyPatch(patchText)
+      expect(result.deleted).toHaveLength(1)
+      expect(result.deleted[0]).toBe(filePath)
+
+      const exists = await fs
+        .access(filePath)
+        .then(() => true)
+        .catch(() => false)
+      expect(exists).toBe(false)
+    })
+
+    test("should update an existing file", async () => {
+      const filePath = path.join(tempDir, "to-update.txt")
+      await fs.writeFile(filePath, "line 1\nline 2\nline 3\n")
+
+      const patchText = `*** Begin Patch
+*** Update File: ${filePath}
+@@
+ line 1
+-line 2
++line 2 updated
+ line 3
+*** End Patch`
+
+      const result = await Patch.applyPatch(patchText)
+      expect(result.modified).toHaveLength(1)
+      expect(result.modified[0]).toBe(filePath)
+
+      const content = await fs.readFile(filePath, "utf-8")
+      expect(content).toBe("line 1\nline 2 updated\nline 3\n")
+    })
+
+    test("should move and update a file", async () => {
+      const oldPath = path.join(tempDir, "old-name.txt")
+      const newPath = path.join(tempDir, "new-name.txt")
+      await fs.writeFile(oldPath, "old content\n")
+
+      const patchText = `*** Begin Patch
+*** Update File: ${oldPath}
+*** Move to: ${newPath}
+@@
+-old content
++new content
+*** End Patch`
+
+      const result = await Patch.applyPatch(patchText)
+      expect(result.modified).toHaveLength(1)
+      expect(result.modified[0]).toBe(newPath)
+
+      const oldExists = await fs
+        .access(oldPath)
+        .then(() => true)
+        .catch(() => false)
+      expect(oldExists).toBe(false)
+
+      const newContent = await fs.readFile(newPath, "utf-8")
+      expect(newContent).toBe("new content\n")
+    })
+
+    test("should handle multiple operations in one patch", async () => {
+      const file1 = path.join(tempDir, "file1.txt")
+      const file2 = path.join(tempDir, "file2.txt")
+      const file3 = path.join(tempDir, "file3.txt")
+
+      await fs.writeFile(file1, "content 1")
+      await fs.writeFile(file2, "content 2")
+
+      const patchText = `*** Begin Patch
+*** Add File: ${file3}
++new file content
+*** Update File: ${file1}
+@@
+-content 1
++updated content 1
+*** Delete File: ${file2}
+*** End Patch`
+
+      const result = await Patch.applyPatch(patchText)
+      expect(result.added).toHaveLength(1)
+      expect(result.modified).toHaveLength(1)
+      expect(result.deleted).toHaveLength(1)
+    })
+
+    test("should create parent directories when adding files", async () => {
+      const nestedPath = path.join(tempDir, "deep", "nested", "file.txt")
+
+      const patchText = `*** Begin Patch
+*** Add File: ${nestedPath}
++Deep nested content
+*** End Patch`
+
+      const result = await Patch.applyPatch(patchText)
+      expect(result.added).toHaveLength(1)
+      expect(result.added[0]).toBe(nestedPath)
+
+      const exists = await fs
+        .access(nestedPath)
+        .then(() => true)
+        .catch(() => false)
+      expect(exists).toBe(true)
+    })
+  })
+
+  describe("error handling", () => {
+    test("should throw error when updating non-existent file", async () => {
+      const nonExistent = path.join(tempDir, "does-not-exist.txt")
+
+      const patchText = `*** Begin Patch
+*** Update File: ${nonExistent}
+@@
+-old line
++new line
+*** End Patch`
+
+      await expect(Patch.applyPatch(patchText)).rejects.toThrow()
+    })
+
+    test("should throw error when deleting non-existent file", async () => {
+      const nonExistent = path.join(tempDir, "does-not-exist.txt")
+
+      const patchText = `*** Begin Patch
+*** Delete File: ${nonExistent}
+*** End Patch`
+
+      await expect(Patch.applyPatch(patchText)).rejects.toThrow()
+    })
+  })
+
+  describe("edge cases", () => {
+    test("should handle empty files", async () => {
+      const emptyFile = path.join(tempDir, "empty.txt")
+      await fs.writeFile(emptyFile, "")
+
+      const patchText = `*** Begin Patch
+*** Update File: ${emptyFile}
+@@
++First line
+*** End Patch`
+
+      const result = await Patch.applyPatch(patchText)
+      expect(result.modified).toHaveLength(1)
+
+      const content = await fs.readFile(emptyFile, "utf-8")
+      expect(content).toBe("First line\n")
+    })
+
+    test("should handle files with no trailing newline", async () => {
+      const filePath = path.join(tempDir, "no-newline.txt")
+      await fs.writeFile(filePath, "no newline")
+
+      const patchText = `*** Begin Patch
+*** Update File: ${filePath}
+@@
+-no newline
++has newline now
+*** End Patch`
+
+      const result = await Patch.applyPatch(patchText)
+      expect(result.modified).toHaveLength(1)
+
+      const content = await fs.readFile(filePath, "utf-8")
+      expect(content).toBe("has newline now\n")
+    })
+
+    test("should handle multiple update chunks in single file", async () => {
+      const filePath = path.join(tempDir, "multi-chunk.txt")
+      await fs.writeFile(filePath, "line 1\nline 2\nline 3\nline 4\n")
+
+      const patchText = `*** Begin Patch
+*** Update File: ${filePath}
+@@
+ line 1
+-line 2
++LINE 2
+@@
+ line 3
+-line 4
++LINE 4
+*** End Patch`
+
+      const result = await Patch.applyPatch(patchText)
+      expect(result.modified).toHaveLength(1)
+
+      const content = await fs.readFile(filePath, "utf-8")
+      expect(content).toBe("line 1\nLINE 2\nline 3\nLINE 4\n")
+    })
+  })
+})

package/test/permission/arity.test.ts

@@ -0,0 +1,33 @@
+import { test, expect } from "bun:test"
+import { BashArity } from "../../src/permission/arity"
+
+test("arity 1 - unknown commands default to first token", () => {
+  expect(BashArity.prefix(["unknown", "command", "subcommand"])).toEqual(["unknown"])
+  expect(BashArity.prefix(["touch", "foo.txt"])).toEqual(["touch"])
+})
+
+test("arity 2 - two token commands", () => {
+  expect(BashArity.prefix(["git", "checkout", "main"])).toEqual(["git", "checkout"])
+  expect(BashArity.prefix(["docker", "run", "nginx"])).toEqual(["docker", "run"])
+})
+
+test("arity 3 - three token commands", () => {
+  expect(BashArity.prefix(["aws", "s3", "ls", "my-bucket"])).toEqual(["aws", "s3", "ls"])
+  expect(BashArity.prefix(["npm", "run", "dev", "script"])).toEqual(["npm", "run", "dev"])
+})
+
+test("longest match wins - nested prefixes", () => {
+  expect(BashArity.prefix(["docker", "compose", "up", "service"])).toEqual(["docker", "compose", "up"])
+  expect(BashArity.prefix(["consul", "kv", "get", "config"])).toEqual(["consul", "kv", "get"])
+})
+
+test("exact length matches", () => {
+  expect(BashArity.prefix(["git", "checkout"])).toEqual(["git", "checkout"])
+  expect(BashArity.prefix(["npm", "run", "dev"])).toEqual(["npm", "run", "dev"])
+})
+
+test("edge cases", () => {
+  expect(BashArity.prefix([])).toEqual([])
+  expect(BashArity.prefix(["single"])).toEqual(["single"])
+  expect(BashArity.prefix(["git"])).toEqual(["git"])
+})