saeeol 1.2.9 → 1.3.1

package/test/question/question.test.ts

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

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

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

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

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