@happy-creative/iroder 1.0.0

package/test/question/question.test.ts

@@ -0,0 +1,453 @@
+import { afterEach, test, expect } from "bun:test"
+import { Question } from "../../src/question"
+import { Instance } from "../../src/project/instance"
+import { QuestionID } from "../../src/question/schema"
+import { tmpdir } from "../fixture/fixture"
+import { SessionID } from "../../src/session/schema"
+
+afterEach(async () => {
+  await Instance.disposeAll()
+})
+
+/** Reject all pending questions so dangling Deferred fibers don't hang the test. */
+async function rejectAll() {
+  const pending = await Question.list()
+  for (const req of pending) {
+    await Question.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 = Question.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 askPromise = Question.ask({
+        sessionID: SessionID.make("ses_test"),
+        questions,
+      })
+
+      const pending = await Question.list()
+      expect(pending.length).toBe(1)
+      expect(pending[0].questions).toEqual(questions)
+      await rejectAll()
+      await askPromise.catch(() => {})
+    },
+  })
+})
+
+// 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 askPromise = Question.ask({
+        sessionID: SessionID.make("ses_test"),
+        questions,
+      })
+
+      const pending = await Question.list()
+      const requestID = pending[0].id
+
+      await Question.reply({
+        requestID,
+        answers: [["Option 1"]],
+      })
+
+      const answers = await askPromise
+      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 askPromise = Question.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 Question.list()
+      expect(pending.length).toBe(1)
+
+      await Question.reply({
+        requestID: pending[0].id,
+        answers: [["Option 1"]],
+      })
+      await askPromise
+
+      const pendingAfter = await Question.list()
+      expect(pendingAfter.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 Question.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 askPromise = Question.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 Question.list()
+      await Question.reject(pending[0].id)
+
+      await expect(askPromise).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 askPromise = Question.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 Question.list()
+      expect(pending.length).toBe(1)
+
+      await Question.reject(pending[0].id)
+      askPromise.catch(() => {}) // Ignore rejection
+
+      const pendingAfter = await Question.list()
+      expect(pendingAfter.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 Question.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 askPromise = Question.ask({
+        sessionID: SessionID.make("ses_test"),
+        questions,
+      })
+
+      const pending = await Question.list()
+
+      await Question.reply({
+        requestID: pending[0].id,
+        answers: [["Build"], ["Dev"]],
+      })
+
+      const answers = await askPromise
+      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 = Question.ask({
+        sessionID: SessionID.make("ses_test1"),
+        questions: [
+          {
+            question: "Question 1?",
+            header: "Q1",
+            options: [{ label: "A", description: "A" }],
+          },
+        ],
+      })
+
+      const p2 = Question.ask({
+        sessionID: SessionID.make("ses_test2"),
+        questions: [
+          {
+            question: "Question 2?",
+            header: "Q2",
+            options: [{ label: "B", description: "B" }],
+          },
+        ],
+      })
+
+      const pending = await Question.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 Question.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: () =>
+      Question.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: () =>
+      Question.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: () => Question.list(),
+  })
+  const twoPending = await Instance.provide({
+    directory: two.path,
+    fn: () => Question.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: () => Question.reject(onePending[0].id),
+  })
+  await Instance.provide({
+    directory: two.path,
+    fn: () => Question.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 ask = Instance.provide({
+    directory: tmp.path,
+    fn: () => {
+      return Question.ask({
+        sessionID: SessionID.make("ses_dispose"),
+        questions: [
+          {
+            question: "Dispose me?",
+            header: "Dispose",
+            options: [{ label: "Yes", description: "Yes" }],
+          },
+        ],
+      })
+    },
+  })
+  const result = ask.then(
+    () => "resolved" as const,
+    (err) => err,
+  )
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const pending = await Question.list()
+      expect(pending).toHaveLength(1)
+      await Instance.dispose()
+    },
+  })
+
+  expect(await result).toBeInstanceOf(Question.RejectedError)
+})
+
+test("pending question rejects on instance reload", async () => {
+  await using tmp = await tmpdir({ git: true })
+
+  const ask = Instance.provide({
+    directory: tmp.path,
+    fn: () => {
+      return Question.ask({
+        sessionID: SessionID.make("ses_reload"),
+        questions: [
+          {
+            question: "Reload me?",
+            header: "Reload",
+            options: [{ label: "Yes", description: "Yes" }],
+          },
+        ],
+      })
+    },
+  })
+  const result = ask.then(
+    () => "resolved" as const,
+    (err) => err,
+  )
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const pending = await Question.list()
+      expect(pending).toHaveLength(1)
+      await Instance.reload({ directory: tmp.path })
+    },
+  })
+
+  expect(await result).toBeInstanceOf(Question.RejectedError)
+})

package/test/runtime/acp-adapter.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from "bun:test"
+import type { Agent } from "@agentclientprotocol/sdk"
+
+let make = () => ({
+  initialize: async () => {},
+  newSession: async () => {},
+  authenticate: async () => {},
+  prompt: async () => {},
+  cancel: async () => {},
+}) as unknown as Agent
+
+const { RuntimeACPAdapter } = await import("../../src/runtime/adapters/acp")
+
+const load = async () => ({
+  ACP: {
+    init: async () => ({
+      create: () => make(),
+    }),
+  },
+})
+
+describe("runtime acp adapter", () => {
+  test("exposes stable feature and method set", () => {
+    const list = RuntimeACPAdapter.listFeatures()
+    expect(list.includes("session")).toBeTrue()
+    expect(list.includes("prompt")).toBeTrue()
+    expect(list.includes("tool")).toBeTrue()
+    expect(RuntimeACPAdapter.supports("session")).toBeTrue()
+    expect(RuntimeACPAdapter.supports("non-core")).toBeFalse()
+    expect(() => RuntimeACPAdapter.assert("session")).not.toThrow()
+    expect(() => RuntimeACPAdapter.assert("non-core")).toThrow()
+
+    const methods = RuntimeACPAdapter.listMethods()
+    expect(methods.includes("prompt")).toBeTrue()
+    expect(RuntimeACPAdapter.supportsMethod("prompt")).toBeTrue()
+    expect(RuntimeACPAdapter.supportsMethod("non-core")).toBeFalse()
+    expect(() => RuntimeACPAdapter.assertMethod("prompt")).not.toThrow()
+    expect(() => RuntimeACPAdapter.assertMethod("non-core")).toThrow()
+  })
+
+  test("allows mapped methods through wrapped adapter", async () => {
+    let called = false
+    make = () => ({
+      initialize: async () => {},
+      newSession: async () => {},
+      authenticate: async () => {},
+      prompt() {
+        called = true
+        return "ok"
+      },
+      cancel: async () => {},
+    }) as unknown as Agent
+
+    const runtime = await RuntimeACPAdapter.init({ sdk: {} as never, load }).then((item) =>
+      item.create({} as never, {}),
+    )
+    const prompt = Reflect.get(runtime as unknown as object, "prompt")
+    expect(typeof prompt).toBe("function")
+    expect((prompt as () => string)()).toBe("ok")
+    expect(called).toBeTrue()
+  })
+
+  test("blocks unmapped methods with explicit unsupported error", async () => {
+    make = () => ({
+      initialize: async () => {},
+      newSession: async () => {},
+      authenticate: async () => {},
+      prompt() {
+        return "ok"
+      },
+      cancel: async () => {},
+      custom() {
+        return "no"
+      },
+    }) as unknown as Agent
+
+    const runtime = await RuntimeACPAdapter.init({ sdk: {} as never, load }).then((item) =>
+      item.create({} as never, {}),
+    )
+    const custom = Reflect.get(runtime as unknown as object, "custom")
+    expect(typeof custom).toBe("function")
+    expect(() => (custom as () => string)()).toThrow("acp method not supported: custom")
+  })
+})

package/test/runtime/core-service.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "bun:test"
+import { RuntimeCore } from "../../src/runtime/core/service"
+
+test("runtime core supports replace and reset", () => {
+  const base = RuntimeCore.service()
+  const custom = {
+    ...base,
+  }
+
+  RuntimeCore.set(custom)
+  expect(RuntimeCore.service()).toBe(custom)
+
+  RuntimeCore.reset()
+  expect(RuntimeCore.service()).not.toBe(custom)
+  expect(typeof RuntimeCore.service().session.list).toBe("function")
+})

package/test/runtime/session-summarize.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "bun:test"
+import { summarizeSession } from "../../src/runtime/core/session-summarize"
+
+describe("runtime session summarize", () => {
+  test("uses latest user agent for compaction", async () => {
+    const calls: string[] = []
+    let compact = {}
+    const dep = {
+      async get(_sessionID: string) {
+        calls.push("get")
+        return { id: "s1" }
+      },
+      async cleanup(_session: unknown) {
+        calls.push("cleanup")
+      },
+      async messages(_input: { sessionID: string }) {
+        calls.push("messages")
+        return [
+          { info: { role: "assistant", agent: "none" } },
+          { info: { role: "user", agent: "build" } },
+          { info: { role: "assistant", agent: "none" } },
+        ]
+      },
+      async default() {
+        calls.push("default")
+        return "general"
+      },
+      async create(input: {
+        sessionID: string
+        agent: string
+        model: { providerID: string; modelID: string }
+        auto: boolean
+      }) {
+        calls.push("create")
+        compact = input
+      },
+      async loop(_input: { sessionID: string }) {
+        calls.push("loop")
+      },
+    }
+
+    await summarizeSession(
+      {
+        sessionID: "s1" as never,
+        providerID: "openai" as never,
+        modelID: "gpt-5" as never,
+      },
+      dep,
+    )
+
+    expect(compact).toEqual({
+      sessionID: "s1",
+      agent: "build",
+      model: { providerID: "openai", modelID: "gpt-5" },
+      auto: false,
+    })
+    expect(calls).toEqual(["get", "cleanup", "messages", "default", "create", "loop"])
+  })
+
+  test("falls back to default agent when latest user has none", async () => {
+    let count = 0
+    let compact = {}
+    const dep = {
+      async get(_sessionID: string) {
+        return {}
+      },
+      async cleanup(_session: unknown) {},
+      async messages(_input: { sessionID: string }) {
+        return [{ info: { role: "user" } }]
+      },
+      async default() {
+        count += 1
+        return "general"
+      },
+      async create(input: {
+        sessionID: string
+        agent: string
+        model: { providerID: string; modelID: string }
+        auto: boolean
+      }) {
+        compact = input
+      },
+      async loop(_input: { sessionID: string }) {},
+    }
+
+    await summarizeSession(
+      {
+        sessionID: "s2" as never,
+        providerID: "alibaba-coding-plan-cn" as never,
+        modelID: "qwen3-coder-plus" as never,
+        auto: true,
+      },
+      dep,
+    )
+
+    expect(count).toBe(2)
+    expect(compact).toEqual({
+      sessionID: "s2",
+      agent: "general",
+      model: { providerID: "alibaba-coding-plan-cn", modelID: "qwen3-coder-plus" },
+      auto: true,
+    })
+  })
+})