saeeol 1.3.0 → 1.4.0

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

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

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

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