luna/oh-my-opencode
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: major codebase cleanup - BDD comments, file splitting, bug fixes (#1350)

Browse Source 
* style(tests): normalize BDD comments from '// #given' to '// given'

- Replace 4,668 Python-style BDD comments across 107 test files
- Patterns changed: // #given -> // given, // #when -> // when, // #then -> // then
- Also handles no-space variants: //#given -> // given

* fix(rules-injector): prefer output.metadata.filePath over output.title

- Extract file path resolution to dedicated output-path.ts module
- Prefer metadata.filePath which contains actual file path
- Fall back to output.title only when metadata unavailable
- Fixes issue where rules weren't injected when tool output title was a label

* feat(slashcommand): add optional user_message parameter

- Add user_message optional parameter for command arguments
- Model can now call: command='publish' user_message='patch'
- Improves error messages with clearer format guidance
- Helps LLMs understand correct parameter usage

* feat(hooks): restore compaction-context-injector hook

- Restore hook deleted in cbbc7bd0 for session compaction context
- Injects 7 mandatory sections: User Requests, Final Goal, Work Completed,
  Remaining Tasks, Active Working Context, MUST NOT Do, Agent Verification State
- Re-register in hooks/index.ts and main plugin entry

* refactor(background-agent): split manager.ts into focused modules

- Extract constants.ts for TTL values and internal types (52 lines)
- Extract state.ts for TaskStateManager class (204 lines)
- Extract spawner.ts for task creation logic (244 lines)
- Extract result-handler.ts for completion handling (265 lines)
- Reduce manager.ts from 1377 to 755 lines (45% reduction)
- Maintain backward compatible exports

* refactor(agents): split prometheus-prompt.ts into subdirectory

- Move 1196-line prometheus-prompt.ts to prometheus/ subdirectory
- Organize prompt sections into separate files for maintainability
- Update agents/index.ts exports

* refactor(delegate-task): split tools.ts into focused modules

- Extract categories.ts for category definitions and routing
- Extract executor.ts for task execution logic
- Extract helpers.ts for utility functions
- Extract prompt-builder.ts for prompt construction
- Reduce tools.ts complexity with cleaner separation of concerns

* refactor(builtin-skills): split skills.ts into individual skill files

- Move each skill to dedicated file in skills/ subdirectory
- Create barrel export for backward compatibility
- Improve maintainability with focused skill modules

* chore: update import paths and lockfile

- Update prometheus import path after refactor
- Update bun.lock

* fix(tests): complete BDD comment normalization

- Fix remaining #when/#then patterns missed by initial sed
- Affected: state.test.ts, events.test.ts

---------

Co-authored-by: justsisyphus <justsisyphus@users.noreply.github.com>
This commit is contained in:
YeonGyu-Kim
2026-02-01 16:47:50 +09:00
committed by GitHub
parent c83150d9ea
commit f146aeff0f
145 changed files with 10307 additions and 9562 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/cli/doctor/checks/auth.test.ts
+24 -24
View File
@@ -4,19 +4,19 @@ import * as auth from "./auth"
describe("auth check", () => {
describe("getAuthProviderInfo", () => {
it("returns anthropic as always available", () => {
// #given anthropic provider
// #when getting info
// given anthropic provider
// when getting info
const info = auth.getAuthProviderInfo("anthropic")
// #then should show plugin installed (builtin)
// then should show plugin installed (builtin)
expect(info.id).toBe("anthropic")
expect(info.pluginInstalled).toBe(true)
})
it("returns correct name for each provider", () => {
// #given each provider
// #when getting info
// #then should have correct names
// given each provider
// when getting info
// then should have correct names
expect(auth.getAuthProviderInfo("anthropic").name).toContain("Claude")
expect(auth.getAuthProviderInfo("openai").name).toContain("ChatGPT")
expect(auth.getAuthProviderInfo("google").name).toContain("Gemini")
@@ -31,7 +31,7 @@ describe("auth check", () => {
})
it("returns pass when plugin installed", async () => {
// #given plugin installed
// given plugin installed
getInfoSpy = spyOn(auth, "getAuthProviderInfo").mockReturnValue({
id: "anthropic",
name: "Anthropic (Claude)",
@@ -39,15 +39,15 @@ describe("auth check", () => {
configured: true,
})
// #when checking
// when checking
const result = await auth.checkAuthProvider("anthropic")
// #then should pass
// then should pass
expect(result.status).toBe("pass")
})
it("returns skip when plugin not installed", async () => {
// #given plugin not installed
// given plugin not installed
getInfoSpy = spyOn(auth, "getAuthProviderInfo").mockReturnValue({
id: "openai",
name: "OpenAI (ChatGPT)",
@@ -55,10 +55,10 @@ describe("auth check", () => {
configured: false,
})
// #when checking
// when checking
const result = await auth.checkAuthProvider("openai")
// #then should skip
// then should skip
expect(result.status).toBe("skip")
expect(result.message).toContain("not installed")
})
@@ -66,11 +66,11 @@ describe("auth check", () => {
describe("checkAnthropicAuth", () => {
it("returns a check result", async () => {
// #given
// #when checking anthropic
// given
// when checking anthropic
const result = await auth.checkAnthropicAuth()
// #then should return valid result
// then should return valid result
expect(result.name).toBeDefined()
expect(["pass", "fail", "warn", "skip"]).toContain(result.status)
})
@@ -78,11 +78,11 @@ describe("auth check", () => {
describe("checkOpenAIAuth", () => {
it("returns a check result", async () => {
// #given
// #when checking openai
// given
// when checking openai
const result = await auth.checkOpenAIAuth()
// #then should return valid result
// then should return valid result
expect(result.name).toBeDefined()
expect(["pass", "fail", "warn", "skip"]).toContain(result.status)
})
@@ -90,11 +90,11 @@ describe("auth check", () => {
describe("checkGoogleAuth", () => {
it("returns a check result", async () => {
// #given
// #when checking google
// given
// when checking google
const result = await auth.checkGoogleAuth()
// #then should return valid result
// then should return valid result
expect(result.name).toBeDefined()
expect(["pass", "fail", "warn", "skip"]).toContain(result.status)
})
@@ -102,11 +102,11 @@ describe("auth check", () => {
describe("getAuthCheckDefinitions", () => {
it("returns definitions for all three providers", () => {
// #given
// #when getting definitions
// given
// when getting definitions
const defs = auth.getAuthCheckDefinitions()
// #then should have 3 definitions
// then should have 3 definitions
expect(defs.length).toBe(3)
expect(defs.every((d) => d.category === "authentication")).toBe(true)
})
src/cli/doctor/checks/config.test.ts
+18 -18
View File
@@ -4,11 +4,11 @@ import * as config from "./config"
describe("config check", () => {
describe("validateConfig", () => {
it("returns valid: false for non-existent file", () => {
// #given non-existent file path
// #when validating
// given non-existent file path
// when validating
const result = config.validateConfig("/non/existent/path.json")
// #then should indicate invalid
// then should indicate invalid
expect(result.valid).toBe(false)
expect(result.errors.length).toBeGreaterThan(0)
})
@@ -16,11 +16,11 @@ describe("config check", () => {
describe("getConfigInfo", () => {
it("returns exists: false when no config found", () => {
// #given no config file exists
// #when getting config info
// given no config file exists
// when getting config info
const info = config.getConfigInfo()
// #then should handle gracefully
// then should handle gracefully
expect(typeof info.exists).toBe("boolean")
expect(typeof info.valid).toBe("boolean")
})
@@ -34,7 +34,7 @@ describe("config check", () => {
})
it("returns pass when no config exists (uses defaults)", async () => {
// #given no config file
// given no config file
getInfoSpy = spyOn(config, "getConfigInfo").mockReturnValue({
exists: false,
path: null,
@@ -43,16 +43,16 @@ describe("config check", () => {
errors: [],
})
// #when checking validity
// when checking validity
const result = await config.checkConfigValidity()
// #then should pass with default message
// then should pass with default message
expect(result.status).toBe("pass")
expect(result.message).toContain("default")
})
it("returns pass when config is valid", async () => {
// #given valid config
// given valid config
getInfoSpy = spyOn(config, "getConfigInfo").mockReturnValue({
exists: true,
path: "/home/user/.config/opencode/oh-my-opencode.json",
@@ -61,16 +61,16 @@ describe("config check", () => {
errors: [],
})
// #when checking validity
// when checking validity
const result = await config.checkConfigValidity()
// #then should pass
// then should pass
expect(result.status).toBe("pass")
expect(result.message).toContain("JSON")
})
it("returns fail when config has validation errors", async () => {
// #given invalid config
// given invalid config
getInfoSpy = spyOn(config, "getConfigInfo").mockReturnValue({
exists: true,
path: "/home/user/.config/opencode/oh-my-opencode.json",
@@ -79,10 +79,10 @@ describe("config check", () => {
errors: ["agents.oracle: Invalid model format"],
})
// #when checking validity
// when checking validity
const result = await config.checkConfigValidity()
// #then should fail with errors
// then should fail with errors
expect(result.status).toBe("fail")
expect(result.details?.some((d) => d.includes("Error"))).toBe(true)
})
@@ -90,11 +90,11 @@ describe("config check", () => {
describe("getConfigCheckDefinition", () => {
it("returns valid check definition", () => {
// #given
// #when getting definition
// given
// when getting definition
const def = config.getConfigCheckDefinition()
// #then should have required properties
// then should have required properties
expect(def.id).toBe("config-validation")
expect(def.category).toBe("configuration")
expect(def.critical).toBe(false)
src/cli/doctor/checks/dependencies.test.ts
+24 -24
View File
@@ -4,11 +4,11 @@ import * as deps from "./dependencies"
describe("dependencies check", () => {
describe("checkAstGrepCli", () => {
it("returns dependency info", async () => {
// #given
// #when checking ast-grep cli
// given
// when checking ast-grep cli
const info = await deps.checkAstGrepCli()
// #then should return valid info
// then should return valid info
expect(info.name).toBe("AST-Grep CLI")
expect(info.required).toBe(false)
expect(typeof info.installed).toBe("boolean")
@@ -17,11 +17,11 @@ describe("dependencies check", () => {
describe("checkAstGrepNapi", () => {
it("returns dependency info", async () => {
// #given
// #when checking ast-grep napi
// given
// when checking ast-grep napi
const info = await deps.checkAstGrepNapi()
// #then should return valid info
// then should return valid info
expect(info.name).toBe("AST-Grep NAPI")
expect(info.required).toBe(false)
expect(typeof info.installed).toBe("boolean")
@@ -30,11 +30,11 @@ describe("dependencies check", () => {
describe("checkCommentChecker", () => {
it("returns dependency info", async () => {
// #given
// #when checking comment checker
// given
// when checking comment checker
const info = await deps.checkCommentChecker()
// #then should return valid info
// then should return valid info
expect(info.name).toBe("Comment Checker")
expect(info.required).toBe(false)
expect(typeof info.installed).toBe("boolean")
@@ -49,7 +49,7 @@ describe("dependencies check", () => {
})
it("returns pass when installed", async () => {
// #given ast-grep installed
// given ast-grep installed
checkSpy = spyOn(deps, "checkAstGrepCli").mockResolvedValue({
name: "AST-Grep CLI",
required: false,
@@ -58,16 +58,16 @@ describe("dependencies check", () => {
path: "/usr/local/bin/sg",
})
// #when checking
// when checking
const result = await deps.checkDependencyAstGrepCli()
// #then should pass
// then should pass
expect(result.status).toBe("pass")
expect(result.message).toContain("0.25.0")
})
it("returns warn when not installed", async () => {
// #given ast-grep not installed
// given ast-grep not installed
checkSpy = spyOn(deps, "checkAstGrepCli").mockResolvedValue({
name: "AST-Grep CLI",
required: false,
@@ -77,10 +77,10 @@ describe("dependencies check", () => {
installHint: "Install: npm install -g @ast-grep/cli",
})
// #when checking
// when checking
const result = await deps.checkDependencyAstGrepCli()
// #then should warn (optional)
// then should warn (optional)
expect(result.status).toBe("warn")
expect(result.message).toContain("optional")
})
@@ -94,7 +94,7 @@ describe("dependencies check", () => {
})
it("returns pass when installed", async () => {
// #given napi installed
// given napi installed
checkSpy = spyOn(deps, "checkAstGrepNapi").mockResolvedValue({
name: "AST-Grep NAPI",
required: false,
@@ -103,10 +103,10 @@ describe("dependencies check", () => {
path: null,
})
// #when checking
// when checking
const result = await deps.checkDependencyAstGrepNapi()
// #then should pass
// then should pass
expect(result.status).toBe("pass")
})
})
@@ -119,7 +119,7 @@ describe("dependencies check", () => {
})
it("returns warn when not installed", async () => {
// #given comment checker not installed
// given comment checker not installed
checkSpy = spyOn(deps, "checkCommentChecker").mockResolvedValue({
name: "Comment Checker",
required: false,
@@ -129,21 +129,21 @@ describe("dependencies check", () => {
installHint: "Hook will be disabled if not available",
})
// #when checking
// when checking
const result = await deps.checkDependencyCommentChecker()
// #then should warn
// then should warn
expect(result.status).toBe("warn")
})
})
describe("getDependencyCheckDefinitions", () => {
it("returns definitions for all dependencies", () => {
// #given
// #when getting definitions
// given
// when getting definitions
const defs = deps.getDependencyCheckDefinitions()
// #then should have 3 definitions
// then should have 3 definitions
expect(defs.length).toBe(3)
expect(defs.every((d) => d.category === "dependencies")).toBe(true)
expect(defs.every((d) => d.critical === false)).toBe(true)
src/cli/doctor/checks/gh.test.ts
+12 -12
View File
@@ -68,7 +68,7 @@ describe("gh cli check", () => {
})
it("returns warn when gh is not installed", async () => {
// #given gh not installed
// given gh not installed
getInfoSpy = spyOn(gh, "getGhCliInfo").mockResolvedValue({
installed: false,
version: null,
@@ -79,17 +79,17 @@ describe("gh cli check", () => {
error: null,
})
// #when checking
// when checking
const result = await gh.checkGhCli()
// #then should warn (optional)
// then should warn (optional)
expect(result.status).toBe("warn")
expect(result.message).toContain("Not installed")
expect(result.details).toContain("Install: https://cli.github.com/")
})
it("returns warn when gh is installed but not authenticated", async () => {
// #given gh installed but not authenticated
// given gh installed but not authenticated
getInfoSpy = spyOn(gh, "getGhCliInfo").mockResolvedValue({
installed: true,
version: "2.40.0",
@@ -100,10 +100,10 @@ describe("gh cli check", () => {
error: "not logged in",
})
// #when checking
// when checking
const result = await gh.checkGhCli()
// #then should warn about auth
// then should warn about auth
expect(result.status).toBe("warn")
expect(result.message).toContain("2.40.0")
expect(result.message).toContain("not authenticated")
@@ -111,7 +111,7 @@ describe("gh cli check", () => {
})
it("returns pass when gh is installed and authenticated", async () => {
// #given gh installed and authenticated
// given gh installed and authenticated
getInfoSpy = spyOn(gh, "getGhCliInfo").mockResolvedValue({
installed: true,
version: "2.40.0",
@@ -122,10 +122,10 @@ describe("gh cli check", () => {
error: null,
})
// #when checking
// when checking
const result = await gh.checkGhCli()
// #then should pass
// then should pass
expect(result.status).toBe("pass")
expect(result.message).toContain("2.40.0")
expect(result.message).toContain("octocat")
@@ -136,11 +136,11 @@ describe("gh cli check", () => {
describe("getGhCliCheckDefinition", () => {
it("returns correct check definition", () => {
// #given
// #when getting definition
// given
// when getting definition
const def = gh.getGhCliCheckDefinition()
// #then should have correct properties
// then should have correct properties
expect(def.id).toBe("gh-cli")
expect(def.name).toBe("GitHub CLI")
expect(def.category).toBe("tools")
src/cli/doctor/checks/lsp.test.ts
+24 -24
View File
@@ -5,11 +5,11 @@ import type { LspServerInfo } from "../types"
describe("lsp check", () => {
describe("getLspServersInfo", () => {
it("returns array of server info", async () => {
// #given
// #when getting servers info
// given
// when getting servers info
const servers = await lsp.getLspServersInfo()
// #then should return array with expected structure
// then should return array with expected structure
expect(Array.isArray(servers)).toBe(true)
servers.forEach((s) => {
expect(s.id).toBeDefined()
@@ -19,14 +19,14 @@ describe("lsp check", () => {
})
it("does not spawn 'which' command (windows compatibility)", async () => {
// #given
// given
const spawnSpy = spyOn(Bun, "spawn")
try {
// #when getting servers info
// when getting servers info
await lsp.getLspServersInfo()
// #then should not spawn which
// then should not spawn which
const calls = spawnSpy.mock.calls
const whichCalls = calls.filter((c) => Array.isArray(c) && Array.isArray(c[0]) && c[0][0] === "which")
expect(whichCalls.length).toBe(0)
@@ -38,29 +38,29 @@ describe("lsp check", () => {
describe("getLspServerStats", () => {
it("counts installed servers correctly", () => {
// #given servers with mixed installation status
// given servers with mixed installation status
const servers = [
{ id: "ts", installed: true, extensions: [".ts"], source: "builtin" as const },
{ id: "py", installed: false, extensions: [".py"], source: "builtin" as const },
{ id: "go", installed: true, extensions: [".go"], source: "builtin" as const },
]
// #when getting stats
// when getting stats
const stats = lsp.getLspServerStats(servers)
// #then should count correctly
// then should count correctly
expect(stats.installed).toBe(2)
expect(stats.total).toBe(3)
})
it("handles empty array", () => {
// #given no servers
// given no servers
const servers: LspServerInfo[] = []
// #when getting stats
// when getting stats
const stats = lsp.getLspServerStats(servers)
// #then should return zeros
// then should return zeros
expect(stats.installed).toBe(0)
expect(stats.total).toBe(0)
})
@@ -74,46 +74,46 @@ describe("lsp check", () => {
})
it("returns warn when no servers installed", async () => {
// #given no servers installed
// given no servers installed
getServersSpy = spyOn(lsp, "getLspServersInfo").mockResolvedValue([
{ id: "typescript-language-server", installed: false, extensions: [".ts"], source: "builtin" },
{ id: "pyright", installed: false, extensions: [".py"], source: "builtin" },
])
// #when checking
// when checking
const result = await lsp.checkLspServers()
// #then should warn
// then should warn
expect(result.status).toBe("warn")
expect(result.message).toContain("No LSP servers")
})
it("returns pass when servers installed", async () => {
// #given some servers installed
// given some servers installed
getServersSpy = spyOn(lsp, "getLspServersInfo").mockResolvedValue([
{ id: "typescript-language-server", installed: true, extensions: [".ts"], source: "builtin" },
{ id: "pyright", installed: false, extensions: [".py"], source: "builtin" },
])
// #when checking
// when checking
const result = await lsp.checkLspServers()
// #then should pass with count
// then should pass with count
expect(result.status).toBe("pass")
expect(result.message).toContain("1/2")
})
it("lists installed and missing servers in details", async () => {
// #given mixed installation
// given mixed installation
getServersSpy = spyOn(lsp, "getLspServersInfo").mockResolvedValue([
{ id: "typescript-language-server", installed: true, extensions: [".ts"], source: "builtin" },
{ id: "pyright", installed: false, extensions: [".py"], source: "builtin" },
])
// #when checking
// when checking
const result = await lsp.checkLspServers()
// #then should list both
// then should list both
expect(result.details?.some((d) => d.includes("Installed"))).toBe(true)
expect(result.details?.some((d) => d.includes("Not found"))).toBe(true)
})
@@ -121,11 +121,11 @@ describe("lsp check", () => {
describe("getLspCheckDefinition", () => {
it("returns valid check definition", () => {
// #given
// #when getting definition
// given
// when getting definition
const def = lsp.getLspCheckDefinition()
// #then should have required properties
// then should have required properties
expect(def.id).toBe("lsp-servers")
expect(def.category).toBe("tools")
expect(def.critical).toBe(false)
src/cli/doctor/checks/mcp-oauth.test.ts
+18 -18
View File
@@ -4,11 +4,11 @@ import * as mcpOauth from "./mcp-oauth"
describe("mcp-oauth check", () => {
describe("getMcpOAuthCheckDefinition", () => {
it("returns check definition with correct properties", () => {
// #given
// #when getting definition
// given
// when getting definition
const def = mcpOauth.getMcpOAuthCheckDefinition()
// #then should have correct structure
// then should have correct structure
expect(def.id).toBe("mcp-oauth-tokens")
expect(def.name).toBe("MCP OAuth Tokens")
expect(def.category).toBe("tools")
@@ -25,19 +25,19 @@ describe("mcp-oauth check", () => {
})
it("returns skip when no tokens stored", async () => {
// #given no OAuth tokens configured
// given no OAuth tokens configured
readStoreSpy = spyOn(mcpOauth, "readTokenStore").mockReturnValue(null)
// #when checking OAuth tokens
// when checking OAuth tokens
const result = await mcpOauth.checkMcpOAuthTokens()
// #then should skip
// then should skip
expect(result.status).toBe("skip")
expect(result.message).toContain("No OAuth")
})
it("returns pass when all tokens valid", async () => {
// #given valid tokens with future expiry (expiresAt is in epoch seconds)
// given valid tokens with future expiry (expiresAt is in epoch seconds)
const futureTime = Math.floor(Date.now() / 1000) + 3600
readStoreSpy = spyOn(mcpOauth, "readTokenStore").mockReturnValue({
"example.com/resource1": {
@@ -50,17 +50,17 @@ describe("mcp-oauth check", () => {
},
})
// #when checking OAuth tokens
// when checking OAuth tokens
const result = await mcpOauth.checkMcpOAuthTokens()
// #then should pass
// then should pass
expect(result.status).toBe("pass")
expect(result.message).toContain("2")
expect(result.message).toContain("valid")
})
it("returns warn when some tokens expired", async () => {
// #given mix of valid and expired tokens (expiresAt is in epoch seconds)
// given mix of valid and expired tokens (expiresAt is in epoch seconds)
const futureTime = Math.floor(Date.now() / 1000) + 3600
const pastTime = Math.floor(Date.now() / 1000) - 3600
readStoreSpy = spyOn(mcpOauth, "readTokenStore").mockReturnValue({
@@ -74,10 +74,10 @@ describe("mcp-oauth check", () => {
},
})
// #when checking OAuth tokens
// when checking OAuth tokens
const result = await mcpOauth.checkMcpOAuthTokens()
// #then should warn
// then should warn
expect(result.status).toBe("warn")
expect(result.message).toContain("1")
expect(result.message).toContain("expired")
@@ -87,23 +87,23 @@ describe("mcp-oauth check", () => {
})
it("returns pass when tokens have no expiry", async () => {
// #given tokens without expiry info
// given tokens without expiry info
readStoreSpy = spyOn(mcpOauth, "readTokenStore").mockReturnValue({
"example.com/resource1": {
accessToken: "token1",
},
})
// #when checking OAuth tokens
// when checking OAuth tokens
const result = await mcpOauth.checkMcpOAuthTokens()
// #then should pass (no expiry = assume valid)
// then should pass (no expiry = assume valid)
expect(result.status).toBe("pass")
expect(result.message).toContain("1")
})
it("includes token details in output", async () => {
// #given multiple tokens
// given multiple tokens
const futureTime = Math.floor(Date.now() / 1000) + 3600
readStoreSpy = spyOn(mcpOauth, "readTokenStore").mockReturnValue({
"api.example.com/v1": {
@@ -116,10 +116,10 @@ describe("mcp-oauth check", () => {
},
})
// #when checking OAuth tokens
// when checking OAuth tokens
const result = await mcpOauth.checkMcpOAuthTokens()
// #then should list tokens in details
// then should list tokens in details
expect(result.details).toBeDefined()
expect(result.details?.length).toBeGreaterThan(0)
expect(
src/cli/doctor/checks/mcp.test.ts
+24 -24
View File
@@ -4,11 +4,11 @@ import * as mcp from "./mcp"
describe("mcp check", () => {
describe("getBuiltinMcpInfo", () => {
it("returns builtin servers", () => {
// #given
// #when getting builtin info
// given
// when getting builtin info
const servers = mcp.getBuiltinMcpInfo()
// #then should include expected servers
// then should include expected servers
expect(servers.length).toBe(2)
expect(servers.every((s) => s.type === "builtin")).toBe(true)
expect(servers.every((s) => s.enabled === true)).toBe(true)
@@ -19,33 +19,33 @@ describe("mcp check", () => {
describe("getUserMcpInfo", () => {
it("returns empty array when no user config", () => {
// #given no user config exists
// #when getting user info
// given no user config exists
// when getting user info
const servers = mcp.getUserMcpInfo()
// #then should return array (may be empty)
// then should return array (may be empty)
expect(Array.isArray(servers)).toBe(true)
})
})
describe("checkBuiltinMcpServers", () => {
it("returns pass with server count", async () => {
// #given
// #when checking builtin servers
// given
// when checking builtin servers
const result = await mcp.checkBuiltinMcpServers()
// #then should pass
// then should pass
expect(result.status).toBe("pass")
expect(result.message).toContain("2")
expect(result.message).toContain("enabled")
})
it("lists enabled servers in details", async () => {
// #given
// #when checking builtin servers
// given
// when checking builtin servers
const result = await mcp.checkBuiltinMcpServers()
// #then should list servers
// then should list servers
expect(result.details?.some((d) => d.includes("context7"))).toBe(true)
expect(result.details?.some((d) => d.includes("grep_app"))).toBe(true)
})
@@ -59,41 +59,41 @@ describe("mcp check", () => {
})
it("returns skip when no user config", async () => {
// #given no user servers
// given no user servers
getUserSpy = spyOn(mcp, "getUserMcpInfo").mockReturnValue([])
// #when checking
// when checking
const result = await mcp.checkUserMcpServers()
// #then should skip
// then should skip
expect(result.status).toBe("skip")
expect(result.message).toContain("No user MCP")
})
it("returns pass when valid user servers", async () => {
// #given valid user servers
// given valid user servers
getUserSpy = spyOn(mcp, "getUserMcpInfo").mockReturnValue([
{ id: "custom-mcp", type: "user", enabled: true, valid: true },
])
// #when checking
// when checking
const result = await mcp.checkUserMcpServers()
// #then should pass
// then should pass
expect(result.status).toBe("pass")
expect(result.message).toContain("1")
})
it("returns warn when servers have issues", async () => {
// #given invalid server config
// given invalid server config
getUserSpy = spyOn(mcp, "getUserMcpInfo").mockReturnValue([
{ id: "bad-mcp", type: "user", enabled: true, valid: false, error: "Missing command" },
])
// #when checking
// when checking
const result = await mcp.checkUserMcpServers()
// #then should warn
// then should warn
expect(result.status).toBe("warn")
expect(result.details?.some((d) => d.includes("Invalid"))).toBe(true)
})
@@ -101,11 +101,11 @@ describe("mcp check", () => {
describe("getMcpCheckDefinitions", () => {
it("returns definitions for builtin and user", () => {
// #given
// #when getting definitions
// given
// when getting definitions
const defs = mcp.getMcpCheckDefinitions()
// #then should have 2 definitions
// then should have 2 definitions
expect(defs.length).toBe(2)
expect(defs.every((d) => d.category === "tools")).toBe(true)
expect(defs.map((d) => d.id)).toContain("mcp-builtin")
src/cli/doctor/checks/model-resolution.test.ts
+19 -19
View File
@@ -2,16 +2,16 @@ import { describe, it, expect, beforeEach, afterEach, spyOn, mock } from "bun:te
describe("model-resolution check", () => {
describe("getModelResolutionInfo", () => {
// #given: Model requirements are defined in model-requirements.ts
// #when: Getting model resolution info
// #then: Returns info for all agents and categories with their provider chains
// given: Model requirements are defined in model-requirements.ts
// when: Getting model resolution info
// then: Returns info for all agents and categories with their provider chains
it("returns agent requirements with provider chains", async () => {
const { getModelResolutionInfo } = await import("./model-resolution")
const info = getModelResolutionInfo()
// #then: Should have agent entries
// then: Should have agent entries
const sisyphus = info.agents.find((a) => a.name === "sisyphus")
expect(sisyphus).toBeDefined()
expect(sisyphus!.requirement.fallbackChain[0]?.model).toBe("claude-opus-4-5")
@@ -24,7 +24,7 @@ describe("model-resolution check", () => {
const info = getModelResolutionInfo()
// #then: Should have category entries
// then: Should have category entries
const visual = info.categories.find((c) => c.name === "visual-engineering")
expect(visual).toBeDefined()
expect(visual!.requirement.fallbackChain[0]?.model).toBe("gemini-3-pro")
@@ -33,14 +33,14 @@ describe("model-resolution check", () => {
})
describe("getModelResolutionInfoWithOverrides", () => {
// #given: User has overrides in oh-my-opencode.json
// #when: Getting resolution info with config
// #then: Shows user override in Step 1 position
// given: User has overrides in oh-my-opencode.json
// when: Getting resolution info with config
// then: Shows user override in Step 1 position
it("shows user override for agent when configured", async () => {
const { getModelResolutionInfoWithOverrides } = await import("./model-resolution")
// #given: User has override for oracle agent
// given: User has override for oracle agent
const mockConfig = {
agents: {
oracle: { model: "anthropic/claude-opus-4-5" },
@@ -49,7 +49,7 @@ describe("model-resolution check", () => {
const info = getModelResolutionInfoWithOverrides(mockConfig)
// #then: Oracle should show the override
// then: Oracle should show the override
const oracle = info.agents.find((a) => a.name === "oracle")
expect(oracle).toBeDefined()
expect(oracle!.userOverride).toBe("anthropic/claude-opus-4-5")
@@ -59,7 +59,7 @@ describe("model-resolution check", () => {
it("shows user override for category when configured", async () => {
const { getModelResolutionInfoWithOverrides } = await import("./model-resolution")
// #given: User has override for visual-engineering category
// given: User has override for visual-engineering category
const mockConfig = {
categories: {
"visual-engineering": { model: "openai/gpt-5.2" },
@@ -68,7 +68,7 @@ describe("model-resolution check", () => {
const info = getModelResolutionInfoWithOverrides(mockConfig)
// #then: visual-engineering should show the override
// then: visual-engineering should show the override
const visual = info.categories.find((c) => c.name === "visual-engineering")
expect(visual).toBeDefined()
expect(visual!.userOverride).toBe("openai/gpt-5.2")
@@ -78,12 +78,12 @@ describe("model-resolution check", () => {
it("shows provider fallback when no override exists", async () => {
const { getModelResolutionInfoWithOverrides } = await import("./model-resolution")
// #given: No overrides configured
// given: No overrides configured
const mockConfig = {}
const info = getModelResolutionInfoWithOverrides(mockConfig)
// #then: Should show provider fallback chain
// then: Should show provider fallback chain
const sisyphus = info.agents.find((a) => a.name === "sisyphus")
expect(sisyphus).toBeDefined()
expect(sisyphus!.userOverride).toBeUndefined()
@@ -93,16 +93,16 @@ describe("model-resolution check", () => {
})
describe("checkModelResolution", () => {
// #given: Doctor check is executed
// #when: Running the model resolution check
// #then: Returns pass with details showing resolution flow
// given: Doctor check is executed
// when: Running the model resolution check
// then: Returns pass with details showing resolution flow
it("returns pass or warn status with agent and category counts", async () => {
const { checkModelResolution } = await import("./model-resolution")
const result = await checkModelResolution()
// #then: Should pass (with cache) or warn (no cache) and show counts
// then: Should pass (with cache) or warn (no cache) and show counts
// In CI without model cache, status is "warn"; locally with cache, status is "pass"
expect(["pass", "warn"]).toContain(result.status)
expect(result.message).toMatch(/\d+ agents?, \d+ categories?/)
@@ -113,7 +113,7 @@ describe("model-resolution check", () => {
const result = await checkModelResolution()
// #then: Details should contain agent/category resolution info
// then: Details should contain agent/category resolution info
expect(result.details).toBeDefined()
expect(result.details!.length).toBeGreaterThan(0)
// Should have Available Models and Configured Models headers
src/cli/doctor/checks/opencode.test.ts
+51 -51
View File
@@ -5,106 +5,106 @@ import { MIN_OPENCODE_VERSION } from "../constants"
describe("opencode check", () => {
describe("compareVersions", () => {
it("returns true when current >= minimum", () => {
// #given versions where current is greater
// #when comparing
// #then should return true
// given versions where current is greater
// when comparing
// then should return true
expect(opencode.compareVersions("1.0.200", "1.0.150")).toBe(true)
expect(opencode.compareVersions("1.1.0", "1.0.150")).toBe(true)
expect(opencode.compareVersions("2.0.0", "1.0.150")).toBe(true)
})
it("returns true when versions are equal", () => {
// #given equal versions
// #when comparing
// #then should return true
// given equal versions
// when comparing
// then should return true
expect(opencode.compareVersions("1.0.150", "1.0.150")).toBe(true)
})
it("returns false when current < minimum", () => {
// #given version below minimum
// #when comparing
// #then should return false
// given version below minimum
// when comparing
// then should return false
expect(opencode.compareVersions("1.0.100", "1.0.150")).toBe(false)
expect(opencode.compareVersions("0.9.0", "1.0.150")).toBe(false)
})
it("handles version prefixes", () => {
// #given version with v prefix
// #when comparing
// #then should strip prefix and compare correctly
// given version with v prefix
// when comparing
// then should strip prefix and compare correctly
expect(opencode.compareVersions("v1.0.200", "1.0.150")).toBe(true)
})
it("handles prerelease versions", () => {
// #given prerelease version
// #when comparing
// #then should use base version
// given prerelease version
// when comparing
// then should use base version
expect(opencode.compareVersions("1.0.200-beta.1", "1.0.150")).toBe(true)
})
})
describe("command helpers", () => {
it("selects where on Windows", () => {
// #given win32 platform
// #when selecting lookup command
// #then should use where
// given win32 platform
// when selecting lookup command
// then should use where
expect(opencode.getBinaryLookupCommand("win32")).toBe("where")
})
it("selects which on non-Windows", () => {
// #given linux platform
// #when selecting lookup command
// #then should use which
// given linux platform
// when selecting lookup command
// then should use which
expect(opencode.getBinaryLookupCommand("linux")).toBe("which")
expect(opencode.getBinaryLookupCommand("darwin")).toBe("which")
})
it("parses command output into paths", () => {
// #given raw output with multiple lines and spaces
// given raw output with multiple lines and spaces
const output = "C:\\\\bin\\\\opencode.ps1\r\nC:\\\\bin\\\\opencode.exe\n\n"
// #when parsing
// when parsing
const paths = opencode.parseBinaryPaths(output)
// #then should return trimmed, non-empty paths
// then should return trimmed, non-empty paths
expect(paths).toEqual(["C:\\\\bin\\\\opencode.ps1", "C:\\\\bin\\\\opencode.exe"])
})
it("prefers exe/cmd/bat over ps1 on Windows", () => {
// #given windows paths
// given windows paths
const paths = [
"C:\\\\bin\\\\opencode.ps1",
"C:\\\\bin\\\\opencode.cmd",
"C:\\\\bin\\\\opencode.exe",
]
// #when selecting binary
// when selecting binary
const selected = opencode.selectBinaryPath(paths, "win32")
// #then should prefer exe
// then should prefer exe
expect(selected).toBe("C:\\\\bin\\\\opencode.exe")
})
it("falls back to ps1 when it is the only Windows candidate", () => {
// #given only ps1 path
// given only ps1 path
const paths = ["C:\\\\bin\\\\opencode.ps1"]
// #when selecting binary
// when selecting binary
const selected = opencode.selectBinaryPath(paths, "win32")
// #then should return ps1 path
// then should return ps1 path
expect(selected).toBe("C:\\\\bin\\\\opencode.ps1")
})
it("builds PowerShell command for ps1 on Windows", () => {
// #given a ps1 path on Windows
// given a ps1 path on Windows
const command = opencode.buildVersionCommand(
"C:\\\\bin\\\\opencode.ps1",
"win32"
)
// #when building command
// #then should use PowerShell
// when building command
// then should use PowerShell
expect(command).toEqual([
"powershell",
"-NoProfile",
@@ -117,15 +117,15 @@ describe("opencode check", () => {
})
it("builds direct command for non-ps1 binaries", () => {
// #given an exe on Windows and a binary on linux
// given an exe on Windows and a binary on linux
const winCommand = opencode.buildVersionCommand(
"C:\\\\bin\\\\opencode.exe",
"win32"
)
const linuxCommand = opencode.buildVersionCommand("opencode", "linux")
// #when building commands
// #then should execute directly
// when building commands
// then should execute directly
expect(winCommand).toEqual(["C:\\\\bin\\\\opencode.exe", "--version"])
expect(linuxCommand).toEqual(["opencode", "--version"])
})
@@ -133,13 +133,13 @@ describe("opencode check", () => {
describe("getOpenCodeInfo", () => {
it("returns installed: false when binary not found", async () => {
// #given no opencode binary
// given no opencode binary
const spy = spyOn(opencode, "findOpenCodeBinary").mockResolvedValue(null)
// #when getting info
// when getting info
const info = await opencode.getOpenCodeInfo()
// #then should indicate not installed
// then should indicate not installed
expect(info.installed).toBe(false)
expect(info.version).toBeNull()
expect(info.path).toBeNull()
@@ -157,7 +157,7 @@ describe("opencode check", () => {
})
it("returns fail when not installed", async () => {
// #given opencode not installed
// given opencode not installed
getInfoSpy = spyOn(opencode, "getOpenCodeInfo").mockResolvedValue({
installed: false,
version: null,
@@ -165,10 +165,10 @@ describe("opencode check", () => {
binary: null,
})
// #when checking installation
// when checking installation
const result = await opencode.checkOpenCodeInstallation()
// #then should fail with installation hint
// then should fail with installation hint
expect(result.status).toBe("fail")
expect(result.message).toContain("not installed")
expect(result.details).toBeDefined()
@@ -176,7 +176,7 @@ describe("opencode check", () => {
})
it("returns warn when version below minimum", async () => {
// #given old version installed
// given old version installed
getInfoSpy = spyOn(opencode, "getOpenCodeInfo").mockResolvedValue({
installed: true,
version: "1.0.100",
@@ -184,17 +184,17 @@ describe("opencode check", () => {
binary: "opencode",
})
// #when checking installation
// when checking installation
const result = await opencode.checkOpenCodeInstallation()
// #then should warn about old version
// then should warn about old version
expect(result.status).toBe("warn")
expect(result.message).toContain("below minimum")
expect(result.details?.some((d) => d.includes(MIN_OPENCODE_VERSION))).toBe(true)
})
it("returns pass when properly installed", async () => {
// #given current version installed
// given current version installed
getInfoSpy = spyOn(opencode, "getOpenCodeInfo").mockResolvedValue({
installed: true,
version: "1.0.200",
@@ -202,10 +202,10 @@ describe("opencode check", () => {
binary: "opencode",
})
// #when checking installation
// when checking installation
const result = await opencode.checkOpenCodeInstallation()
// #then should pass
// then should pass
expect(result.status).toBe("pass")
expect(result.message).toContain("1.0.200")
})
@@ -213,11 +213,11 @@ describe("opencode check", () => {
describe("getOpenCodeCheckDefinition", () => {
it("returns valid check definition", () => {
// #given
// #when getting definition
// given
// when getting definition
const def = opencode.getOpenCodeCheckDefinition()
// #then should have required properties
// then should have required properties
expect(def.id).toBe("opencode-installation")
expect(def.category).toBe("installation")
expect(def.critical).toBe(true)
src/cli/doctor/checks/plugin.test.ts
+18 -18
View File
@@ -4,9 +4,9 @@ import * as plugin from "./plugin"
describe("plugin check", () => {
describe("getPluginInfo", () => {
it("returns registered: false when config not found", () => {
// #given no config file exists
// #when getting plugin info
// #then should indicate not registered
// given no config file exists
// when getting plugin info
// then should indicate not registered
const info = plugin.getPluginInfo()
expect(typeof info.registered).toBe("boolean")
expect(typeof info.isPinned).toBe("boolean")
@@ -21,7 +21,7 @@ describe("plugin check", () => {
})
it("returns fail when config file not found", async () => {
// #given no config file
// given no config file
getInfoSpy = spyOn(plugin, "getPluginInfo").mockReturnValue({
registered: false,
configPath: null,
@@ -30,16 +30,16 @@ describe("plugin check", () => {
pinnedVersion: null,
})
// #when checking registration
// when checking registration
const result = await plugin.checkPluginRegistration()
// #then should fail with hint
// then should fail with hint
expect(result.status).toBe("fail")
expect(result.message).toContain("not found")
})
it("returns fail when plugin not registered", async () => {
// #given config exists but plugin not registered
// given config exists but plugin not registered
getInfoSpy = spyOn(plugin, "getPluginInfo").mockReturnValue({
registered: false,
configPath: "/home/user/.config/opencode/opencode.json",
@@ -48,16 +48,16 @@ describe("plugin check", () => {
pinnedVersion: null,
})
// #when checking registration
// when checking registration
const result = await plugin.checkPluginRegistration()
// #then should fail
// then should fail
expect(result.status).toBe("fail")
expect(result.message).toContain("not registered")
})
it("returns pass when plugin registered", async () => {
// #given plugin registered
// given plugin registered
getInfoSpy = spyOn(plugin, "getPluginInfo").mockReturnValue({
registered: true,
configPath: "/home/user/.config/opencode/opencode.json",
@@ -66,16 +66,16 @@ describe("plugin check", () => {
pinnedVersion: null,
})
// #when checking registration
// when checking registration
const result = await plugin.checkPluginRegistration()
// #then should pass
// then should pass
expect(result.status).toBe("pass")
expect(result.message).toContain("Registered")
})
it("indicates pinned version when applicable", async () => {
// #given plugin pinned to version
// given plugin pinned to version
getInfoSpy = spyOn(plugin, "getPluginInfo").mockReturnValue({
registered: true,
configPath: "/home/user/.config/opencode/opencode.json",
@@ -84,10 +84,10 @@ describe("plugin check", () => {
pinnedVersion: "2.7.0",
})
// #when checking registration
// when checking registration
const result = await plugin.checkPluginRegistration()
// #then should show pinned version
// then should show pinned version
expect(result.status).toBe("pass")
expect(result.message).toContain("pinned")
expect(result.message).toContain("2.7.0")
@@ -96,11 +96,11 @@ describe("plugin check", () => {
describe("getPluginCheckDefinition", () => {
it("returns valid check definition", () => {
// #given
// #when getting definition
// given
// when getting definition
const def = plugin.getPluginCheckDefinition()
// #then should have required properties
// then should have required properties
expect(def.id).toBe("plugin-registration")
expect(def.category).toBe("installation")
expect(def.critical).toBe(true)
src/cli/doctor/checks/version.test.ts
+24 -24
View File
@@ -4,11 +4,11 @@ import * as version from "./version"
describe("version check", () => {
describe("getVersionInfo", () => {
it("returns version check info structure", async () => {
// #given
// #when getting version info
// given
// when getting version info
const info = await version.getVersionInfo()
// #then should have expected structure
// then should have expected structure
expect(typeof info.isUpToDate).toBe("boolean")
expect(typeof info.isLocalDev).toBe("boolean")
expect(typeof info.isPinned).toBe("boolean")
@@ -23,7 +23,7 @@ describe("version check", () => {
})
it("returns pass when in local dev mode", async () => {
// #given local dev mode
// given local dev mode
getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
currentVersion: "local-dev",
latestVersion: "2.7.0",
@@ -32,16 +32,16 @@ describe("version check", () => {
isPinned: false,
})
// #when checking
// when checking
const result = await version.checkVersionStatus()
// #then should pass with dev message
// then should pass with dev message
expect(result.status).toBe("pass")
expect(result.message).toContain("local development")
})
it("returns pass when pinned", async () => {
// #given pinned version
// given pinned version
getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
currentVersion: "2.6.0",
latestVersion: "2.7.0",
@@ -50,16 +50,16 @@ describe("version check", () => {
isPinned: true,
})
// #when checking
// when checking
const result = await version.checkVersionStatus()
// #then should pass with pinned message
// then should pass with pinned message
expect(result.status).toBe("pass")
expect(result.message).toContain("Pinned")
})
it("returns warn when unable to determine version", async () => {
// #given no version info
// given no version info
getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
currentVersion: null,
latestVersion: "2.7.0",
@@ -68,16 +68,16 @@ describe("version check", () => {
isPinned: false,
})
// #when checking
// when checking
const result = await version.checkVersionStatus()
// #then should warn
// then should warn
expect(result.status).toBe("warn")
expect(result.message).toContain("Unable to determine")
})
it("returns warn when network error", async () => {
// #given network error
// given network error
getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
currentVersion: "2.6.0",
latestVersion: null,
@@ -86,16 +86,16 @@ describe("version check", () => {
isPinned: false,
})
// #when checking
// when checking
const result = await version.checkVersionStatus()
// #then should warn
// then should warn
expect(result.status).toBe("warn")
expect(result.details?.some((d) => d.includes("network"))).toBe(true)
})
it("returns warn when update available", async () => {
// #given update available
// given update available
getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
currentVersion: "2.6.0",
latestVersion: "2.7.0",
@@ -104,10 +104,10 @@ describe("version check", () => {
isPinned: false,
})
// #when checking
// when checking
const result = await version.checkVersionStatus()
// #then should warn with update info
// then should warn with update info
expect(result.status).toBe("warn")
expect(result.message).toContain("Update available")
expect(result.message).toContain("2.6.0")
@@ -115,7 +115,7 @@ describe("version check", () => {
})
it("returns pass when up to date", async () => {
// #given up to date
// given up to date
getInfoSpy = spyOn(version, "getVersionInfo").mockResolvedValue({
currentVersion: "2.7.0",
latestVersion: "2.7.0",
@@ -124,10 +124,10 @@ describe("version check", () => {
isPinned: false,
})
// #when checking
// when checking
const result = await version.checkVersionStatus()
// #then should pass
// then should pass
expect(result.status).toBe("pass")
expect(result.message).toContain("Up to date")
})
@@ -135,11 +135,11 @@ describe("version check", () => {
describe("getVersionCheckDefinition", () => {
it("returns valid check definition", () => {
// #given
// #when getting definition
// given
// when getting definition
const def = version.getVersionCheckDefinition()
// #then should have required properties
// then should have required properties
expect(def.id).toBe("version-status")
expect(def.category).toBe("updates")
expect(def.critical).toBe(false)