koro-ai 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/server/global-session-list.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test"
+import { Instance } from "../../src/project/instance"
+import { Project } from "../../src/project/project"
+import { Session } from "../../src/session"
+import { Log } from "../../src/util/log"
+import { tmpdir } from "../fixture/fixture"
+
+Log.init({ print: false })
+
+describe("Session.listGlobal", () => {
+  test("lists sessions across projects with project metadata", async () => {
+    await using first = await tmpdir({ git: true })
+    await using second = await tmpdir({ git: true })
+
+    const firstSession = await Instance.provide({
+      directory: first.path,
+      fn: async () => Session.create({ title: "first-session" }),
+    })
+    const secondSession = await Instance.provide({
+      directory: second.path,
+      fn: async () => Session.create({ title: "second-session" }),
+    })
+
+    const sessions = [...Session.listGlobal({ limit: 200 })]
+    const ids = sessions.map((session) => session.id)
+
+    expect(ids).toContain(firstSession.id)
+    expect(ids).toContain(secondSession.id)
+
+    const firstProject = Project.get(firstSession.projectID)
+    const secondProject = Project.get(secondSession.projectID)
+
+    const firstItem = sessions.find((session) => session.id === firstSession.id)
+    const secondItem = sessions.find((session) => session.id === secondSession.id)
+
+    expect(firstItem?.project?.id).toBe(firstProject?.id)
+    expect(firstItem?.project?.worktree).toBe(firstProject?.worktree)
+    expect(secondItem?.project?.id).toBe(secondProject?.id)
+    expect(secondItem?.project?.worktree).toBe(secondProject?.worktree)
+  })
+
+  test("excludes archived sessions by default", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const archived = await Instance.provide({
+      directory: tmp.path,
+      fn: async () => Session.create({ title: "archived-session" }),
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => Session.setArchived({ sessionID: archived.id, time: Date.now() }),
+    })
+
+    const sessions = [...Session.listGlobal({ limit: 200 })]
+    const ids = sessions.map((session) => session.id)
+
+    expect(ids).not.toContain(archived.id)
+
+    const allSessions = [...Session.listGlobal({ limit: 200, archived: true })]
+    const allIds = allSessions.map((session) => session.id)
+
+    expect(allIds).toContain(archived.id)
+  })
+
+  test("supports cursor pagination", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const first = await Instance.provide({
+      directory: tmp.path,
+      fn: async () => Session.create({ title: "page-one" }),
+    })
+    await new Promise((resolve) => setTimeout(resolve, 5))
+    const second = await Instance.provide({
+      directory: tmp.path,
+      fn: async () => Session.create({ title: "page-two" }),
+    })
+
+    const page = [...Session.listGlobal({ directory: tmp.path, limit: 1 })]
+    expect(page.length).toBe(1)
+    expect(page[0].id).toBe(second.id)
+
+    const next = [...Session.listGlobal({ directory: tmp.path, limit: 10, cursor: page[0].time.updated })]
+    const ids = next.map((session) => session.id)
+
+    expect(ids).toContain(first.id)
+    expect(ids).not.toContain(second.id)
+  })
+})

package/test/server/project-init-git.test.ts

@@ -0,0 +1,121 @@
+import { afterEach, describe, expect, spyOn, test } from "bun:test"
+import path from "path"
+import { GlobalBus } from "../../src/bus/global"
+import { Snapshot } from "../../src/snapshot"
+import { InstanceBootstrap } from "../../src/project/bootstrap"
+import { Instance } from "../../src/project/instance"
+import { Server } from "../../src/server/server"
+import { Filesystem } from "../../src/util/filesystem"
+import { Log } from "../../src/util/log"
+import { resetDatabase } from "../fixture/db"
+import { tmpdir } from "../fixture/fixture"
+
+Log.init({ print: false })
+
+afterEach(async () => {
+  await resetDatabase()
+})
+
+describe("project.initGit endpoint", () => {
+  test("initializes git and reloads immediately", async () => {
+    await using tmp = await tmpdir()
+    const app = Server.Default()
+    const seen: { directory?: string; payload: { type: string } }[] = []
+    const fn = (evt: { directory?: string; payload: { type: string } }) => {
+      seen.push(evt)
+    }
+    const reload = Instance.reload
+    const reloadSpy = spyOn(Instance, "reload").mockImplementation((input) => reload(input))
+    GlobalBus.on("event", fn)
+
+    try {
+      const init = await app.request("/project/git/init", {
+        method: "POST",
+        headers: {
+          "x-opencode-directory": tmp.path,
+        },
+      })
+      const body = await init.json()
+      expect(init.status).toBe(200)
+      expect(body).toMatchObject({
+        id: "global",
+        vcs: "git",
+        worktree: tmp.path,
+      })
+      expect(reloadSpy).toHaveBeenCalledTimes(1)
+      expect(reloadSpy.mock.calls[0]?.[0]?.init).toBe(InstanceBootstrap)
+      expect(seen.some((evt) => evt.directory === tmp.path && evt.payload.type === "server.instance.disposed")).toBe(
+        true,
+      )
+      expect(await Filesystem.exists(path.join(tmp.path, ".git", "opencode"))).toBe(false)
+
+      const current = await app.request("/project/current", {
+        headers: {
+          "x-opencode-directory": tmp.path,
+        },
+      })
+      expect(current.status).toBe(200)
+      expect(await current.json()).toMatchObject({
+        id: "global",
+        vcs: "git",
+        worktree: tmp.path,
+      })
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          expect(await Snapshot.track()).toBeTruthy()
+        },
+      })
+    } finally {
+      await Instance.disposeAll()
+      reloadSpy.mockRestore()
+      GlobalBus.off("event", fn)
+    }
+  })
+
+  test("does not reload when the project is already git", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const app = Server.Default()
+    const seen: { directory?: string; payload: { type: string } }[] = []
+    const fn = (evt: { directory?: string; payload: { type: string } }) => {
+      seen.push(evt)
+    }
+    const reload = Instance.reload
+    const reloadSpy = spyOn(Instance, "reload").mockImplementation((input) => reload(input))
+    GlobalBus.on("event", fn)
+
+    try {
+      const init = await app.request("/project/git/init", {
+        method: "POST",
+        headers: {
+          "x-opencode-directory": tmp.path,
+        },
+      })
+      expect(init.status).toBe(200)
+      expect(await init.json()).toMatchObject({
+        vcs: "git",
+        worktree: tmp.path,
+      })
+      expect(
+        seen.filter((evt) => evt.directory === tmp.path && evt.payload.type === "server.instance.disposed").length,
+      ).toBe(0)
+      expect(reloadSpy).toHaveBeenCalledTimes(0)
+
+      const current = await app.request("/project/current", {
+        headers: {
+          "x-opencode-directory": tmp.path,
+        },
+      })
+      expect(current.status).toBe(200)
+      expect(await current.json()).toMatchObject({
+        vcs: "git",
+        worktree: tmp.path,
+      })
+    } finally {
+      await Instance.disposeAll()
+      reloadSpy.mockRestore()
+      GlobalBus.off("event", fn)
+    }
+  })
+})