@opendash-ai/cli 0.1.0-beta.1 → 0.1.0-beta.3

package/test/memory/service.test.ts

@@ -1,169 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import * as fs from "fs/promises"
-import path from "path"
-import { Database } from "../../src/storage"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { MemoryFtsTable } from "../../src/memory/fts.sql"
-import { Memory } from "../../src/memory"
-import { Instance } from "../../src/project/instance"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-afterEach(async () => {
-  // Clear shared in-memory DB rows so tests don't bleed into each other.
-  Database.use((db) => db.delete(MemoryFtsTable).run())
-  await Instance.disposeAll()
-})
-
-const it = testEffect(Layer.mergeAll(Memory.defaultLayer, CrossSpawnSpawner.defaultLayer))
-
-describe("Memory.search", () => {
-  it.live("returns BM25-ranked matches across all scopes when no scope filter", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const memory = yield* Memory.Service
-        const root = yield* memory.root()
-        yield* Effect.promise(() => fs.rm(root, { recursive: true, force: true }))
-        yield* Effect.promise(() => fs.mkdir(path.join(root, "global"), { recursive: true }))
-        yield* Effect.promise(() =>
-          fs.writeFile(path.join(root, "global", "auth.md"), "JWT signing with RS256 algorithm"),
-        )
-        yield* Effect.promise(() =>
-          fs.writeFile(path.join(root, "global", "perf.md"), "database query optimization tips"),
-        )
-
-        const results = yield* memory.search({ query: "JWT" })
-        expect(results.length).toBe(1)
-        expect(results[0].path).toContain("auth.md")
-        expect(results[0].score).toBeGreaterThan(0)
-      }),
-    ),
-  )
-
-  it.live("filters by scope", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const memory = yield* Memory.Service
-        const root = yield* memory.root()
-        yield* Effect.promise(() => fs.rm(root, { recursive: true, force: true }))
-        yield* Effect.promise(() => fs.mkdir(path.join(root, "global"), { recursive: true }))
-        yield* Effect.promise(() => fs.mkdir(path.join(root, "sessions/ses_a"), { recursive: true }))
-        yield* Effect.promise(() => fs.writeFile(path.join(root, "global", "x.md"), "matching content"))
-        yield* Effect.promise(() => fs.writeFile(path.join(root, "sessions/ses_a", "x.md"), "matching content"))
-
-        const globalOnly = yield* memory.search({ query: "matching", scope: "global" })
-        expect(globalOnly.length).toBe(1)
-        expect(globalOnly[0].path).toContain("/global/")
-
-        const sessionOnly = yield* memory.search({ query: "matching", scope: "sessions" })
-        expect(sessionOnly.length).toBe(1)
-        expect(sessionOnly[0].path).toContain("/sessions/")
-      }),
-    ),
-  )
-
-  it.live("filters by scope_id when scope is sessions", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const memory = yield* Memory.Service
-        const root = yield* memory.root()
-        yield* Effect.promise(() => fs.rm(root, { recursive: true, force: true }))
-        yield* Effect.promise(() => fs.mkdir(path.join(root, "sessions/ses_a"), { recursive: true }))
-        yield* Effect.promise(() => fs.mkdir(path.join(root, "sessions/ses_b"), { recursive: true }))
-        yield* Effect.promise(() => fs.writeFile(path.join(root, "sessions/ses_a", "x.md"), "alpha content"))
-        yield* Effect.promise(() => fs.writeFile(path.join(root, "sessions/ses_b", "x.md"), "alpha content"))
-
-        const aOnly = yield* memory.search({ query: "alpha", scope: "sessions", scope_id: "ses_a" })
-        expect(aOnly.length).toBe(1)
-        expect(aOnly[0].path).toContain("ses_a")
-      }),
-    ),
-  )
-
-  it.live("respects limit", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const memory = yield* Memory.Service
-        const root = yield* memory.root()
-        yield* Effect.promise(() => fs.rm(root, { recursive: true, force: true }))
-        yield* Effect.promise(() => fs.mkdir(path.join(root, "global"), { recursive: true }))
-        for (let i = 0; i < 15; i++) {
-          yield* Effect.promise(() => fs.writeFile(path.join(root, "global", `f${i}.md`), `match ${i}`))
-        }
-
-        const r5 = yield* memory.search({ query: "match", limit: 5 })
-        expect(r5.length).toBe(5)
-      }),
-    ),
-  )
-
-  it.live("does not crash on FTS5 special chars in query", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const memory = yield* Memory.Service
-        const root = yield* memory.root()
-        yield* Effect.promise(() => fs.rm(root, { recursive: true, force: true }))
-        yield* Effect.promise(() => fs.mkdir(path.join(root, "global"), { recursive: true }))
-        yield* Effect.promise(() =>
-          fs.writeFile(path.join(root, "global", "x.md"), 'literal "quoted" content with stars'),
-        )
-
-        // Each of these contains a char that would crash the FTS5 MATCH parser
-        // if the query were not phrase-wrapped: `"`, `*`, `(`, prefix `-`.
-        for (const q of ['"quoted"', "wild*", "(paren)", "-not", "and"]) {
-          const results = yield* memory.search({ query: q })
-          expect(Array.isArray(results)).toBe(true)
-        }
-      }),
-    ),
-  )
-
-  it.live("multi-word query OR-matches across tokens, splits punctuation", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const memory = yield* Memory.Service
-        const root = yield* memory.root()
-        yield* Effect.promise(() => fs.rm(root, { recursive: true, force: true }))
-        yield* Effect.promise(() => fs.mkdir(path.join(root, "global"), { recursive: true }))
-        yield* Effect.promise(() =>
-          fs.writeFile(
-            path.join(root, "global", "doc.md"),
-            "T5.3 closure conversion abandoned — out of v0.1 scope per spec.md §4.4",
-          ),
-        )
-        yield* Effect.promise(() =>
-          fs.writeFile(path.join(root, "global", "other.md"), "unrelated text only"),
-        )
-
-        // Identifier with dot: tokenizer splits T5.3 into [t5, 3]; OR-join +
-        // BM25 ranks doc.md (which contains both + "closure") top.
-        const dotted = yield* memory.search({ query: "T5.3 closure" })
-        expect(dotted.length).toBeGreaterThanOrEqual(1)
-        expect(dotted[0].path).toContain("doc.md")
-
-        // Multi-word: both words appear in doc.md, other.md has neither →
-        // only doc.md is above the score floor.
-        const both = yield* memory.search({ query: "abandoned scope" })
-        expect(both.length).toBe(1)
-        expect(both[0].path).toContain("doc.md")
-
-        // OR semantics: one word present ("abandoned"), one absent
-        // ("nonexistentterm") → still matches doc.md (unlike old AND, which
-        // returned 0). This is the recall fix: a stray non-matching word no
-        // longer zeroes the query.
-        const orHit = yield* memory.search({ query: "abandoned nonexistentterm" })
-        expect(orHit.length).toBe(1)
-        expect(orHit[0].path).toContain("doc.md")
-
-        // A query of ONLY absent words → genuinely 0.
-        const trueMiss = yield* memory.search({ query: "nonexistentterm anotherbogusword" })
-        expect(trueMiss.length).toBe(0)
-
-        // Empty query returns empty array (early-return path).
-        const empty = yield* memory.search({ query: "   " })
-        expect(empty.length).toBe(0)
-      }),
-    ),
-  )
-})

package/test/npm.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Npm } from "../src/npm"
-
-const win = process.platform === "win32"
-
-describe("Npm.sanitize", () => {
-  test("keeps normal scoped package specs unchanged", () => {
-    expect(Npm.sanitize("@opendash/acme")).toBe("@opendash/acme")
-    expect(Npm.sanitize("@opendash/acme@1.0.0")).toBe("@opendash/acme@1.0.0")
-    expect(Npm.sanitize("prettier")).toBe("prettier")
-  })
-
-  test("handles git https specs", () => {
-    const spec = "acme@git+https://github.com/opendash/acme.git"
-    const expected = win ? "acme@git+https_//github.com/opendash/acme.git" : spec
-    expect(Npm.sanitize(spec)).toBe(expected)
-  })
-})

package/test/patch/patch.test.ts

@@ -1,348 +0,0 @@
-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/abort.test.ts

@@ -1,116 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer, Fiber } from "effect"
-import { Bus } from "../../src/bus"
-import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"
-import { Permission } from "../../src/permission"
-import { Instance } from "../../src/project/instance"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { Log } from "../../src/util"
-
-void Log.init({ print: false })
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-const bus = Bus.layer
-const env = Layer.mergeAll(Permission.layer.pipe(Layer.provide(bus)), bus, CrossSpawnSpawner.defaultLayer)
-const it = testEffect(env)
-
-// Build a request that genuinely needs ask (no rule auto-approves).
-// Specific permission name + pattern must NOT have a default rule allowing it.
-function buildRequest() {
-  return {
-    permission: "read" as never,
-    patterns: ["/some/never-allowed-path"],
-    always: ["*"],
-    metadata: {},
-    sessionID: "ses_test" as never,
-    ruleset: [], // empty ruleset → evaluate falls through to needsAsk
-    tool: { messageID: "msg_test" as never, callID: "call_test" },
-  }
-}
-
-describe("Permission.ask abortSignal (Spec ③ P3)", () => {
-  it.live(
-    "fails when signal already aborted",
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const perm = yield* Permission.Service
-        const ctl = new AbortController()
-        ctl.abort()
-        const result = yield* perm.ask(buildRequest(), ctl.signal).pipe(Effect.exit)
-        expect(result._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live(
-    "fails when signal aborts mid-await",
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const perm = yield* Permission.Service
-        const ctl = new AbortController()
-        const fiber = yield* perm.ask(buildRequest(), ctl.signal).pipe(Effect.forkScoped)
-        yield* Effect.sleep("20 millis")
-        ctl.abort()
-        const result = yield* Fiber.join(fiber).pipe(Effect.exit)
-        expect(result._tag).toBe("Failure")
-      }),
-    ),
-  )
-
-  it.live(
-    "no abortSignal → behavior unchanged (backward compat)",
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const perm = yield* Permission.Service
-        // Without abortSignal, the ask should suspend awaiting reply.
-        // We fork it, wait briefly, then verify nothing crashed.
-        const fiber = yield* perm.ask(buildRequest()).pipe(Effect.forkScoped)
-        yield* Effect.sleep("30 millis")
-        // Fiber should still be pending; we interrupt it to clean up.
-        yield* Fiber.interrupt(fiber)
-        // Just assert the fork itself didn't throw synchronously.
-        expect(fiber).toBeDefined()
-      }),
-    ),
-  )
-
-  it.live(
-    "abortSignal listener is removed after race resolves (C1 regression: no leak)",
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const perm = yield* Permission.Service
-        const ctl = new AbortController()
-        // Spy on addEventListener / removeEventListener to count net listeners.
-        let netListeners = 0
-        const realAdd = ctl.signal.addEventListener.bind(ctl.signal)
-        const realRemove = ctl.signal.removeEventListener.bind(ctl.signal)
-        ctl.signal.addEventListener = ((type: string, ...rest: unknown[]) => {
-          if (type === "abort") netListeners += 1
-          return (realAdd as unknown as (t: string, ...r: unknown[]) => void)(type, ...rest)
-        }) as typeof ctl.signal.addEventListener
-        ctl.signal.removeEventListener = ((type: string, ...rest: unknown[]) => {
-          if (type === "abort") netListeners -= 1
-          return (realRemove as unknown as (t: string, ...r: unknown[]) => void)(type, ...rest)
-        }) as typeof ctl.signal.removeEventListener
-
-        // Fork ask with the spied signal; let it attach the listener.
-        const fiber = yield* perm.ask(buildRequest(), ctl.signal).pipe(Effect.forkScoped)
-        yield* Effect.sleep("20 millis")
-        expect(netListeners).toBe(1) // listener attached during await
-
-        // Interrupting the fiber cancels Effect.race, which interrupts the
-        // Effect.callback body, which runs the cleanup that removes the
-        // listener. The Effect.promise variant would NOT do this — that's
-        // the C1 leak the cleanup return-effect guards against.
-        yield* Fiber.interrupt(fiber)
-        yield* Effect.sleep("10 millis") // give cleanup a tick to run
-
-        expect(netListeners).toBe(0) // cleanup removed the listener
-      }),
-    ),
-  )
-})

package/test/permission/arity.test.ts

@@ -1,33 +0,0 @@
-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"])
-})