saeeol 1.2.5 → 1.2.8

package/test/saeeol/external-directory-boundary.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import path from "path"
-import type { Permission } from "../../src/permission"
-import { Instance } from "../../src/project/instance"
-import { InstanceStore } from "../../src/project/instance-store"
-import { SessionID, MessageID } from "../../src/session/schema"
-import { assertExternalDirectory } from "../../src/tool/external-directory"
-import type { Tool } from "../../src/tool/tool"
-import { Filesystem } from "../../src/util/filesystem"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { tmpdir } from "../fixture/fixture"
-
-const base: Omit<Tool.Context, "ask"> = {
-  sessionID: SessionID.make("ses_test-boundary-session"),
-  messageID: MessageID.make(""),
-  callID: "",
-  agent: "code",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => Effect.void,
-}
-
-const glob = (p: string) =>
-  process.platform === "win32" ? AppFileSystem.normalizePathPattern(p) : p.replaceAll("\\", "/")
-
-const asks = () => {
-  const items: Array<Omit<Permission.Request, "id" | "sessionID" | "tool">> = []
-  const ctx: Tool.Context = {
-    ...base,
-    ask: (req) =>
-      Effect.sync(() => {
-        items.push(req)
-      }),
-  }
-  return { items, ctx }
-}
-
-describe("saeeol external directory boundaries", () => {
-  test("asks before accessing outside a repo-root session", async () => {
-    await using repo = await tmpdir({ git: true })
-    await using outer = await tmpdir()
-    const file = path.join(outer.path, "outside.txt")
-    const { items, ctx } = asks()
-
-    await Instance.provide({
-      directory: repo.path,
-      fn: async () => {
-        try {
-          await assertExternalDirectory(ctx, file)
-        } finally {
-          await InstanceStore.disposeInstance(Instance.current)
-        }
-      },
-    })
-
-    const ext = items.find((item) => item.permission === "external_directory")
-    expect(ext).toBeDefined()
-    expect(ext!.patterns).toEqual([glob(path.join(outer.path, "*"))])
-    expect(ext!.always).toEqual([glob(path.join(outer.path, "*"))])
-    expect(ext!.metadata).toMatchObject({ filepath: file, parentDir: outer.path })
-  })
-
-  test("asks when the instance directory is a filesystem root", async () => {
-    await using outer = await tmpdir()
-    const root = path.parse(outer.path).root
-    const file = path.join(outer.path, "outside-root.txt")
-    const { items, ctx } = asks()
-
-    await Instance.provide({
-      directory: root,
-      fn: async () => {
-        try {
-          await assertExternalDirectory(ctx, file)
-        } finally {
-          await InstanceStore.disposeInstance(Instance.current)
-        }
-      },
-    })
-
-    const ext = items.find((item) => item.permission === "external_directory")
-    expect(ext).toBeDefined()
-    expect(ext!.patterns).toEqual([glob(path.join(outer.path, "*"))])
-    expect(ext!.metadata).toMatchObject({ filepath: file, parentDir: outer.path })
-  })
-
-  test("contains helpers keep dot-prefixed child names internal", () => {
-    expect(Filesystem.contains("/project", "/project/..cache/file")).toBe(true)
-    expect(AppFileSystem.contains("/a/b", "/a/b/..cache/file")).toBe(true)
-  })
-
-  test("AppFileSystem.contains rejects cross-drive paths on Windows", () => {
-    if (process.platform !== "win32") return
-    expect(AppFileSystem.contains("C:\\repo", "D:\\outside\\file.txt")).toBe(false)
-  })
-})

package/test/saeeol/gateway-headers.test.ts

@@ -1,88 +0,0 @@
-import { describe, it, expect, afterEach } from "bun:test"
-import { buildSaeeolHeaders, getFeatureHeader, getEditorNameHeader } from "@saeeol/gateway"
-import { HEADER_FEATURE, ENV_FEATURE, ENV_VERSION, DEFAULT_EDITOR_NAME } from "@saeeol/gateway"
-
-describe("getFeatureHeader", () => {
-  const original = process.env[ENV_FEATURE]
-
-  afterEach(() => {
-    if (original === undefined) {
-      delete process.env[ENV_FEATURE]
-    } else {
-      process.env[ENV_FEATURE] = original
-    }
-  })
-
-  it("returns undefined when env var is not set", () => {
-    delete process.env[ENV_FEATURE]
-    expect(getFeatureHeader()).toBeUndefined()
-  })
-
-  it("returns the env var value when set", () => {
-    process.env[ENV_FEATURE] = "cloud-agent"
-    expect(getFeatureHeader()).toBe("cloud-agent")
-  })
-
-  it("returns undefined for empty string", () => {
-    process.env[ENV_FEATURE] = ""
-    expect(getFeatureHeader()).toBeUndefined()
-  })
-})
-
-describe("getEditorNameHeader", () => {
-  const originalVersion = process.env[ENV_VERSION]
-
-  afterEach(() => {
-    if (originalVersion === undefined) {
-      delete process.env[ENV_VERSION]
-    } else {
-      process.env[ENV_VERSION] = originalVersion
-    }
-  })
-
-  it("returns default editor name without version when SAEEOL_VERSION is not set", () => {
-    delete process.env[ENV_VERSION]
-    expect(getEditorNameHeader()).toBe(DEFAULT_EDITOR_NAME)
-  })
-
-  it("appends version when SAEEOL_VERSION is set", () => {
-    process.env[ENV_VERSION] = "1.2.3"
-    expect(getEditorNameHeader()).toBe(`${DEFAULT_EDITOR_NAME} 1.2.3`)
-  })
-})
-
-describe("buildSaeeolHeaders", () => {
-  const original = process.env[ENV_FEATURE]
-
-  afterEach(() => {
-    if (original === undefined) {
-      delete process.env[ENV_FEATURE]
-    } else {
-      process.env[ENV_FEATURE] = original
-    }
-  })
-
-  it("includes feature header when env var is set", () => {
-    process.env[ENV_FEATURE] = "vscode-extension"
-    const headers = buildSaeeolHeaders()
-    expect(headers[HEADER_FEATURE]).toBe("vscode-extension")
-  })
-
-  it("omits feature header when env var is not set", () => {
-    delete process.env[ENV_FEATURE]
-    const headers = buildSaeeolHeaders()
-    expect(headers[HEADER_FEATURE]).toBeUndefined()
-  })
-
-  it("always includes editor name header", () => {
-    delete process.env[ENV_FEATURE]
-    const headers = buildSaeeolHeaders()
-    expect(headers["X-SAEEOL-EDITORNAME"]).toBe(getEditorNameHeader())
-  })
-
-  it("passes through any feature value from env", () => {
-    process.env[ENV_FEATURE] = "custom-feature"
-    const headers = buildSaeeolHeaders()
-    expect(headers[HEADER_FEATURE]).toBe("custom-feature")
-  })
-})

package/test/saeeol/help.test.ts

@@ -1,191 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import path from "path"
-import { generateHelp, generateCommandTable } from "../../src/overlay/help"
-import { AcpCommand } from "../../src/cli/cmd/acp"
-import { McpCommand } from "../../src/cli/cmd/mcp"
-import { RunCommand } from "../../src/cli/cmd/run"
-import { GenerateCommand } from "../../src/cli/cmd/generate"
-import { DebugCommand } from "../../src/cli/cmd/debug"
-import { ProvidersCommand } from "../../src/cli/cmd/providers" 
-import { AgentCommand } from "../../src/cli/cmd/agent"
-import { UpgradeCommand } from "../../src/cli/cmd/upgrade"
-import { UninstallCommand } from "../../src/cli/cmd/uninstall"
-import { ServeCommand } from "../../src/cli/cmd/serve"
-import { WebCommand } from "../../src/cli/cmd/web"
-import { ModelsCommand } from "../../src/cli/cmd/models"
-import { StatsCommand } from "../../src/cli/cmd/stats"
-import { ExportCommand } from "../../src/cli/cmd/export"
-import { ImportCommand } from "../../src/cli/cmd/import"
-import { PrCommand } from "../../src/cli/cmd/pr"
-import { SessionCommand } from "../../src/cli/cmd/session"
-import { RemoteCommand } from "../../src/cli/cmd/remote"
-import { ConfigCommand as ConfigCLICommand } from "../../src/cli/cmd/config"
-import { PluginCommand } from "../../src/cli/cmd/plug"
-import { DbCommand } from "../../src/cli/cmd/db"
-import { HelpCommand } from "../../src/overlay/help-command"
-
-// Stand-in for TuiThreadCommand — the real one imports @opentui/solid which
-// doesn't resolve in the test environment. Only command/describe matter here.
-const TuiStub = {
-  command: "$0 [project]",
-  describe: "start saeeol tui",
-  handler() {},
-}
-
-// Stand-in for AttachCommand — same reason as TuiStub above.
-const AttachStub = {
-  command: "attach <url>",
-  describe: "attach to a running saeeol server",
-  handler() {},
-}
-
-// Synthetic entry for the yargs built-in .completion() command
-const CompletionStub = {
-  command: "completion",
-  describe: "generate shell completion script",
-  handler() {},
-}
-
-const commands = [
-  AcpCommand,
-  McpCommand,
-  TuiStub,
-  AttachStub,
-  RunCommand,
-  GenerateCommand,
-  DebugCommand,
-  ProvidersCommand,
-  AgentCommand,
-  UpgradeCommand,
-  UninstallCommand,
-  ServeCommand,
-  WebCommand,
-  ModelsCommand,
-  StatsCommand,
-  ExportCommand,
-  ImportCommand,
-  PrCommand,
-  SessionCommand,
-  RemoteCommand,
-  DbCommand,
-  ConfigCLICommand,
-  PluginCommand,
-  HelpCommand,
-  CompletionStub,
-] as any[]
-
-describe("saeeol help --all (markdown)", () => {
-  test("contains ## heading for each known top-level command", async () => {
-    const output = await generateHelp({ all: true, format: "md", commands })
-    for (const cmd of ["run", "auth", "debug", "mcp", "session", "agent"]) {
-      expect(output).toContain(`## saeeol ${cmd}`)
-    }
-  })
-
-  test("contains headings for nested subcommands", async () => {
-    const output = await generateHelp({ all: true, format: "md", commands })
-    expect(output).toContain("saeeol auth login")
-    expect(output).toContain("saeeol auth logout")
-    expect(output).toContain("saeeol debug config")
-  })
-})
-
-describe("saeeol help --all (text)", () => {
-  test("does NOT contain Markdown ## headings or triple-backtick fences", async () => {
-    const output = await generateHelp({ all: true, format: "text", commands })
-    expect(output).not.toMatch(/^##\s/m)
-    expect(output).not.toContain("```")
-  })
-
-  test("still contains each command name", async () => {
-    const output = await generateHelp({ all: true, format: "text", commands })
-    for (const cmd of ["run", "auth", "debug", "mcp", "session", "agent"]) {
-      expect(output).toContain(`saeeol ${cmd}`)
-    }
-  })
-})
-
-describe("saeeol help <command>", () => {
-  test("saeeol help auth contains auth subcommand headings", async () => {
-    const output = await generateHelp({ command: "auth", format: "md", commands })
-    expect(output).toContain("saeeol auth login")
-    expect(output).toContain("saeeol auth logout")
-    expect(output).toContain("saeeol auth list")
-  })
-
-  test("saeeol help auth does NOT contain run or debug headings", async () => {
-    const output = await generateHelp({ command: "auth", format: "md", commands })
-    expect(output).not.toContain("## saeeol run")
-    expect(output).not.toContain("## saeeol debug")
-  })
-})
-
-describe("edge cases", () => {
-  test("output contains no ANSI escape sequences", async () => {
-    const output = await generateHelp({ all: true, format: "md", commands })
-    expect(/\x1b\[/.test(output)).toBe(false)
-  })
-
-  test("saeeol help nonexistent throws unknown command error", async () => {
-    await expect(generateHelp({ command: "nonexistent", commands })).rejects.toThrow("unknown command")
-  })
-})
-
-describe("generateCommandTable", () => {
-  test("returns a string containing a markdown table header", async () => {
-    const output = await generateCommandTable({ commands })
-    expect(output).toContain("| Command | Description |")
-  })
-
-  test("contains rows for known commands", async () => {
-    const output = await generateCommandTable({ commands })
-    for (const name of ["run", "auth", "debug", "mcp"]) {
-      expect(output).toContain(`saeeol ${name}`)
-    }
-  })
-
-  test("default command appears as saeeol [project], not $0", async () => {
-    const output = await generateCommandTable({ commands })
-    expect(output).toContain("`saeeol [project]`")
-    expect(output).not.toContain("$0")
-  })
-
-  test("contains no ANSI escape sequences", async () => {
-    const output = await generateCommandTable({ commands })
-    expect(/\x1b\[/.test(output)).toBe(false)
-  })
-
-  test("skips commands with no describe", async () => {
-    const output = await generateCommandTable({ commands })
-    expect(output).not.toContain("`saeeol generate`")
-  })
-
-  test("contains saeeol completion row", async () => {
-    const output = await generateCommandTable({ commands })
-    expect(output).toContain("`saeeol completion`")
-  })
-
-  test("contains saeeol help row", async () => {
-    const output = await generateCommandTable({ commands })
-    expect(output).toContain("`saeeol help")
-  })
-})
-
-describe("commands.ts stays in sync with index.ts", () => {
-  test("every .command() in index.ts has an entry in the commands array", async () => {
-    const index = await Bun.file(path.resolve(import.meta.dir, "../../src/index.ts")).text()
-    const barrel = await Bun.file(path.resolve(import.meta.dir, "../../src/overlay/commands.ts")).text()
-
-    // Match uncommented .command(XxxCommand) calls in index.ts
-    const registered = [...index.matchAll(/^\s*\.command\((\w+)\)/gm)].map((m) => m[1]!)
-    expect(registered.length).toBeGreaterThan(0)
-
-    // Extract identifiers inside the exported commands = [...] array, not just anywhere in the file
-    const arrayMatch = barrel.match(/export const commands\s*=\s*\[([\s\S]*?)\]/)
-    expect(arrayMatch).toBeTruthy()
-    const entries = [...arrayMatch![1]!.matchAll(/\b(\w+Command)\b/g)].map((m) => m[1]!)
-
-    const missing = registered.filter((name) => !entries.includes(name))
-    expect(missing).toEqual([])
-  })
-})

package/test/saeeol/ignore-migrator.test.ts

@@ -1,308 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { IgnoreMigrator } from "../../src/overlay/ignore-migrator"
-import { tmpdir } from "../fixture/fixture"
-import path from "path"
-
-describe("IgnoreMigrator", () => {
-  describe("parseIgnoreContent", () => {
-    test("parses basic patterns", () => {
-      const content = `
-# Comment
-secrets/
-*.env
-!.env.example
-`
-      const patterns = IgnoreMigrator.parseIgnoreContent(content)
-
-      expect(patterns).toEqual([
-        { pattern: "secrets/", negated: false },
-        { pattern: "*.env", negated: false },
-        { pattern: ".env.example", negated: true },
-      ])
-    })
-
-    test("ignores empty lines and comments", () => {
-      const content = `
-# This is a comment
-pattern1
-
-# Another comment
-pattern2
-`
-      const patterns = IgnoreMigrator.parseIgnoreContent(content)
-
-      expect(patterns).toHaveLength(2)
-      expect(patterns[0].pattern).toBe("pattern1")
-      expect(patterns[1].pattern).toBe("pattern2")
-    })
-
-    test("handles negation patterns", () => {
-      const content = `*.log
-!important.log`
-      const patterns = IgnoreMigrator.parseIgnoreContent(content)
-
-      expect(patterns[0]).toEqual({ pattern: "*.log", negated: false })
-      expect(patterns[1]).toEqual({ pattern: "important.log", negated: true })
-    })
-
-    test("handles empty content", () => {
-      const patterns = IgnoreMigrator.parseIgnoreContent("")
-      expect(patterns).toHaveLength(0)
-    })
-
-    test("handles content with only comments", () => {
-      const content = `# Comment 1
-# Comment 2`
-      const patterns = IgnoreMigrator.parseIgnoreContent(content)
-      expect(patterns).toHaveLength(0)
-    })
-
-    test("trims whitespace from patterns", () => {
-      const content = `  secrets/  
-  *.env  `
-      const patterns = IgnoreMigrator.parseIgnoreContent(content)
-
-      expect(patterns[0].pattern).toBe("secrets/")
-      expect(patterns[1].pattern).toBe("*.env")
-    })
-  })
-
-  describe("convertToGlob", () => {
-    test("converts directory pattern", () => {
-      expect(IgnoreMigrator.convertToGlob("secrets/")).toBe("secrets/*")
-    })
-
-    test("preserves simple filename pattern", () => {
-      // Saeeol's * already matches any path depth
-      expect(IgnoreMigrator.convertToGlob("*.env")).toBe("*.env")
-    })
-
-    test("converts rooted patterns", () => {
-      expect(IgnoreMigrator.convertToGlob("/root-only")).toBe("root-only")
-    })
-
-    test("preserves patterns with path separators", () => {
-      expect(IgnoreMigrator.convertToGlob("src/secrets/")).toBe("src/secrets/*")
-    })
-
-    test("handles double-star patterns", () => {
-      expect(IgnoreMigrator.convertToGlob("**/deep/")).toBe("*deep/*")
-    })
-
-    test("preserves simple filename without extension", () => {
-      // Saeeol's * already matches any path depth
-      expect(IgnoreMigrator.convertToGlob("Dockerfile")).toBe("Dockerfile")
-    })
-
-    test("preserves extension-only pattern", () => {
-      expect(IgnoreMigrator.convertToGlob("*.log")).toBe("*.log")
-    })
-
-    test("preserves nested path pattern", () => {
-      expect(IgnoreMigrator.convertToGlob("config/secrets.json")).toBe("config/secrets.json")
-    })
-  })
-
-  describe("buildPermissionRules", () => {
-    test("creates default allow rule", () => {
-      const rules = IgnoreMigrator.buildPermissionRules([])
-      expect(rules["*"]).toBe("allow")
-    })
-
-    test("creates deny rules for patterns", () => {
-      const patterns = [{ pattern: "secrets/", negated: false, source: "project" as const }]
-      const rules = IgnoreMigrator.buildPermissionRules(patterns)
-
-      expect(rules["*"]).toBe("allow")
-      expect(rules["secrets/*"]).toBe("deny")
-    })
-
-    test("creates allow rules for negated patterns", () => {
-      const patterns = [
-        { pattern: "*.env", negated: false, source: "project" as const },
-        { pattern: ".env.example", negated: true, source: "project" as const },
-      ]
-      const rules = IgnoreMigrator.buildPermissionRules(patterns)
-
-      expect(rules["*.env"]).toBe("deny")
-      expect(rules[".env.example"]).toBe("allow")
-    })
-
-    test("handles multiple deny patterns", () => {
-      const patterns = [
-        { pattern: "secrets/", negated: false, source: "project" as const },
-        { pattern: "*.env", negated: false, source: "project" as const },
-        { pattern: "*.key", negated: false, source: "project" as const },
-      ]
-      const rules = IgnoreMigrator.buildPermissionRules(patterns)
-
-      expect(rules["secrets/*"]).toBe("deny")
-      expect(rules["*.env"]).toBe("deny")
-      expect(rules["*.key"]).toBe("deny")
-    })
-
-    test("negated patterns override deny patterns", () => {
-      const patterns = [
-        { pattern: "config/", negated: false, source: "project" as const },
-        { pattern: "config/public.json", negated: true, source: "project" as const },
-      ]
-      const rules = IgnoreMigrator.buildPermissionRules(patterns)
-
-      expect(rules["config/*"]).toBe("deny")
-      expect(rules["config/public.json"]).toBe("allow")
-    })
-  })
-
-  describe("migrate", () => {
-    test("returns empty permission for project without .saeeolignore", async () => {
-      await using tmp = await tmpdir()
-
-      const result = await IgnoreMigrator.migrate({
-        projectDir: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result.patternCount).toBe(0)
-      expect(Object.keys(result.permission)).toHaveLength(0)
-    })
-
-    test("loads project .saeeolignore", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolignore"), "secrets/\n*.env")
-        },
-      })
-
-      const result = await IgnoreMigrator.migrate({
-        projectDir: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result.patternCount).toBe(2)
-      expect(result.permission.read).toBeDefined()
-      expect(result.permission.edit).toBeDefined()
-    })
-
-    test("applies patterns to both read and edit", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolignore"), "secrets/")
-        },
-      })
-
-      const result = await IgnoreMigrator.migrate({
-        projectDir: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      const readRules = result.permission.read as Record<string, string>
-      const editRules = result.permission.edit as Record<string, string>
-
-      expect(readRules["secrets/*"]).toBe("deny")
-      expect(editRules["secrets/*"]).toBe("deny")
-    })
-
-    test("handles negation patterns correctly", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolignore"), "*.env\n!.env.example")
-        },
-      })
-
-      const result = await IgnoreMigrator.migrate({
-        projectDir: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      const readRules = result.permission.read as Record<string, string>
-
-      expect(readRules["*.env"]).toBe("deny")
-      expect(readRules[".env.example"]).toBe("allow")
-    })
-
-    test("handles complex .saeeolignore file", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(
-            path.join(dir, ".saeeolignore"),
-            `# Secrets
-secrets/
-*.env
-!.env.example
-
-# Keys
-*.key
-*.pem
-
-# Config
-/config/private/
-!config/private/public.json
-`,
-          )
-        },
-      })
-
-      const result = await IgnoreMigrator.migrate({
-        projectDir: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result.patternCount).toBe(7)
-
-      const readRules = result.permission.read as Record<string, string>
-      expect(readRules["*"]).toBe("allow")
-      expect(readRules["secrets/*"]).toBe("deny")
-      expect(readRules["*.env"]).toBe("deny")
-      expect(readRules[".env.example"]).toBe("allow")
-      expect(readRules["*.key"]).toBe("deny")
-      expect(readRules["*.pem"]).toBe("deny")
-      expect(readRules["config/private/*"]).toBe("deny")
-      expect(readRules["config/private/public.json"]).toBe("allow")
-    })
-
-    test("returns empty warnings array", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolignore"), "secrets/")
-        },
-      })
-
-      const result = await IgnoreMigrator.migrate({
-        projectDir: tmp.path,
-        skipGlobalPaths: true,
-      })
-
-      expect(result.warnings).toHaveLength(0)
-    })
-  })
-
-  describe("loadIgnoreConfig", () => {
-    test("returns empty object for project without .saeeolignore", async () => {
-      await using tmp = await tmpdir()
-
-      const permission = await IgnoreMigrator.loadIgnoreConfig(tmp.path, true)
-
-      expect(Object.keys(permission)).toHaveLength(0)
-    })
-
-    test("returns permission config for project with .saeeolignore", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolignore"), "secrets/")
-        },
-      })
-
-      const permission = await IgnoreMigrator.loadIgnoreConfig(tmp.path, true)
-
-      expect(permission.read).toBeDefined()
-      expect(permission.edit).toBeDefined()
-    })
-
-    test("handles errors gracefully", async () => {
-      // Pass a non-existent directory
-      const permission = await IgnoreMigrator.loadIgnoreConfig("/non/existent/path", true)
-
-      expect(Object.keys(permission)).toHaveLength(0)
-    })
-  })
-})