saeeol 1.2.4 → 1.2.7

package/test/question/question.test.ts

@@ -1,490 +0,0 @@
-import { afterEach, test, expect } from "bun:test"
-import { Question } from "../../src/question"
-import { Instance } from "../../src/project/instance"
-import { InstanceStore } from "../../src/project/instance-store"
-import { QuestionID } from "../../src/question/schema"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import { SessionID } from "../../src/session/schema"
-import { AppRuntime } from "../../src/effect/app-runtime"
-
-const ask = (input: { sessionID: SessionID; questions: ReadonlyArray<Question.Info>; tool?: Question.Tool }) =>
-  AppRuntime.runPromise(Question.Service.use((svc) => svc.ask(input)))
-
-const list = () => AppRuntime.runPromise(Question.Service.use((svc) => svc.list()))
-
-const reply = (input: { requestID: QuestionID; answers: ReadonlyArray<Question.Answer> }) =>
-  AppRuntime.runPromise(Question.Service.use((svc) => svc.reply(input)))
-
-const reject = (id: QuestionID) => AppRuntime.runPromise(Question.Service.use((svc) => svc.reject(id)))
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-/** Reject all pending questions so dangling Deferred fibers don't hang the test. */
-async function rejectAll() {
-  const pending = await list()
-  for (const req of pending) {
-    await reject(req.id)
-  }
-}
-
-test("ask - returns pending promise", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const promise = ask({
-        sessionID: SessionID.make("ses_test"),
-        questions: [
-          {
-            question: "What would you like to do?",
-            header: "Action",
-            options: [
-              { label: "Option 1", description: "First option" },
-              { label: "Option 2", description: "Second option" },
-            ],
-          },
-        ],
-      })
-      expect(promise).toBeInstanceOf(Promise)
-      await rejectAll()
-      await promise.catch(() => {})
-    },
-  })
-})
-
-test("ask - adds to pending list", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const questions = [
-        {
-          question: "What would you like to do?",
-          header: "Action",
-          options: [
-            { label: "Option 1", description: "First option" },
-            { label: "Option 2", description: "Second option" },
-          ],
-        },
-      ]
-
-      const promise = ask({
-        sessionID: SessionID.make("ses_test"),
-        questions,
-      })
-
-      const pending = await list()
-      expect(pending.length).toBe(1)
-      expect(pending[0].questions).toEqual(questions)
-      await rejectAll()
-      await promise.catch(() => {})
-    },
-  })
-})
-test("ask - preserves blocking flag", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const askPromise = Question.ask({
-        sessionID: SessionID.make("ses_test"),
-        blocking: false,
-        questions: [
-          {
-            question: "Proceed with review suggestion?",
-            header: "Code review",
-            options: [{ label: "Start", description: "Run review" }],
-          },
-        ],
-      })
-
-      const pending = await Question.list()
-      expect(pending[0]?.blocking).toBe(false)
-
-      await Question.reject(pending[0].id)
-      await expect(askPromise).rejects.toBeInstanceOf(Question.RejectedError)
-    },
-  })
-})
-
-// reply tests
-
-test("reply - resolves the pending ask with answers", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const questions = [
-        {
-          question: "What would you like to do?",
-          header: "Action",
-          options: [
-            { label: "Option 1", description: "First option" },
-            { label: "Option 2", description: "Second option" },
-          ],
-        },
-      ]
-
-      const promise = ask({
-        sessionID: SessionID.make("ses_test"),
-        questions,
-      })
-
-      const pending = await list()
-      const requestID = pending[0].id
-
-      await reply({
-        requestID,
-        answers: [["Option 1"]],
-      })
-
-      const answers = await promise
-      expect(answers).toEqual([["Option 1"]])
-    },
-  })
-})
-
-test("reply - removes from pending list", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const promise = ask({
-        sessionID: SessionID.make("ses_test"),
-        questions: [
-          {
-            question: "What would you like to do?",
-            header: "Action",
-            options: [
-              { label: "Option 1", description: "First option" },
-              { label: "Option 2", description: "Second option" },
-            ],
-          },
-        ],
-      })
-
-      const pending = await list()
-      expect(pending.length).toBe(1)
-
-      await reply({
-        requestID: pending[0].id,
-        answers: [["Option 1"]],
-      })
-      await promise
-
-      const after = await list()
-      expect(after.length).toBe(0)
-    },
-  })
-})
-
-test("reply - does nothing for unknown requestID", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      await reply({
-        requestID: QuestionID.make("que_unknown"),
-        answers: [["Option 1"]],
-      })
-      // Should not throw
-    },
-  })
-})
-
-// reject tests
-
-test("reject - throws RejectedError", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const promise = ask({
-        sessionID: SessionID.make("ses_test"),
-        questions: [
-          {
-            question: "What would you like to do?",
-            header: "Action",
-            options: [
-              { label: "Option 1", description: "First option" },
-              { label: "Option 2", description: "Second option" },
-            ],
-          },
-        ],
-      })
-
-      const pending = await list()
-      await reject(pending[0].id)
-
-      await expect(promise).rejects.toBeInstanceOf(Question.RejectedError)
-    },
-  })
-})
-
-test("reject - removes from pending list", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const promise = ask({
-        sessionID: SessionID.make("ses_test"),
-        questions: [
-          {
-            question: "What would you like to do?",
-            header: "Action",
-            options: [
-              { label: "Option 1", description: "First option" },
-              { label: "Option 2", description: "Second option" },
-            ],
-          },
-        ],
-      })
-
-      const pending = await list()
-      expect(pending.length).toBe(1)
-
-      await reject(pending[0].id)
-      promise.catch(() => {}) // Ignore rejection
-
-      const after = await list()
-      expect(after.length).toBe(0)
-    },
-  })
-})
-
-test("reject - does nothing for unknown requestID", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      await reject(QuestionID.make("que_unknown"))
-      // Should not throw
-    },
-  })
-})
-
-// multiple questions tests
-
-test("ask - handles multiple questions", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const questions = [
-        {
-          question: "What would you like to do?",
-          header: "Action",
-          options: [
-            { label: "Build", description: "Build the project" },
-            { label: "Test", description: "Run tests" },
-          ],
-        },
-        {
-          question: "Which environment?",
-          header: "Env",
-          options: [
-            { label: "Dev", description: "Development" },
-            { label: "Prod", description: "Production" },
-          ],
-        },
-      ]
-
-      const promise = ask({
-        sessionID: SessionID.make("ses_test"),
-        questions,
-      })
-
-      const pending = await list()
-
-      await reply({
-        requestID: pending[0].id,
-        answers: [["Build"], ["Dev"]],
-      })
-
-      const answers = await promise
-      expect(answers).toEqual([["Build"], ["Dev"]])
-    },
-  })
-})
-
-// list tests
-
-test("list - returns all pending requests", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const p1 = ask({
-        sessionID: SessionID.make("ses_test1"),
-        questions: [
-          {
-            question: "Question 1?",
-            header: "Q1",
-            options: [{ label: "A", description: "A" }],
-          },
-        ],
-      })
-
-      const p2 = ask({
-        sessionID: SessionID.make("ses_test2"),
-        questions: [
-          {
-            question: "Question 2?",
-            header: "Q2",
-            options: [{ label: "B", description: "B" }],
-          },
-        ],
-      })
-
-      const pending = await list()
-      expect(pending.length).toBe(2)
-      await rejectAll()
-      p1.catch(() => {})
-      p2.catch(() => {})
-    },
-  })
-})
-
-test("list - returns empty when no pending", async () => {
-  await using tmp = await tmpdir({ git: true })
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const pending = await list()
-      expect(pending.length).toBe(0)
-    },
-  })
-})
-
-test("questions stay isolated by directory", async () => {
-  await using one = await tmpdir({ git: true })
-  await using two = await tmpdir({ git: true })
-
-  const p1 = Instance.provide({
-    directory: one.path,
-    fn: () =>
-      ask({
-        sessionID: SessionID.make("ses_one"),
-        questions: [
-          {
-            question: "Question 1?",
-            header: "Q1",
-            options: [{ label: "A", description: "A" }],
-          },
-        ],
-      }),
-  })
-
-  const p2 = Instance.provide({
-    directory: two.path,
-    fn: () =>
-      ask({
-        sessionID: SessionID.make("ses_two"),
-        questions: [
-          {
-            question: "Question 2?",
-            header: "Q2",
-            options: [{ label: "B", description: "B" }],
-          },
-        ],
-      }),
-  })
-
-  const onePending = await Instance.provide({
-    directory: one.path,
-    fn: () => list(),
-  })
-  const twoPending = await Instance.provide({
-    directory: two.path,
-    fn: () => list(),
-  })
-
-  expect(onePending.length).toBe(1)
-  expect(twoPending.length).toBe(1)
-  expect(onePending[0].sessionID).toBe(SessionID.make("ses_one"))
-  expect(twoPending[0].sessionID).toBe(SessionID.make("ses_two"))
-
-  await Instance.provide({
-    directory: one.path,
-    fn: () => reject(onePending[0].id),
-  })
-  await Instance.provide({
-    directory: two.path,
-    fn: () => reject(twoPending[0].id),
-  })
-
-  await p1.catch(() => {})
-  await p2.catch(() => {})
-})
-
-test("pending question rejects on instance dispose", async () => {
-  await using tmp = await tmpdir({ git: true })
-
-  const pending = Instance.provide({
-    directory: tmp.path,
-    fn: () => {
-      return ask({
-        sessionID: SessionID.make("ses_dispose"),
-        questions: [
-          {
-            question: "Dispose me?",
-            header: "Dispose",
-            options: [{ label: "Yes", description: "Yes" }],
-          },
-        ],
-      })
-    },
-  })
-  const result = pending.then(
-    () => "resolved" as const,
-    (err) => err,
-  )
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const items = await list()
-      expect(items).toHaveLength(1)
-      await InstanceStore.disposeInstance(Instance.current)
-    },
-  })
-
-  expect(await result).toBeInstanceOf(Question.RejectedError)
-})
-
-test("pending question rejects on instance reload", async () => {
-  await using tmp = await tmpdir({ git: true })
-
-  const pending = Instance.provide({
-    directory: tmp.path,
-    fn: () => {
-      return ask({
-        sessionID: SessionID.make("ses_reload"),
-        questions: [
-          {
-            question: "Reload me?",
-            header: "Reload",
-            options: [{ label: "Yes", description: "Yes" }],
-          },
-        ],
-      })
-    },
-  })
-  const result = pending.then(
-    () => "resolved" as const,
-    (err) => err,
-  )
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const items = await list()
-      expect(items).toHaveLength(1)
-      await InstanceStore.reloadInstance({ directory: tmp.path })
-    },
-  })
-
-  expect(await result).toBeInstanceOf(Question.RejectedError)
-})

package/test/saeeol/agent-global-config-dirs.test.ts

@@ -1,24 +0,0 @@
-import { afterEach, test, expect } from "bun:test"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import { Instance } from "../../src/project/instance"
-import { Agent } from "../../src/agent/agent"
-import { Permission } from "../../src/permission"
-import { Global } from "@saeeol/core/global"
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-test("code agent allows global config directory reads by default", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const code = await Agent.get("code")
-      expect(code).toBeDefined()
-      expect(Permission.evaluate("external_directory", `${Global.Path.config}/*`, code!.permission).action).toBe(
-        "allow",
-      )
-    },
-  })
-})

package/test/saeeol/agent-manager-tool.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect, Layer, ManagedRuntime } from "effect"
-import { MessageID, SessionID } from "../../src/session/schema"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
-import { AgentManagerTool } from "../../src/overlay/tool/agent-manager"
-import { Bus } from "../../src/bus"
-import { Tool } from "../../src/tool/tool"
-import { Truncate } from "../../src/tool/truncate"
-import { Agent } from "../../src/agent/agent"
-
-const runtime = ManagedRuntime.make(
-  Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer, Bus.defaultLayer, CrossSpawnSpawner.defaultLayer),
-)
-
-async function init() {
-  return runtime.runPromise(
-    Effect.gen(function* () {
-      const info = yield* AgentManagerTool
-      return yield* Tool.init(info)
-    }),
-  )
-}
-
-const ctx = {
-  sessionID: SessionID.make("ses_test"),
-  messageID: MessageID.make("msg_test"),
-  callID: "call_agent_manager",
-  agent: "build",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-}
-
-describe("agent_manager tool", () => {
-  test("asks for agent_manager permission", async () => {
-    const tool = await init()
-    const calls: unknown[] = []
-
-    await runtime.runPromise(
-      provideTmpdirInstance(() =>
-        tool.execute(
-          { mode: "local", tasks: [{ prompt: "Fix issue" }] },
-          { ...ctx, ask: (input: unknown) => Effect.sync(() => calls.push(input)) },
-        ),
-      ).pipe(Effect.scoped),
-    )
-
-    expect(calls).toEqual([
-      {
-        permission: "agent_manager",
-        patterns: ["local"],
-        always: ["local"],
-        metadata: { mode: "local", count: 1 },
-      },
-    ])
-  })
-
-  test("rejects empty tasks", async () => {
-    const tool = await init()
-
-    await expect(
-      runtime.runPromise(
-        provideTmpdirInstance(() =>
-          tool.execute({ mode: "local", tasks: [{}] }, { ...ctx, ask: () => Effect.void }),
-        ).pipe(Effect.scoped),
-      ),
-    ).rejects.toThrow("Each task must include prompt, name, or branchName")
-  })
-})

package/test/saeeol/agent-permission-overrides.test.ts

@@ -1,75 +0,0 @@
-import { afterEach, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { Agent } from "../../src/agent/agent"
-import { Permission } from "../../src/permission"
-import { Instance } from "../../src/project/instance"
-import { disposeAllInstances, provideInstance, tmpdir } from "../fixture/fixture"
-
-function load<A>(dir: string, fn: (svc: Agent.Interface) => Effect.Effect<A>) {
-  return Effect.runPromise(provideInstance(dir)(Agent.Service.use(fn)).pipe(Effect.provide(Agent.defaultLayer)))
-}
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-test("ask agent honors user MCP allow over generated ask rule", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      mcp: {
-        context7: { type: "local", command: ["context7"] },
-      },
-      permission: {
-        "context7_query-docs": { "*": "allow" },
-      },
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const ask = await load(tmp.path, (svc) => svc.get("ask"))
-      expect(ask).toBeDefined()
-      expect(Permission.evaluate("context7_query-docs", "*", ask!.permission).action).toBe("allow")
-    },
-  })
-})
-
-test("plan agent honors user bash allow over read-only deny default", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      permission: {
-        bash: { "cargo search *": "allow" },
-      },
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const plan = await load(tmp.path, (svc) => svc.get("plan"))
-      expect(plan).toBeDefined()
-      expect(Permission.evaluate("bash", "cargo search serde", plan!.permission).action).toBe("allow")
-    },
-  })
-})
-
-test("plan agent still hard-denies non-plan edits after user edit allow", async () => {
-  await using tmp = await tmpdir({
-    config: {
-      permission: {
-        edit: { "src/output.log": "allow" },
-      },
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const plan = await load(tmp.path, (svc) => svc.get("plan"))
-      expect(plan).toBeDefined()
-      expect(Permission.evaluate("edit", "src/output.log", plan!.permission).action).toBe("deny")
-      expect(Permission.evaluate("edit", ".saeeol/plans/fix.md", plan!.permission).action).toBe("allow")
-    },
-  })
-})

package/test/saeeol/agent-skill-permissions.test.ts

@@ -1,37 +0,0 @@
-import { afterEach, test, expect } from "bun:test"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import { Instance } from "../../src/project/instance"
-import { Agent } from "../../src/agent/agent"
-import { Permission } from "../../src/permission"
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-function action(name: string, ruleset: Permission.Ruleset) {
-  return Permission.evaluate("skill", name, ruleset).action
-}
-
-test("skill tool available for non-system native agents and denied for system agents", async () => {
-  await using tmp = await tmpdir()
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      const allow = ["code", "plan", "debug", "orchestrator", "ask", "general", "explore"]
-      for (const name of allow) {
-        const agent = await Agent.get(name)
-        expect(agent).toBeDefined()
-        expect(action("using-superpowers", agent!.permission)).toBe("allow")
-        expect(Permission.disabled(["skill"], agent!.permission).has("skill")).toBe(false)
-      }
-
-      const deny = ["compaction", "title", "summary"]
-      for (const name of deny) {
-        const agent = await Agent.get(name)
-        expect(agent).toBeDefined()
-        expect(action("using-superpowers", agent!.permission)).toBe("deny")
-        expect(Permission.disabled(["skill"], agent!.permission).has("skill")).toBe(true)
-      }
-    },
-  })
-})