rird 2.1.231 → 2.3.0

package/test/cli/cmd/acp.test.ts

@@ -0,0 +1,144 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import path from "path"
+import { tmpdir } from "../../fixture/fixture"
+import { Instance } from "../../../src/project/instance"
+
+describe("ACP Command", () => {
+  test("should have acp command defined with correct options", async () => {
+    // Import the ACP command to verify it's defined
+    const { AcpCommand } = await import("../../../src/cli/cmd/acp")
+
+    expect(AcpCommand).toBeDefined()
+    expect(AcpCommand.command).toBe("acp")
+    expect(AcpCommand.describe).toContain("ACP")
+    expect(AcpCommand.describe).toContain("Agent Client Protocol")
+  })
+
+  test("acp command should have port option", async () => {
+    const { AcpCommand } = await import("../../../src/cli/cmd/acp")
+
+    // Verify the builder sets up port option
+    expect(AcpCommand.builder).toBeDefined()
+
+    // The builder is a function that sets up yargs
+    // We test that it's callable
+    let hasPortOption = false
+    let hasHostnameOption = false
+
+    // Mock yargs to capture builder calls
+    const mockYargs = {
+      option: (name: string) => {
+        if (name === "port") hasPortOption = true
+        if (name === "hostname") hasHostnameOption = true
+        return mockYargs
+      },
+    }
+
+    if (typeof AcpCommand.builder === "function") {
+      AcpCommand.builder(mockYargs as any)
+    }
+
+    expect(hasPortOption).toBe(true)
+    expect(hasHostnameOption).toBe(true)
+  })
+
+  test("acp command handler should be async function", async () => {
+    const { AcpCommand } = await import("../../../src/cli/cmd/acp")
+
+    expect(AcpCommand.handler).toBeDefined()
+    expect(typeof AcpCommand.handler).toBe("function")
+
+    // Verify it's async
+    const result = AcpCommand.handler({
+      cwd: process.cwd(),
+      port: 0,
+      hostname: "127.0.0.1",
+      _: [],
+      $0: "",
+    } as any)
+
+    expect(result).toBeInstanceOf(Promise)
+  })
+
+  test("acp command should accept custom working directory", async () => {
+    await using tmp = await tmpdir()
+
+    const { AcpCommand } = await import("../../../src/cli/cmd/acp")
+
+    expect(AcpCommand.builder).toBeDefined()
+
+    // Verify cwd option exists by checking the builder
+    let cwdOptionFound = false
+    const mockYargs = {
+      option: (name: string, config: any) => {
+        if (name === "cwd") {
+          cwdOptionFound = true
+          expect(config.describe).toContain("working directory")
+          expect(config.type).toBe("string")
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof AcpCommand.builder === "function") {
+      AcpCommand.builder(mockYargs as any)
+    }
+
+    expect(cwdOptionFound).toBe(true)
+  })
+
+  test("acp command should support custom port", async () => {
+    const { AcpCommand } = await import("../../../src/cli/cmd/acp")
+
+    let portConfig: any = null
+    const mockYargs = {
+      option: (name: string, config: any) => {
+        if (name === "port") {
+          portConfig = config
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof AcpCommand.builder === "function") {
+      AcpCommand.builder(mockYargs as any)
+    }
+
+    expect(portConfig).toBeDefined()
+    expect(portConfig.type).toBe("number")
+    expect(portConfig.default).toBe(0) // 0 means auto-assign
+  })
+
+  test("acp command should have default hostname", async () => {
+    const { AcpCommand } = await import("../../../src/cli/cmd/acp")
+
+    let hostnameConfig: any = null
+    const mockYargs = {
+      option: (name: string, config: any) => {
+        if (name === "hostname") {
+          hostnameConfig = config
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof AcpCommand.builder === "function") {
+      AcpCommand.builder(mockYargs as any)
+    }
+
+    expect(hostnameConfig).toBeDefined()
+    expect(hostnameConfig.type).toBe("string")
+    expect(hostnameConfig.default).toBe("127.0.0.1")
+  })
+
+  test("acp command handler should unhandled rejection handler", async () => {
+    const { AcpCommand } = await import("../../../src/cli/cmd/acp")
+
+    // Verify there's error handling for unhandled rejections
+    expect(AcpCommand).toBeDefined()
+
+    // The module should have set up unhandledRejection listener
+    const listeners = process.listeners("unhandledRejection")
+    expect(listeners.length).toBeGreaterThan(0)
+  })
+})

package/test/cli/cmd/run.test.ts

@@ -0,0 +1,250 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import path from "path"
+import { tmpdir } from "../../fixture/fixture"
+import { mockEnv } from "../../helpers"
+
+describe("Run Command", () => {
+  let restoreEnv: (() => void) | undefined
+
+  beforeEach(() => {
+    // Setup test environment
+  })
+
+  afterEach(() => {
+    if (restoreEnv) {
+      restoreEnv()
+    }
+  })
+
+  test("should have run command defined", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    expect(RunCommand).toBeDefined()
+    expect(RunCommand.command).toBe("run [message..]")
+    expect(RunCommand.describe).toContain("run rird")
+  })
+
+  test("run command should accept message positional argument", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    let messagePositionFound = false
+    const mockYargs = {
+      positional: (name: string, config: any) => {
+        if (name === "message") {
+          messagePositionFound = true
+          expect(config.type).toBe("string")
+          expect(config.array).toBe(true)
+        }
+        return mockYargs
+      },
+      option: () => mockYargs,
+    }
+
+    if (typeof RunCommand.builder === "function") {
+      RunCommand.builder(mockYargs as any)
+    }
+
+    expect(messagePositionFound).toBe(true)
+  })
+
+  test("run command should have model option", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    let modelOptionFound = false
+    const mockYargs = {
+      positional: () => mockYargs,
+      option: (name: string, config: any) => {
+        if (name === "model") {
+          modelOptionFound = true
+          expect(config.type).toBe("string")
+          expect(config.alias).toContain("m")
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof RunCommand.builder === "function") {
+      RunCommand.builder(mockYargs as any)
+    }
+
+    expect(modelOptionFound).toBe(true)
+  })
+
+  test("run command should have session options", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    let sessionOptionFound = false
+    let continueOptionFound = false
+
+    const mockYargs = {
+      positional: () => mockYargs,
+      option: (name: string, config: any) => {
+        if (name === "session") {
+          sessionOptionFound = true
+          expect(config.type).toBe("string")
+          expect(config.alias).toContain("s")
+        }
+        if (name === "continue") {
+          continueOptionFound = true
+          expect(config.type).toBe("boolean")
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof RunCommand.builder === "function") {
+      RunCommand.builder(mockYargs as any)
+    }
+
+    expect(sessionOptionFound).toBe(true)
+    expect(continueOptionFound).toBe(true)
+  })
+
+  test("run command should have file option", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    let fileOptionFound = false
+    const mockYargs = {
+      positional: () => mockYargs,
+      option: (name: string, config: any) => {
+        if (name === "file") {
+          fileOptionFound = true
+          expect(config.type).toBe("string")
+          expect(config.array).toBe(true)
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof RunCommand.builder === "function") {
+      RunCommand.builder(mockYargs as any)
+    }
+
+    expect(fileOptionFound).toBe(true)
+  })
+
+  test("run command should have title option", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    let titleOptionFound = false
+    const mockYargs = {
+      positional: () => mockYargs,
+      option: (name: string, config: any) => {
+        if (name === "title") {
+          titleOptionFound = true
+          expect(config.type).toBe("string")
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof RunCommand.builder === "function") {
+      RunCommand.builder(mockYargs as any)
+    }
+
+    expect(titleOptionFound).toBe(true)
+  })
+
+  test("run command should support format option", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    let formatOptionFound = false
+    const mockYargs = {
+      positional: () => mockYargs,
+      option: (name: string, config: any) => {
+        if (name === "format") {
+          formatOptionFound = true
+          expect(config.type).toBe("string")
+          expect(config.choices).toContain("default")
+          expect(config.choices).toContain("json")
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof RunCommand.builder === "function") {
+      RunCommand.builder(mockYargs as any)
+    }
+
+    expect(formatOptionFound).toBe(true)
+  })
+
+  test("run command should have handler function", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    expect(RunCommand.handler).toBeDefined()
+    expect(typeof RunCommand.handler).toBe("function")
+  })
+
+  test("run command builder should return yargs instance", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    expect(typeof RunCommand.builder === "function").toBe(true)
+  })
+
+  test("run command should support agent option", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    let agentOptionFound = false
+    const mockYargs = {
+      positional: () => mockYargs,
+      option: (name: string, config: any) => {
+        if (name === "agent") {
+          agentOptionFound = true
+          expect(config.type).toBe("string")
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof RunCommand.builder === "function") {
+      RunCommand.builder(mockYargs as any)
+    }
+
+    expect(agentOptionFound).toBe(true)
+  })
+
+  test("run command should support share option", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    let shareOptionFound = false
+    const mockYargs = {
+      positional: () => mockYargs,
+      option: (name: string, config: any) => {
+        if (name === "share") {
+          shareOptionFound = true
+          expect(config.type).toBe("boolean")
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof RunCommand.builder === "function") {
+      RunCommand.builder(mockYargs as any)
+    }
+
+    expect(shareOptionFound).toBe(true)
+  })
+
+  test("run command should have command option", async () => {
+    const { RunCommand } = await import("../../../src/cli/cmd/run")
+
+    let commandOptionFound = false
+    const mockYargs = {
+      positional: () => mockYargs,
+      option: (name: string, config: any) => {
+        if (name === "command") {
+          commandOptionFound = true
+          expect(config.type).toBe("string")
+        }
+        return mockYargs
+      },
+    }
+
+    if (typeof RunCommand.builder === "function") {
+      RunCommand.builder(mockYargs as any)
+    }
+
+    expect(commandOptionFound).toBe(true)
+  })
+})

package/test/cli/github-remote.test.ts

@@ -0,0 +1,80 @@
+import { test, expect } from "bun:test"
+import { parseGitHubRemote } from "../../src/cli/cmd/github"
+
+test("parses https URL with .git suffix", () => {
+  expect(parseGitHubRemote("https://github.com/sst/opencode.git")).toEqual({ owner: "sst", repo: "opencode" })
+})
+
+test("parses https URL without .git suffix", () => {
+  expect(parseGitHubRemote("https://github.com/sst/opencode")).toEqual({ owner: "sst", repo: "opencode" })
+})
+
+test("parses git@ URL with .git suffix", () => {
+  expect(parseGitHubRemote("git@github.com:sst/opencode.git")).toEqual({ owner: "sst", repo: "opencode" })
+})
+
+test("parses git@ URL without .git suffix", () => {
+  expect(parseGitHubRemote("git@github.com:sst/opencode")).toEqual({ owner: "sst", repo: "opencode" })
+})
+
+test("parses ssh:// URL with .git suffix", () => {
+  expect(parseGitHubRemote("ssh://git@github.com/sst/opencode.git")).toEqual({ owner: "sst", repo: "opencode" })
+})
+
+test("parses ssh:// URL without .git suffix", () => {
+  expect(parseGitHubRemote("ssh://git@github.com/sst/opencode")).toEqual({ owner: "sst", repo: "opencode" })
+})
+
+test("parses http URL", () => {
+  expect(parseGitHubRemote("http://github.com/owner/repo")).toEqual({ owner: "owner", repo: "repo" })
+})
+
+test("parses URL with hyphenated owner and repo names", () => {
+  expect(parseGitHubRemote("https://github.com/my-org/my-repo.git")).toEqual({ owner: "my-org", repo: "my-repo" })
+})
+
+test("parses URL with underscores in names", () => {
+  expect(parseGitHubRemote("git@github.com:my_org/my_repo.git")).toEqual({ owner: "my_org", repo: "my_repo" })
+})
+
+test("parses URL with numbers in names", () => {
+  expect(parseGitHubRemote("https://github.com/org123/repo456")).toEqual({ owner: "org123", repo: "repo456" })
+})
+
+test("parses repos with dots in the name", () => {
+  expect(parseGitHubRemote("https://github.com/socketio/socket.io.git")).toEqual({
+    owner: "socketio",
+    repo: "socket.io",
+  })
+  expect(parseGitHubRemote("https://github.com/vuejs/vue.js")).toEqual({
+    owner: "vuejs",
+    repo: "vue.js",
+  })
+  expect(parseGitHubRemote("git@github.com:mrdoob/three.js.git")).toEqual({
+    owner: "mrdoob",
+    repo: "three.js",
+  })
+  expect(parseGitHubRemote("https://github.com/jashkenas/backbone.git")).toEqual({
+    owner: "jashkenas",
+    repo: "backbone",
+  })
+})
+
+test("returns null for non-github URLs", () => {
+  expect(parseGitHubRemote("https://gitlab.com/owner/repo.git")).toBeNull()
+  expect(parseGitHubRemote("git@gitlab.com:owner/repo.git")).toBeNull()
+  expect(parseGitHubRemote("https://bitbucket.org/owner/repo")).toBeNull()
+})
+
+test("returns null for invalid URLs", () => {
+  expect(parseGitHubRemote("not-a-url")).toBeNull()
+  expect(parseGitHubRemote("")).toBeNull()
+  expect(parseGitHubRemote("github.com")).toBeNull()
+  expect(parseGitHubRemote("https://github.com/")).toBeNull()
+  expect(parseGitHubRemote("https://github.com/owner")).toBeNull()
+})
+
+test("returns null for URLs with extra path segments", () => {
+  expect(parseGitHubRemote("https://github.com/owner/repo/tree/main")).toBeNull()
+  expect(parseGitHubRemote("https://github.com/owner/repo/blob/main/file.ts")).toBeNull()
+})

package/test/config/agent-color.test.ts

@@ -0,0 +1,66 @@
+import { test, expect } from "bun:test"
+import path from "path"
+import { tmpdir } from "../fixture/fixture"
+import { Instance } from "../../src/project/instance"
+import { Config } from "../../src/config/config"
+import { Agent as AgentSvc } from "../../src/agent/agent"
+import { Color } from "../../src/util/color"
+
+test("agent color parsed from project config", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://rird.ai/config.json",
+          agent: {
+            act: { color: "#FFA500" },
+          },
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const cfg = await Config.get()
+      expect(cfg.agent?.["act"]?.color).toBe("#FFA500")
+    },
+  })
+})
+
+test("Agent.get includes color from config", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://rird.ai/config.json",
+          agent: {
+            plan: { color: "#A855F7" },
+          },
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const plan = await AgentSvc.get("plan")
+      expect(plan?.color).toBe("#A855F7")
+    },
+  })
+})
+
+test("Color.hexToAnsiBold converts valid hex to ANSI", () => {
+  const result = Color.hexToAnsiBold("#FFA500")
+  expect(result).toBe("\x1b[38;2;255;165;0m\x1b[1m")
+})
+
+test("Color.hexToAnsiBold returns undefined for invalid hex", () => {
+  expect(Color.hexToAnsiBold(undefined)).toBeUndefined()
+  expect(Color.hexToAnsiBold("")).toBeUndefined()
+  expect(Color.hexToAnsiBold("#FFF")).toBeUndefined()
+  expect(Color.hexToAnsiBold("FFA500")).toBeUndefined()
+  expect(Color.hexToAnsiBold("#GGGGGG")).toBeUndefined()
+})