feat: rewrite in TypeScript with OpenCode SDK

Complete rewrite of Opencoder from Zig to TypeScript using Bun runtime
and @opencode-ai/sdk for the autonomous development loop.

Source modules:
- index.ts: Entry point
- cli.ts: CLI argument parsing with commander
- config.ts: Configuration loading (file + env + CLI merge)
- types.ts: TypeScript interfaces and types
- state.ts: State persistence (JSON)
- fs.ts: File system utilities
- logger.ts: Logging with live output streaming
- plan.ts: Plan parsing, validation, prompt generation
- ideas.ts: Ideas queue management, selection logic
- builder.ts: OpenCode SDK wrapper with event streaming
- evaluator.ts: Evaluation response parsing
- loop.ts: Main autonomous loop

Features:
- Three-phase loop: planning, build, evaluation
- Ideas queue for user-specified tasks
- Resumable state persistence
- Live streaming output in verbose mode

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

Author: leocavalcante

src/builder.ts

@@ -0,0 +1,86 @@
+/**
+ * CLI argument parsing and program setup
+ */
+
+import { Command } from "commander"
+import { loadConfig } from "./config.ts"
+import { runLoop } from "./loop.ts"
+import type { CliOptions } from "./types.ts"
+
+const VERSION = "1.0.0"
+
+/**
+ * Parse CLI arguments and run the application
+ */
+export async function run(): Promise<void> {
+	const program = new Command()
+
+	program
+		.name("opencoder")
+		.description("Autonomous development loop powered by OpenCode")
+		.version(VERSION)
+		.argument("[hint]", "Optional hint/instruction for the AI")
+		.option("-p, --project <dir>", "Project directory (default: current directory)")
+		.option("-m, --model <model>", "Model for both planning and build (provider/model format)")
+		.option("-P, --planning-model <model>", "Model for planning phase (provider/model format)")
+		.option("-B, --build-model <model>", "Model for build phase (provider/model format)")
+		.option("-v, --verbose", "Enable verbose logging")
+		.action(async (hint: string | undefined, opts: Record<string, unknown>) => {
+			try {
+				const cliOptions: CliOptions = {
+					project: opts.project as string | undefined,
+					model: opts.model as string | undefined,
+					planningModel: opts.planningModel as string | undefined,
+					buildModel: opts.buildModel as string | undefined,
+					verbose: opts.verbose as boolean | undefined,
+				}
+
+				const config = await loadConfig(cliOptions, hint)
+				await runLoop(config)
+			} catch (err) {
+				console.error(`Error: ${err instanceof Error ? err.message : String(err)}`)
+				process.exit(1)
+			}
+		})
+
+	// Add examples to help
+	program.addHelpText(
+		"after",
+		`
+Examples:
+  $ opencoder --model anthropic/claude-sonnet-4
+    Run with Claude Sonnet for both planning and build
+
+  $ opencoder -m anthropic/claude-sonnet-4 "build a REST API"
+    Run with a specific hint/instruction
+
+  $ opencoder -P anthropic/claude-opus-4 -B anthropic/claude-sonnet-4
+    Use different models for planning and build
+
+  $ opencoder -m openai/gpt-4o -p ./myproject -v
+    Run with verbose logging in a specific directory
+
+Options:
+    -p, --project <dir>         Project directory (default: current directory)
+    -m, --model <model>         Model for both planning and build
+    -P, --planning-model        Model for planning phase
+    -B, --build-model           Model for build phase
+    -v, --verbose               Enable verbose logging
+
+Environment variables:
+    OPENCODER_PLANNING_MODEL    Default planning model
+    OPENCODER_BUILD_MODEL       Default build model
+    OPENCODER_VERBOSE           Enable verbose logging (true/1)
+    OPENCODER_PROJECT_DIR       Default project directory
+
+Config file (opencoder.json):
+    {
+      "planningModel": "anthropic/claude-sonnet-4",
+      "buildModel": "anthropic/claude-sonnet-4",
+      "verbose": false
+    }
+`,
+	)
+
+	await program.parseAsync()
+}

src/cli.ts

@@ -0,0 +1,212 @@
+/**
+ * Configuration loading and management
+ *
+ * Priority (lowest to highest):
+ * 1. Defaults
+ * 2. opencoder.json in project directory
+ * 3. Environment variables
+ * 4. CLI arguments
+ */
+
+import { existsSync } from "node:fs"
+import { readFile } from "node:fs/promises"
+import { resolve } from "node:path"
+import type { CliOptions, Config, ConfigFile } from "./types.ts"
+
+/** Default configuration values */
+const DEFAULTS: Omit<Config, "planningModel" | "buildModel" | "projectDir"> = {
+	verbose: false,
+	maxRetries: 3,
+	backoffBase: 10,
+	logRetention: 30,
+	taskPauseSeconds: 2,
+}
+
+/** Environment variable prefix */
+const ENV_PREFIX = "OPENCODER_"
+
+/**
+ * Load configuration from all sources and merge them
+ */
+export async function loadConfig(cliOptions: CliOptions, hint?: string): Promise<Config> {
+	// Start with defaults
+	const projectDir = resolveProjectDir(cliOptions.project)
+
+	// Load config file if it exists
+	const fileConfig = await loadConfigFile(projectDir)
+
+	// Load environment variables
+	const envConfig = loadEnvConfig()
+
+	// Merge CLI options
+	const cliConfig = {
+		planningModel: cliOptions.planningModel || cliOptions.model,
+		buildModel: cliOptions.buildModel || cliOptions.model,
+		verbose: cliOptions.verbose,
+	}
+
+	// Merge all sources (later sources override earlier ones)
+	const config: Config = {
+		...DEFAULTS,
+		projectDir,
+		planningModel: "",
+		buildModel: "",
+		...fileConfig,
+		...envConfig,
+		...filterUndefined(cliConfig),
+		userHint: hint,
+	}
+
+	// Validate required fields
+	validateConfig(config)
+
+	return config
+}
+
+/**
+ * Resolve the project directory
+ */
+function resolveProjectDir(cliProject?: string): string {
+	if (cliProject) {
+		return resolve(cliProject)
+	}
+
+	const envProject = process.env[`${ENV_PREFIX}PROJECT_DIR`]
+	if (envProject) {
+		return resolve(envProject)
+	}
+
+	return process.cwd()
+}
+
+/**
+ * Load configuration from opencoder.json file
+ */
+async function loadConfigFile(projectDir: string): Promise<Partial<Config>> {
+	const configPath = resolve(projectDir, "opencoder.json")
+
+	if (!existsSync(configPath)) {
+		return {}
+	}
+
+	try {
+		const content = await readFile(configPath, "utf-8")
+		const parsed = JSON.parse(content) as ConfigFile
+
+		return {
+			planningModel: parsed.planningModel,
+			buildModel: parsed.buildModel,
+			verbose: parsed.verbose,
+			maxRetries: parsed.maxRetries,
+			backoffBase: parsed.backoffBase,
+			logRetention: parsed.logRetention,
+			taskPauseSeconds: parsed.taskPauseSeconds,
+		}
+	} catch (err) {
+		console.warn(`Warning: Failed to parse opencoder.json: ${err}`)
+		return {}
+	}
+}
+
+/**
+ * Load configuration from environment variables
+ */
+function loadEnvConfig(): Partial<Config> {
+	const config: Partial<Config> = {}
+
+	const planningModel = process.env[`${ENV_PREFIX}PLANNING_MODEL`]
+	if (planningModel) config.planningModel = planningModel
+
+	const buildModel = process.env[`${ENV_PREFIX}BUILD_MODEL`]
+	if (buildModel) config.buildModel = buildModel
+
+	const verbose = process.env[`${ENV_PREFIX}VERBOSE`]
+	if (verbose) config.verbose = verbose === "true" || verbose === "1"
+
+	const maxRetries = process.env[`${ENV_PREFIX}MAX_RETRIES`]
+	if (maxRetries) {
+		const parsed = Number.parseInt(maxRetries, 10)
+		if (!Number.isNaN(parsed)) config.maxRetries = parsed
+	}
+
+	const backoffBase = process.env[`${ENV_PREFIX}BACKOFF_BASE`]
+	if (backoffBase) {
+		const parsed = Number.parseInt(backoffBase, 10)
+		if (!Number.isNaN(parsed)) config.backoffBase = parsed
+	}
+
+	const logRetention = process.env[`${ENV_PREFIX}LOG_RETENTION`]
+	if (logRetention) {
+		const parsed = Number.parseInt(logRetention, 10)
+		if (!Number.isNaN(parsed)) config.logRetention = parsed
+	}
+
+	const taskPause = process.env[`${ENV_PREFIX}TASK_PAUSE_SECONDS`]
+	if (taskPause) {
+		const parsed = Number.parseInt(taskPause, 10)
+		if (!Number.isNaN(parsed)) config.taskPauseSeconds = parsed
+	}
+
+	return config
+}
+
+/**
+ * Validate configuration has all required fields
+ */
+function validateConfig(config: Config): void {
+	if (!config.planningModel) {
+		throw new Error(
+			"Missing planning model. Provide via --model, --planning-model, opencoder.json, or OPENCODER_PLANNING_MODEL env var.",
+		)
+	}
+
+	if (!config.buildModel) {
+		throw new Error(
+			"Missing build model. Provide via --model, --build-model, opencoder.json, or OPENCODER_BUILD_MODEL env var.",
+		)
+	}
+
+	// Validate model format (should be provider/model)
+	if (!isValidModelFormat(config.planningModel)) {
+		throw new Error(
+			`Invalid planning model format: ${config.planningModel}. Expected format: provider/model`,
+		)
+	}
+
+	if (!isValidModelFormat(config.buildModel)) {
+		throw new Error(
+			`Invalid build model format: ${config.buildModel}. Expected format: provider/model`,
+		)
+	}
+
+	// Validate project directory exists
+	if (!existsSync(config.projectDir)) {
+		throw new Error(`Project directory does not exist: ${config.projectDir}`)
+	}
+}
+
+/**
+ * Check if model string has valid format (provider/model)
+ */
+function isValidModelFormat(model: string): boolean {
+	const parts = model.split("/")
+	return parts.length >= 2 && (parts[0]?.length ?? 0) > 0 && (parts[1]?.length ?? 0) > 0
+}
+
+/**
+ * Filter out undefined values from an object
+ */
+function filterUndefined<T extends object>(obj: T): Partial<T> {
+	return Object.fromEntries(Object.entries(obj).filter(([_, v]) => v !== undefined)) as Partial<T>
+}
+
+/**
+ * Parse a model string into provider and model ID
+ */
+export function parseModel(model: string): { providerID: string; modelID: string } {
+	const [providerID, ...rest] = model.split("/")
+	return {
+		providerID: providerID ?? "",
+		modelID: rest.join("/"),
+	}
+}

src/config.ts

@@ -0,0 +1,70 @@
+/**
+ * Plan evaluation response parsing
+ */
+
+import type { EvaluationResult } from "./types.ts"
+
+/**
+ * Parse evaluation response from the AI
+ *
+ * Expected formats:
+ * - COMPLETE\nReason: ...
+ * - NEEDS_WORK\nReason: ...
+ */
+export function parseEvaluation(response: string): EvaluationResult {
+	const trimmed = response.trim().toUpperCase()
+
+	// Check for COMPLETE
+	if (trimmed.startsWith("COMPLETE") || trimmed.includes("\nCOMPLETE")) {
+		return "COMPLETE"
+	}
+
+	// Check for NEEDS_WORK
+	if (trimmed.startsWith("NEEDS_WORK") || trimmed.includes("\nNEEDS_WORK")) {
+		return "NEEDS_WORK"
+	}
+
+	// Check within code blocks
+	const codeBlockMatch = response.match(/```[\s\S]*?(COMPLETE|NEEDS_WORK)[\s\S]*?```/i)
+	if (codeBlockMatch?.[1]) {
+		return codeBlockMatch[1].toUpperCase() === "COMPLETE" ? "COMPLETE" : "NEEDS_WORK"
+	}
+
+	// Default to NEEDS_WORK if unclear
+	return "NEEDS_WORK"
+}
+
+/**
+ * Extract the reason from an evaluation response
+ */
+export function extractEvaluationReason(response: string): string | null {
+	// Look for Reason: pattern
+	const reasonMatch = response.match(/Reason:\s*(.+?)(?:\n|$)/i)
+	if (reasonMatch?.[1]) {
+		return reasonMatch[1].trim()
+	}
+
+	// Look for reason in a code block
+	const codeBlockMatch = response.match(
+		/```[\s\S]*?(?:COMPLETE|NEEDS_WORK)\s*\n\s*Reason:\s*(.+?)(?:\n|```)[\s\S]*?```/i,
+	)
+	if (codeBlockMatch?.[1]) {
+		return codeBlockMatch[1].trim()
+	}
+
+	return null
+}
+
+/**
+ * Check if evaluation indicates cycle is complete
+ */
+export function isComplete(result: EvaluationResult): boolean {
+	return result === "COMPLETE"
+}
+
+/**
+ * Check if evaluation indicates more work is needed
+ */
+export function needsWork(result: EvaluationResult): boolean {
+	return result === "NEEDS_WORK"
+}