saeeol 1.2.5 → 1.2.8

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

@@ -1,257 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { RulesMigrator } from "../../src/overlay/rules-migrator"
-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
-  const prevTest = process.env.SAEEOL_TEST_HOME
-  process.env.HOME = home
-  process.env.SAEEOL_TEST_HOME = home
-  try {
-    return await fn()
-  } finally {
-    if (prev) process.env.HOME = prev
-    else delete process.env.HOME
-    if (prevTest) process.env.SAEEOL_TEST_HOME = prevTest
-    else delete process.env.SAEEOL_TEST_HOME
-  }
-}
-
-describe("RulesMigrator", () => {
-  describe("discoverRules", () => {
-    test("discovers legacy .saeeolrules file", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolrules"), "# Project rules")
-        },
-      })
-
-      const rules = await RulesMigrator.discoverRules(tmp.path)
-
-      expect(rules).toHaveLength(1)
-      expect(rules[0].source).toBe("legacy")
-      expect(rules[0].path).toContain(".saeeolrules")
-      expect(rules[0].mode).toBeUndefined()
-    })
-
-    test("discovers .saeeol/rules/ directory", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await fs.mkdir(path.join(dir, ".saeeol", "rules"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "rules", "coding.md"), "# Coding rules")
-          await Bun.write(path.join(dir, ".saeeol", "rules", "testing.md"), "# Testing rules")
-        },
-      })
-
-      const rules = await RulesMigrator.discoverRules(tmp.path)
-
-      expect(rules).toHaveLength(2)
-      expect(rules.every((r) => r.source === "project")).toBe(true)
-      expect(rules.every((r) => r.mode === undefined)).toBe(true)
-    })
-
-    test("discovers rules from legacy .saeeol/rules/", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await fs.mkdir(path.join(dir, ".saeeol", "rules"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "rules", "legacy.md"), "# Legacy rules")
-        },
-      })
-
-      const rules = await RulesMigrator.discoverRules(tmp.path)
-
-      expect(rules.some((r) => r.path.includes("legacy.md"))).toBe(true)
-    })
-
-    test(".saeeol/rules/ takes precedence over .saeeol/rules/ for same filename", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await fs.mkdir(path.join(dir, ".saeeol", "rules"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "rules", "main.md"), "# New rules")
-          await fs.mkdir(path.join(dir, ".saeeol", "rules"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "rules", "main.md"), "# Old rules")
-        },
-      })
-
-      const rules = await RulesMigrator.discoverRules(tmp.path)
-      const mainRules = rules.filter((r) => r.path.includes("main.md"))
-
-      // Only one main.md should be found (.saeeol wins)
-      expect(mainRules).toHaveLength(1)
-      expect(mainRules[0].path).toContain(`.saeeol${path.sep}`)
-    })
-
-    test("discovers mode-specific directory rules", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await fs.mkdir(path.join(dir, ".saeeol", "rules-code"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "rules-code", "style.md"), "# Code style")
-        },
-      })
-
-      const rules = await RulesMigrator.discoverRules(tmp.path)
-
-      expect(rules).toHaveLength(1)
-      expect(rules[0].source).toBe("project")
-      expect(rules[0].mode).toBe("code")
-    })
-
-    test("discovers mode-specific legacy file", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolrules-architect"), "# Architect rules")
-        },
-      })
-
-      const rules = await RulesMigrator.discoverRules(tmp.path)
-
-      expect(rules).toHaveLength(1)
-      expect(rules[0].source).toBe("legacy")
-      expect(rules[0].mode).toBe("architect")
-    })
-
-    test("ignores non-markdown files in rules directory", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await fs.mkdir(path.join(dir, ".saeeol", "rules"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "rules", "rules.md"), "# Rules")
-          await Bun.write(path.join(dir, ".saeeol", "rules", "notes.txt"), "Notes")
-          await Bun.write(path.join(dir, ".saeeol", "rules", "config.json"), "{}")
-        },
-      })
-
-      const rules = await RulesMigrator.discoverRules(tmp.path)
-
-      expect(rules).toHaveLength(1)
-      expect(rules[0].path).toContain("rules.md")
-    })
-
-    test("returns empty array for project without rules", async () => {
-      await using tmp = await tmpdir()
-
-      const rules = await RulesMigrator.discoverRules(tmp.path)
-
-      expect(rules).toHaveLength(0)
-    })
-
-    test("discovers multiple rule sources together", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          // Legacy file
-          await Bun.write(path.join(dir, ".saeeolrules"), "# Legacy rules")
-          // Directory rules
-          await fs.mkdir(path.join(dir, ".saeeol", "rules"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "rules", "main.md"), "# Main rules")
-          // Mode-specific
-          await Bun.write(path.join(dir, ".saeeolrules-code"), "# Code rules")
-        },
-      })
-
-      const rules = await RulesMigrator.discoverRules(tmp.path)
-
-      expect(rules).toHaveLength(3)
-      expect(rules.some((r) => r.source === "legacy" && !r.mode)).toBe(true)
-      expect(rules.some((r) => r.source === "project")).toBe(true)
-      expect(rules.some((r) => r.mode === "code")).toBe(true)
-    })
-
-    test("discovers global rules from ~/.saeeol/rules/", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await fs.mkdir(path.join(dir, ".saeeol", "rules"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "rules", "global.md"), "# Global rules")
-          await fs.mkdir(path.join(dir, "repo"), { recursive: true })
-        },
-      })
-
-      const rules = await withHome(tmp.path, () => RulesMigrator.discoverRules(path.join(tmp.path, "repo")))
-
-      expect(
-        rules.some((r) => r.source === "global" && r.path.includes(path.join(".saeeol", "rules", "global.md"))),
-      ).toBe(true)
-    })
-  })
-
-  describe("migrate", () => {
-    test("returns instructions array with discovered rules", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await fs.mkdir(path.join(dir, ".saeeol", "rules"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "rules", "main.md"), "# Main rules")
-        },
-      })
-
-      const result = await RulesMigrator.migrate({ projectDir: tmp.path })
-
-      expect(result.instructions).toHaveLength(1)
-      expect(result.instructions[0]).toContain("main.md")
-    })
-
-    test("warns about legacy files", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolrules"), "# Legacy rules")
-        },
-      })
-
-      const result = await RulesMigrator.migrate({ projectDir: tmp.path })
-
-      expect(result.warnings.some((w) => w.includes("Legacy"))).toBe(true)
-      expect(result.warnings.some((w) => w.includes(".saeeol/rules/"))).toBe(true)
-    })
-
-    test("skips mode-specific rules when includeModeSpecific is false", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolrules-code"), "# Code rules")
-        },
-      })
-
-      const result = await RulesMigrator.migrate({
-        projectDir: tmp.path,
-        includeModeSpecific: false,
-      })
-
-      expect(result.instructions).toHaveLength(0)
-      expect(result.warnings.some((w) => w.includes("skipped"))).toBe(true)
-    })
-
-    test("includes mode-specific rules by default", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolrules-code"), "# Code rules")
-        },
-      })
-
-      const result = await RulesMigrator.migrate({ projectDir: tmp.path })
-
-      expect(result.instructions).toHaveLength(1)
-    })
-
-    test("returns empty result for project without rules", async () => {
-      await using tmp = await tmpdir()
-
-      const result = await RulesMigrator.migrate({ projectDir: tmp.path })
-
-      expect(result.instructions).toHaveLength(0)
-      expect(result.warnings).toHaveLength(0)
-    })
-
-    test("combines all rule sources", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, ".saeeolrules"), "# Legacy")
-          await fs.mkdir(path.join(dir, ".saeeol", "rules"), { recursive: true })
-          await Bun.write(path.join(dir, ".saeeol", "rules", "main.md"), "# Main")
-          await Bun.write(path.join(dir, ".saeeolrules-architect"), "# Architect")
-        },
-      })
-
-      const result = await RulesMigrator.migrate({ projectDir: tmp.path })
-
-      expect(result.instructions).toHaveLength(3)
-    })
-  })
-})

package/test/saeeol/run-auto.test.ts

@@ -1,176 +0,0 @@
-import { afterEach, describe, expect, mock, test } from "bun:test"
-
-type Event = {
-  type: string
-  properties: Record<string, unknown>
-}
-
-function feed<T>() {
-  const list: T[] = []
-  const wait: Array<() => void> = []
-  const state = { done: false }
-
-  return {
-    push(item: T) {
-      list.push(item)
-      while (wait.length) wait.shift()?.()
-    },
-    end() {
-      state.done = true
-      while (wait.length) wait.shift()?.()
-    },
-    async *stream() {
-      while (!state.done || list.length) {
-        if (list.length) {
-          yield list.shift() as T
-          continue
-        }
-        await new Promise<void>((resolve) => wait.push(resolve))
-      }
-    },
-  }
-}
-
-function task(child: string): Event {
-  return {
-    type: "message.part.updated",
-    properties: {
-      part: {
-        id: "prt_task",
-        type: "tool",
-        tool: "task",
-        sessionID: "ses_root",
-        state: {
-          status: "running",
-          input: {
-            description: "inspect bug",
-            prompt: "check child permissions",
-            subagent_type: "general",
-          },
-          metadata: {
-            sessionId: child,
-          },
-          time: { start: 0 },
-        },
-      },
-    },
-  }
-}
-
-function permission(id: string, sessionID: string): Event {
-  return {
-    type: "permission.asked",
-    properties: {
-      id,
-      sessionID,
-      permission: "bash",
-      patterns: ["npm test"],
-      metadata: { command: "npm test" },
-      always: ["npm *"],
-    },
-  }
-}
-
-function idle(): Event {
-  return {
-    type: "session.status",
-    properties: {
-      sessionID: "ses_root",
-      status: { type: "idle" },
-    },
-  }
-}
-
-function args() {
-  return {
-    _: [],
-    $0: "saeeol",
-    message: ["hi"],
-    command: undefined,
-    continue: false,
-    session: "ses_root",
-    fork: false,
-    "cloud-fork": false,
-    cloudFork: false,
-    share: false,
-    model: undefined,
-    agent: undefined,
-    format: "json",
-    file: undefined,
-    title: undefined,
-    attach: "http://127.0.0.1:4096",
-    password: undefined,
-    dir: undefined,
-    port: undefined,
-    variant: undefined,
-    thinking: false,
-    auto: true,
-    "dangerously-skip-permissions": false,
-    dangerouslySkipPermissions: false,
-    "--": [],
-  }
-}
-
-const tty = Object.getOwnPropertyDescriptor(process.stdin, "isTTY")
-
-afterEach(() => {
-  if (tty) {
-    Object.defineProperty(process.stdin, "isTTY", tty)
-    return
-  }
-  delete (process.stdin as { isTTY?: boolean }).isTTY
-})
-
-async function run(sdk: Record<string, unknown>) {
-  mock.module("@saeeol/sdk/v2", () => ({
-    createSaeeolClient: () => sdk,
-  }))
-
-  Object.defineProperty(process.stdin, "isTTY", {
-    configurable: true,
-    value: true,
-  })
-
-  const key = JSON.stringify({ time: Date.now(), rand: Math.random() })
-  const { RunCommand } = await import(`../../src/cli/cmd/run?${key}`)
-  return RunCommand.handler(args() as never)
-}
-
-describe("cli run auto permissions", () => {
-  test("auto approves tracked subagent permissions and ignores unrelated sessions", async () => {
-    const q = feed<Event>()
-    const calls: Array<{ requestID: string; reply: string }> = []
-    const done = Promise.withResolvers<void>()
-
-    const sdk = {
-      config: {
-        get: async () => ({ data: { share: "manual" } }),
-      },
-      event: {
-        subscribe: async () => ({ stream: q.stream() }),
-      },
-      permission: {
-        reply: async (input: { requestID: string; reply: string }) => {
-          calls.push(input)
-          if (input.requestID === "perm_child") done.resolve()
-          return { data: true }
-        },
-      },
-      session: {
-        prompt: async () => {
-          q.push(task("ses_child"))
-          q.push(permission("perm_other", "ses_other"))
-          q.push(permission("perm_child", "ses_child"))
-          q.push(idle())
-          await Promise.race([done.promise, new Promise((resolve) => setTimeout(resolve, 25))])
-          q.end()
-          return { data: undefined }
-        },
-      },
-    }
-
-    await run(sdk)
-
-    expect(calls).toEqual([{ requestID: "perm_child", reply: "once" }])
-  })
-})

package/test/saeeol/run-network.test.ts

@@ -1,224 +0,0 @@
-import { afterEach, describe, expect, mock, test } from "bun:test"
-
-type Event = {
-  type: string
-  properties: Record<string, unknown>
-}
-
-function feed<T>() {
-  const list: T[] = []
-  const wait: Array<() => void> = []
-  const state = { done: false }
-
-  return {
-    push(item: T) {
-      list.push(item)
-      while (wait.length) wait.shift()?.()
-    },
-    end() {
-      state.done = true
-      while (wait.length) wait.shift()?.()
-    },
-    async *stream() {
-      while (!state.done || list.length) {
-        if (list.length) {
-          yield list.shift() as T
-          continue
-        }
-        await new Promise<void>((resolve) => wait.push(resolve))
-      }
-    },
-  }
-}
-
-function asked(id: number): Event {
-  return {
-    type: "session.network.asked",
-    properties: {
-      sessionID: "ses_test",
-      id: `req_${id}`,
-      message: "Connection refused",
-      restored: false,
-      time: { created: 0 },
-    },
-  }
-}
-
-function busy(): Event {
-  return {
-    type: "session.status",
-    properties: {
-      sessionID: "ses_test",
-      status: { type: "busy" },
-    },
-  }
-}
-
-function idle(): Event {
-  return {
-    type: "session.status",
-    properties: {
-      sessionID: "ses_test",
-      status: { type: "idle" },
-    },
-  }
-}
-
-function args() {
-  return {
-    _: [],
-    $0: "saeeol",
-    message: ["hi"],
-    command: undefined,
-    continue: false,
-    session: "ses_test",
-    fork: false,
-    "cloud-fork": false,
-    cloudFork: false,
-    share: false,
-    model: undefined,
-    agent: undefined,
-    format: "default",
-    file: undefined,
-    title: undefined,
-    attach: "http://127.0.0.1:4096",
-    password: undefined,
-    dir: undefined,
-    port: undefined,
-    variant: undefined,
-    thinking: false,
-    auto: false,
-    "--": [],
-  }
-}
-
-const timer = globalThis.setTimeout
-const tty = Object.getOwnPropertyDescriptor(process.stdin, "isTTY")
-
-afterEach(() => {
-  globalThis.setTimeout = timer
-  if (tty) {
-    Object.defineProperty(process.stdin, "isTTY", tty)
-    return
-  }
-  delete (process.stdin as { isTTY?: boolean }).isTTY
-})
-
-function instant() {
-  globalThis.setTimeout = ((cb: TimerHandler) => {
-    if (typeof cb === "function") {
-      queueMicrotask(() => cb())
-    }
-    return 0 as unknown as ReturnType<typeof setTimeout>
-  }) as unknown as typeof setTimeout
-}
-
-async function run(sdk: Record<string, unknown>) {
-  mock.module("@saeeol/sdk/v2", () => ({
-    createSaeeolClient: () => sdk,
-  }))
-
-  Object.defineProperty(process.stdin, "isTTY", {
-    configurable: true,
-    value: true,
-  })
-
-  const key = JSON.stringify({ time: Date.now(), rand: Math.random() })
-  const { RunCommand } = await import(`../../src/cli/cmd/run?${key}`)
-  return RunCommand.handler(args() as never)
-}
-
-describe("cli run network retries", () => {
-  test("rejects after repeated offline resumes without busy", async () => {
-    instant()
-    const q = feed<Event>()
-    const calls: string[] = []
-    const gate = Promise.withResolvers<void>()
-    const state = { reject: undefined as string | undefined }
-
-    const sdk = {
-      config: {
-        get: async () => ({ data: { share: "manual" } }),
-      },
-      event: {
-        subscribe: async () => ({ stream: q.stream() }),
-      },
-      network: {
-        reply: async (input: { requestID: string }) => {
-          calls.push(input.requestID)
-          q.push(asked(calls.length + 1))
-        },
-        reject: async (input: { requestID: string }) => {
-          state.reject = input.requestID
-          q.push(idle())
-          q.end()
-          gate.resolve()
-        },
-      },
-      session: {
-        prompt: async () => {
-          q.push(asked(1))
-          await gate.promise
-          return { data: undefined }
-        },
-      },
-    }
-
-    await run(sdk)
-
-    expect(calls).toStrictEqual(["req_1", "req_2", "req_3"])
-    expect(state.reject).toBe("req_4")
-  })
-
-  test("resets retry budget only after the session is busy again", async () => {
-    instant()
-    const q = feed<Event>()
-    const calls: string[] = []
-    const gate = Promise.withResolvers<void>()
-    const state = { reject: undefined as string | undefined }
-
-    const sdk = {
-      config: {
-        get: async () => ({ data: { share: "manual" } }),
-      },
-      event: {
-        subscribe: async () => ({ stream: q.stream() }),
-      },
-      network: {
-        reply: async (input: { requestID: string }) => {
-          calls.push(input.requestID)
-          if (calls.length === 1) {
-            q.push(busy())
-            q.push(asked(2))
-            return
-          }
-          if (calls.length < 4) {
-            q.push(asked(calls.length + 1))
-            return
-          }
-          q.push(idle())
-          q.end()
-          gate.resolve()
-        },
-        reject: async (input: { requestID: string }) => {
-          state.reject = input.requestID
-          q.push(idle())
-          q.end()
-          gate.resolve()
-        },
-      },
-      session: {
-        prompt: async () => {
-          q.push(asked(1))
-          await gate.promise
-          return { data: undefined }
-        },
-      },
-    }
-
-    await run(sdk)
-
-    expect(calls).toStrictEqual(["req_1", "req_2", "req_3", "req_4"])
-    expect(state.reject).toBeUndefined()
-  })
-})