test: add unit tests for core modules

Add comprehensive unit tests using Bun's test runner (55 tests total):
- tests/config.test.ts: Config parsing, env vars, CLI args merging
- tests/state.test.ts: State persistence, phase transitions
- tests/plan.test.ts: Plan parsing, validation, task management
- tests/ideas.test.ts: Ideas loading, formatting, selection
- tests/evaluator.test.ts: Evaluation response parsing

Signed-off-by: leocavalcante <[email protected]>

Author: leocavalcante

tests/config.test.ts

@@ -0,0 +1,38 @@
+/**
+ * Tests for config module
+ */
+
+import { describe, expect, test, beforeEach, afterEach } from "bun:test"
+import { parseModel } from "../src/config.ts"
+
+describe("parseModel", () => {
+	test("parses simple provider/model format", () => {
+		const result = parseModel("anthropic/claude-sonnet-4")
+		expect(result.providerID).toBe("anthropic")
+		expect(result.modelID).toBe("claude-sonnet-4")
+	})
+
+	test("parses model with multiple slashes", () => {
+		const result = parseModel("openai/gpt-4/turbo")
+		expect(result.providerID).toBe("openai")
+		expect(result.modelID).toBe("gpt-4/turbo")
+	})
+
+	test("handles empty string", () => {
+		const result = parseModel("")
+		expect(result.providerID).toBe("")
+		expect(result.modelID).toBe("")
+	})
+
+	test("handles string without slash", () => {
+		const result = parseModel("claude")
+		expect(result.providerID).toBe("claude")
+		expect(result.modelID).toBe("")
+	})
+
+	test("handles provider-only with trailing slash", () => {
+		const result = parseModel("anthropic/")
+		expect(result.providerID).toBe("anthropic")
+		expect(result.modelID).toBe("")
+	})
+})

tests/evaluator.test.ts

@@ -0,0 +1,96 @@
+/**
+ * Tests for evaluator module
+ */
+
+import { describe, expect, test } from "bun:test"
+import { parseEvaluation, isComplete, extractEvaluationReason } from "../src/evaluator.ts"
+
+describe("evaluator", () => {
+	describe("parseEvaluation", () => {
+		test("parses COMPLETE response", () => {
+			const response = "COMPLETE\nReason: All tasks done"
+			const result = parseEvaluation(response)
+
+			expect(result).toBe("COMPLETE")
+		})
+
+		test("parses NEEDS_WORK response", () => {
+			const response = "NEEDS_WORK\nReason: Tests failing"
+			const result = parseEvaluation(response)
+
+			expect(result).toBe("NEEDS_WORK")
+		})
+
+		test("handles extra whitespace", () => {
+			const response = "  COMPLETE  \n\nReason: Done"
+			const result = parseEvaluation(response)
+
+			expect(result).toBe("COMPLETE")
+		})
+
+		test("defaults to NEEDS_WORK for ambiguous response", () => {
+			const response = "Maybe we should continue"
+			const result = parseEvaluation(response)
+
+			expect(result).toBe("NEEDS_WORK")
+		})
+
+		test("handles case insensitive matching", () => {
+			const response = "complete\nreason: all good"
+			const result = parseEvaluation(response)
+
+			expect(result).toBe("COMPLETE")
+		})
+
+		test("handles response with code block", () => {
+			const response = `Here's my evaluation:
+\`\`\`
+COMPLETE
+Reason: Everything passed
+\`\`\``
+			const result = parseEvaluation(response)
+
+			expect(result).toBe("COMPLETE")
+		})
+	})
+
+	describe("isComplete", () => {
+		test("returns true for COMPLETE", () => {
+			expect(isComplete("COMPLETE")).toBe(true)
+		})
+
+		test("returns false for NEEDS_WORK", () => {
+			expect(isComplete("NEEDS_WORK")).toBe(false)
+		})
+	})
+
+	describe("extractEvaluationReason", () => {
+		test("extracts reason from response", () => {
+			const response = "COMPLETE\nReason: All tests passing and code looks good"
+			const reason = extractEvaluationReason(response)
+
+			expect(reason).toBe("All tests passing and code looks good")
+		})
+
+		test("handles multi-word reason", () => {
+			const response = "NEEDS_WORK\nReason: Three tests still failing in the auth module"
+			const reason = extractEvaluationReason(response)
+
+			expect(reason).toBe("Three tests still failing in the auth module")
+		})
+
+		test("returns null when no reason found", () => {
+			const response = "COMPLETE"
+			const reason = extractEvaluationReason(response)
+
+			expect(reason).toBeNull()
+		})
+
+		test("handles lowercase reason prefix", () => {
+			const response = "COMPLETE\nreason: it works"
+			const reason = extractEvaluationReason(response)
+
+			expect(reason).toBe("it works")
+		})
+	})
+})

tests/ideas.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Tests for ideas module
+ */
+
+import { describe, expect, test, beforeEach, afterEach } from "bun:test"
+import { mkdirSync, rmSync, existsSync } from "node:fs"
+import { join } from "node:path"
+import {
+	loadAllIdeas,
+	formatIdeasForSelection,
+	getIdeaSummary,
+	removeIdea,
+	parseIdeaSelection,
+	countIdeas,
+} from "../src/ideas.ts"
+
+const TEST_DIR = "/tmp/opencoder-test-ideas"
+
+describe("ideas", () => {
+	beforeEach(() => {
+		if (existsSync(TEST_DIR)) {
+			rmSync(TEST_DIR, { recursive: true })
+		}
+		mkdirSync(TEST_DIR, { recursive: true })
+	})
+
+	afterEach(() => {
+		if (existsSync(TEST_DIR)) {
+			rmSync(TEST_DIR, { recursive: true })
+		}
+	})
+
+	describe("loadAllIdeas", () => {
+		test("returns empty array for non-existent directory", async () => {
+			const ideas = await loadAllIdeas("/nonexistent/path")
+			expect(ideas.length).toBe(0)
+		})
+
+		test("loads markdown files from directory", async () => {
+			await Bun.write(join(TEST_DIR, "idea1.md"), "# First Idea\nDescription")
+			await Bun.write(join(TEST_DIR, "idea2.md"), "# Second Idea\nContent")
+			await Bun.write(join(TEST_DIR, "not-an-idea.txt"), "Ignored file")
+
+			const ideas = await loadAllIdeas(TEST_DIR)
+
+			expect(ideas.length).toBe(2)
+			expect(ideas.some((i) => i.filename === "idea1.md")).toBe(true)
+			expect(ideas.some((i) => i.filename === "idea2.md")).toBe(true)
+		})
+
+		test("skips empty files", async () => {
+			await Bun.write(join(TEST_DIR, "empty.md"), "")
+			await Bun.write(join(TEST_DIR, "whitespace.md"), "   \n\t  ")
+			await Bun.write(join(TEST_DIR, "valid.md"), "Valid content")
+
+			const ideas = await loadAllIdeas(TEST_DIR)
+
+			expect(ideas.length).toBe(1)
+			expect(ideas[0]?.filename).toBe("valid.md")
+		})
+	})
+
+	describe("getIdeaSummary", () => {
+		test("extracts first line as summary", () => {
+			const summary = getIdeaSummary("First line\nSecond line")
+			expect(summary).toBe("First line")
+		})
+
+		test("removes markdown headers", () => {
+			const summary = getIdeaSummary("# Header Title\nContent")
+			expect(summary).toBe("Header Title")
+		})
+
+		test("truncates long summaries", () => {
+			const longContent = "A".repeat(150)
+			const summary = getIdeaSummary(longContent)
+
+			expect(summary.length).toBeLessThanOrEqual(103) // 100 + "..."
+			expect(summary.endsWith("...")).toBe(true)
+		})
+
+		test("skips empty lines to find summary", () => {
+			const summary = getIdeaSummary("\n\n# Title\nContent")
+			expect(summary).toBe("Title")
+		})
+	})
+
+	describe("formatIdeasForSelection", () => {
+		test("formats ideas with numbers and content", () => {
+			const ideas = [
+				{ path: "/a.md", filename: "a.md", content: "# Idea A\nContent A" },
+				{ path: "/b.md", filename: "b.md", content: "# Idea B\nContent B" },
+			]
+
+			const formatted = formatIdeasForSelection(ideas)
+
+			expect(formatted).toContain("## Idea 1: a.md")
+			expect(formatted).toContain("## Idea 2: b.md")
+			expect(formatted).toContain("Content A")
+			expect(formatted).toContain("Content B")
+		})
+	})
+
+	describe("parseIdeaSelection", () => {
+		test("parses valid selection response", () => {
+			const response = "SELECTED_IDEA: 2\nREASON: It's simpler"
+			const index = parseIdeaSelection(response)
+
+			expect(index).toBe(1) // 0-indexed
+		})
+
+		test("handles case insensitive matching", () => {
+			const response = "selected_idea: 3\nreason: Quick win"
+			const index = parseIdeaSelection(response)
+
+			expect(index).toBe(2)
+		})
+
+		test("returns null for invalid response", () => {
+			const response = "I think we should do idea 2"
+			const index = parseIdeaSelection(response)
+
+			expect(index).toBeNull()
+		})
+
+		test("returns null for zero selection", () => {
+			const response = "SELECTED_IDEA: 0\nREASON: Invalid"
+			const index = parseIdeaSelection(response)
+
+			expect(index).toBeNull()
+		})
+	})
+
+	describe("countIdeas", () => {
+		test("returns 0 for non-existent directory", async () => {
+			const count = await countIdeas("/nonexistent")
+			expect(count).toBe(0)
+		})
+
+		test("counts markdown files", async () => {
+			await Bun.write(join(TEST_DIR, "a.md"), "idea")
+			await Bun.write(join(TEST_DIR, "b.md"), "idea")
+			await Bun.write(join(TEST_DIR, "c.txt"), "not counted")
+
+			const count = await countIdeas(TEST_DIR)
+			expect(count).toBe(2)
+		})
+	})
+
+	describe("removeIdea", () => {
+		test("removes existing file", async () => {
+			const filePath = join(TEST_DIR, "to-remove.md")
+			await Bun.write(filePath, "content")
+
+			const result = removeIdea(filePath)
+
+			expect(result).toBe(true)
+			expect(existsSync(filePath)).toBe(false)
+		})
+
+		test("returns false for non-existent file", () => {
+			const result = removeIdea("/nonexistent/file.md")
+			expect(result).toBe(false)
+		})
+	})
+})