@kodrunhq/opencode-autopilot 0.1.0

package/src/config.ts

@@ -0,0 +1,168 @@
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { fallbackConfigSchema, fallbackDefaults } from "./orchestrator/fallback/fallback-config";
+import { ensureDir, isEnoentError } from "./utils/fs-helpers";
+import { getGlobalConfigDir } from "./utils/paths";
+
+// --- V1 schema (internal, for migration) ---
+
+const pluginConfigSchemaV1 = z.object({
+	version: z.literal(1),
+	configured: z.boolean(),
+	models: z.record(z.string(), z.string()),
+});
+
+type PluginConfigV1 = z.infer<typeof pluginConfigSchemaV1>;
+
+// --- V2 sub-schemas ---
+
+const phasesConfigSchema = z.object({
+	recon: z.boolean().default(true),
+	challenge: z.boolean().default(true),
+	architect: z.boolean().default(true),
+	explore: z.boolean().default(true),
+	plan: z.boolean().default(true),
+	build: z.boolean().default(true),
+	ship: z.boolean().default(true),
+	retrospective: z.boolean().default(true),
+});
+
+const thresholdsConfigSchema = z.object({
+	proceed: z.enum(["HIGH", "MEDIUM", "LOW"]).default("MEDIUM"),
+	abort: z.enum(["HIGH", "MEDIUM", "LOW"]).default("LOW"),
+});
+
+export const orchestratorConfigSchema = z.object({
+	autonomy: z.enum(["full", "supervised", "manual"]).default("full"),
+	strictness: z.enum(["strict", "normal", "lenient"]).default("normal"),
+	phases: phasesConfigSchema.default(phasesConfigSchema.parse({})),
+});
+
+export const confidenceConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	thresholds: thresholdsConfigSchema.default(thresholdsConfigSchema.parse({})),
+});
+
+// Pre-compute full defaults for nested schema defaults
+const orchestratorDefaults = orchestratorConfigSchema.parse({});
+const confidenceDefaults = confidenceConfigSchema.parse({});
+
+// --- V2 schema (internal, for migration) ---
+
+const pluginConfigSchemaV2 = z.object({
+	version: z.literal(2),
+	configured: z.boolean(),
+	models: z.record(z.string(), z.string()),
+	orchestrator: orchestratorConfigSchema.default(orchestratorDefaults),
+	confidence: confidenceConfigSchema.default(confidenceDefaults),
+});
+
+type PluginConfigV2 = z.infer<typeof pluginConfigSchemaV2>;
+
+// --- V3 schema ---
+
+const pluginConfigSchemaV3 = z.object({
+	version: z.literal(3),
+	configured: z.boolean(),
+	models: z.record(z.string(), z.string()),
+	orchestrator: orchestratorConfigSchema.default(orchestratorDefaults),
+	confidence: confidenceConfigSchema.default(confidenceDefaults),
+	fallback: fallbackConfigSchema.default(fallbackDefaults),
+	fallback_models: z.union([z.string(), z.array(z.string())]).optional(),
+});
+
+// Export pluginConfigSchema as alias for v3 (preserves import compatibility)
+export const pluginConfigSchema = pluginConfigSchemaV3;
+
+export type PluginConfig = z.infer<typeof pluginConfigSchemaV3>;
+
+export const CONFIG_PATH = join(getGlobalConfigDir(), "opencode-autopilot.json");
+
+// --- Migration ---
+
+function migrateV1toV2(v1Config: PluginConfigV1): PluginConfigV2 {
+	return {
+		version: 2 as const,
+		configured: v1Config.configured,
+		models: v1Config.models,
+		orchestrator: orchestratorDefaults,
+		confidence: confidenceDefaults,
+	};
+}
+
+function migrateV2toV3(v2Config: PluginConfigV2): PluginConfig {
+	return {
+		version: 3 as const,
+		configured: v2Config.configured,
+		models: v2Config.models,
+		orchestrator: v2Config.orchestrator,
+		confidence: v2Config.confidence,
+		fallback: fallbackDefaults,
+	};
+}
+
+// --- Public API ---
+
+export async function loadConfig(configPath: string = CONFIG_PATH): Promise<PluginConfig | null> {
+	try {
+		const raw = await readFile(configPath, "utf-8");
+		const parsed = JSON.parse(raw);
+
+		// Try v3 first
+		const v3Result = pluginConfigSchemaV3.safeParse(parsed);
+		if (v3Result.success) {
+			return v3Result.data;
+		}
+
+		// Try v2 and migrate to v3
+		const v2Result = pluginConfigSchemaV2.safeParse(parsed);
+		if (v2Result.success) {
+			const migrated = migrateV2toV3(v2Result.data);
+			await saveConfig(migrated, configPath);
+			return migrated;
+		}
+
+		// Try v1 and double-migrate v1->v2->v3
+		const v1Result = pluginConfigSchemaV1.safeParse(parsed);
+		if (v1Result.success) {
+			const v2 = migrateV1toV2(v1Result.data);
+			const migrated = migrateV2toV3(v2);
+			await saveConfig(migrated, configPath);
+			return migrated;
+		}
+
+		// None matched -- force v3 parse to get proper error
+		return pluginConfigSchemaV3.parse(parsed);
+	} catch (error: unknown) {
+		if (isEnoentError(error)) {
+			return null;
+		}
+		throw error;
+	}
+}
+
+export async function saveConfig(
+	config: PluginConfig,
+	configPath: string = CONFIG_PATH,
+): Promise<void> {
+	await ensureDir(dirname(configPath));
+	const tmpPath = `${configPath}.tmp.${Date.now()}`;
+	await writeFile(tmpPath, JSON.stringify(config, null, 2), "utf-8");
+	await rename(tmpPath, configPath);
+}
+
+export function isFirstLoad(config: PluginConfig | null): boolean {
+	return config === null || !config.configured;
+}
+
+export function createDefaultConfig(): PluginConfig {
+	return {
+		version: 3 as const,
+		configured: false,
+		models: {},
+		orchestrator: orchestratorDefaults,
+		confidence: confidenceDefaults,
+		fallback: fallbackDefaults,
+	};
+}

package/src/index.ts

@@ -0,0 +1,152 @@
+import type { Config, Plugin } from "@opencode-ai/plugin";
+import { configHook } from "./agents";
+import { isFirstLoad, loadConfig } from "./config";
+import { installAssets } from "./installer";
+import type { SdkOperations } from "./orchestrator/fallback";
+import {
+	createChatMessageHandler,
+	createEventHandler,
+	createToolExecuteAfterHandler,
+	FallbackManager,
+} from "./orchestrator/fallback";
+import { fallbackDefaults } from "./orchestrator/fallback/fallback-config";
+import { resolveChain } from "./orchestrator/fallback/resolve-chain";
+import { ocConfidence } from "./tools/confidence";
+import { ocCreateAgent } from "./tools/create-agent";
+import { ocCreateCommand } from "./tools/create-command";
+import { ocCreateSkill } from "./tools/create-skill";
+import { ocForensics } from "./tools/forensics";
+import { ocOrchestrate } from "./tools/orchestrate";
+import { ocPhase } from "./tools/phase";
+import { ocPlaceholder } from "./tools/placeholder";
+import { ocPlan } from "./tools/plan";
+import { ocReview } from "./tools/review";
+import { ocState } from "./tools/state";
+
+let openCodeConfig: Config | null = null;
+
+const plugin: Plugin = async (input) => {
+	const client = input.client;
+
+	// Self-healing asset installation on every load
+	const installResult = await installAssets();
+	if (installResult.errors.length > 0) {
+		console.error("[opencode-autopilot] Asset installation errors:", installResult.errors);
+	}
+
+	// Load config for first-load detection and fallback settings
+	const config = await loadConfig();
+	const fallbackConfig = config?.fallback ?? fallbackDefaults;
+
+	// --- Fallback subsystem initialization ---
+	const sdkOps: SdkOperations = {
+		abortSession: async (sessionID) => {
+			await client.session.abort({ path: { id: sessionID } });
+		},
+		getSessionMessages: async (sessionID) => {
+			const response = await client.session.messages({
+				path: { id: sessionID },
+				query: { directory: process.cwd() },
+			});
+			// Extract parts from the last non-assistant message for replay
+			const messages = (response.data ?? []) as ReadonlyArray<{
+				role?: string;
+				parts?: readonly import("./orchestrator/fallback").MessagePart[];
+			}>;
+			const lastUserMsg = [...messages].reverse().find((m) => m.role !== "assistant");
+			return lastUserMsg?.parts ?? [];
+		},
+		promptAsync: async (sessionID, model, parts) => {
+			await client.session.promptAsync({
+				path: { id: sessionID },
+				// biome-ignore lint/suspicious/noExplicitAny: MessagePart is a superset of SDK part types
+				body: { model, parts: parts as any },
+				query: { directory: process.cwd() },
+			});
+		},
+		showToast: async (title, message, variant) => {
+			await client.tui.showToast({
+				body: { title, message, variant, duration: 5000 },
+			});
+		},
+	};
+
+	const manager = new FallbackManager({
+		config: fallbackConfig,
+		resolveFallbackChain: (_sessionID, agentName) => {
+			const agentConfigs = openCodeConfig?.agent as
+				| Record<string, Record<string, unknown>>
+				| undefined;
+			return resolveChain(agentName ?? "", agentConfigs, config?.fallback_models);
+		},
+	});
+
+	const fallbackEventHandler = createEventHandler({
+		manager,
+		sdk: sdkOps,
+		config: fallbackConfig,
+	});
+	const chatMessageHandler = createChatMessageHandler(manager);
+	const toolExecuteAfterHandler = createToolExecuteAfterHandler(manager);
+
+	return {
+		tool: {
+			oc_placeholder: ocPlaceholder,
+			oc_create_agent: ocCreateAgent,
+			oc_create_skill: ocCreateSkill,
+			oc_create_command: ocCreateCommand,
+			oc_state: ocState,
+			oc_confidence: ocConfidence,
+			oc_phase: ocPhase,
+			oc_plan: ocPlan,
+			oc_orchestrate: ocOrchestrate,
+			oc_forensics: ocForensics,
+			oc_review: ocReview,
+		},
+		event: async ({ event }) => {
+			if (event.type === "session.created" && isFirstLoad(config)) {
+				// First load: config wizard will be triggered via /configure command
+				// Phase 2 will add the oc_configure tool
+			}
+
+			// Fallback event handling (runs for all events)
+			if (fallbackConfig.enabled) {
+				await fallbackEventHandler({ event });
+			}
+		},
+		config: async (cfg: Config) => {
+			openCodeConfig = cfg;
+			await configHook(cfg);
+		},
+		"chat.message": async (
+			hookInput: {
+				readonly sessionID: string;
+				readonly agent?: string;
+				readonly model?: { readonly providerID: string; readonly modelID: string };
+			},
+			output: {
+				message: { model?: { providerID: string; modelID: string } };
+				parts: unknown[];
+			},
+		) => {
+			if (fallbackConfig.enabled) {
+				await chatMessageHandler(hookInput, output);
+			}
+		},
+		"tool.execute.after": async (
+			hookInput: {
+				readonly tool: string;
+				readonly sessionID: string;
+				readonly callID: string;
+				readonly args: unknown;
+			},
+			output: { title: string; output: string; metadata: unknown },
+		) => {
+			if (fallbackConfig.enabled) {
+				await toolExecuteAfterHandler(hookInput, output);
+			}
+		},
+	};
+};
+
+export default plugin;

package/src/installer.ts

@@ -0,0 +1,130 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { copyIfMissing, isEnoentError } from "./utils/fs-helpers";
+import { getAssetsDir, getGlobalConfigDir } from "./utils/paths";
+
+export interface InstallResult {
+	readonly copied: readonly string[];
+	readonly skipped: readonly string[];
+	readonly errors: readonly string[];
+}
+
+interface ListEntriesResult {
+	readonly entries: ReadonlyArray<{ name: string; isDirectory: boolean }>;
+	readonly error: string | null;
+}
+
+async function listEntries(dirPath: string): Promise<ListEntriesResult> {
+	try {
+		const entries = await readdir(dirPath, { withFileTypes: true });
+		return {
+			entries: entries.map((e) => ({ name: e.name, isDirectory: e.isDirectory() })),
+			error: null,
+		};
+	} catch (error: unknown) {
+		if (isEnoentError(error)) {
+			return { entries: [], error: null };
+		}
+		const message = error instanceof Error ? error.message : String(error);
+		return { entries: [], error: `${dirPath}: ${message}` };
+	}
+}
+
+async function processFiles(
+	sourceDir: string,
+	targetDir: string,
+	category: string,
+): Promise<InstallResult> {
+	const copied: string[] = [];
+	const skipped: string[] = [];
+	const errors: string[] = [];
+
+	const listing = await listEntries(join(sourceDir, category));
+	if (listing.error) {
+		errors.push(listing.error);
+	}
+
+	for (const entry of listing.entries) {
+		if (entry.name === ".gitkeep") continue;
+		if (entry.isDirectory) continue;
+
+		const relativePath = `${category}/${entry.name}`;
+		const source = join(sourceDir, relativePath);
+		const target = join(targetDir, relativePath);
+
+		try {
+			const result = await copyIfMissing(source, target);
+			if (result.copied) {
+				copied.push(relativePath);
+			} else {
+				skipped.push(relativePath);
+			}
+		} catch (error: unknown) {
+			const message = error instanceof Error ? error.message : String(error);
+			errors.push(`${relativePath}: ${message}`);
+		}
+	}
+
+	return { copied, skipped, errors };
+}
+
+async function processSkills(sourceDir: string, targetDir: string): Promise<InstallResult> {
+	const copied: string[] = [];
+	const skipped: string[] = [];
+	const errors: string[] = [];
+
+	const skillListing = await listEntries(join(sourceDir, "skills"));
+	if (skillListing.error) {
+		errors.push(skillListing.error);
+	}
+
+	for (const dir of skillListing.entries) {
+		if (!dir.isDirectory) continue;
+		if (dir.name === ".gitkeep") continue;
+
+		const fileListing = await listEntries(join(sourceDir, "skills", dir.name));
+		if (fileListing.error) {
+			errors.push(fileListing.error);
+		}
+
+		for (const file of fileListing.entries) {
+			if (file.name === ".gitkeep") continue;
+			if (file.isDirectory) continue;
+
+			const relativePath = `skills/${dir.name}/${file.name}`;
+			const source = join(sourceDir, relativePath);
+			const target = join(targetDir, relativePath);
+
+			try {
+				const result = await copyIfMissing(source, target);
+				if (result.copied) {
+					copied.push(relativePath);
+				} else {
+					skipped.push(relativePath);
+				}
+			} catch (error: unknown) {
+				const message = error instanceof Error ? error.message : String(error);
+				errors.push(`${relativePath}: ${message}`);
+			}
+		}
+	}
+
+	return { copied, skipped, errors };
+}
+
+export async function installAssets(
+	assetsDir: string = getAssetsDir(),
+	targetDir: string = getGlobalConfigDir(),
+): Promise<InstallResult> {
+	const [agents, commands, skills] = await Promise.all([
+		processFiles(assetsDir, targetDir, "agents"),
+		processFiles(assetsDir, targetDir, "commands"),
+		processSkills(assetsDir, targetDir),
+	]);
+
+	return {
+		copied: [...agents.copied, ...commands.copied, ...skills.copied],
+		skipped: [...agents.skipped, ...commands.skipped, ...skills.skipped],
+		errors: [...agents.errors, ...commands.errors, ...skills.errors],
+	};
+}

package/src/orchestrator/arena.ts

@@ -0,0 +1,41 @@
+import { summarizeConfidence } from "./confidence";
+import type { ConfidenceEntry } from "./types";
+
+type ConfidenceLevel = "HIGH" | "MEDIUM" | "LOW";
+
+const DEPTH_MAP: Readonly<Record<ConfidenceLevel, number>> = Object.freeze({
+	HIGH: 1,
+	MEDIUM: 2,
+	LOW: 3,
+});
+
+const LEVEL_ORDER: Readonly<Record<ConfidenceLevel, number>> = Object.freeze({
+	HIGH: 3,
+	MEDIUM: 2,
+	LOW: 1,
+});
+
+/**
+ * Determines arena debate depth based on aggregate confidence.
+ * LOW confidence -> 3 proposals, MEDIUM -> 2, HIGH -> 1.
+ */
+export function getDebateDepth(entries: readonly ConfidenceEntry[]): number {
+	const { dominant } = summarizeConfidence(entries);
+	return DEPTH_MAP[dominant];
+}
+
+/**
+ * Returns true if any confidence entry is below the given threshold.
+ * Empty entries returns false.
+ */
+export function shouldTriggerExplorer(
+	entries: readonly ConfidenceEntry[],
+	threshold: ConfidenceLevel = "MEDIUM",
+): boolean {
+	if (entries.length === 0) {
+		return false;
+	}
+
+	const thresholdOrder = LEVEL_ORDER[threshold];
+	return entries.some((entry) => LEVEL_ORDER[entry.level] < thresholdOrder);
+}

package/src/orchestrator/artifacts.ts

@@ -0,0 +1,28 @@
+import { join } from "node:path";
+import { ensureDir } from "../utils/fs-helpers";
+import type { Phase } from "./types";
+
+export function getPhaseDir(artifactDir: string, phase: Phase): string {
+	return join(artifactDir, "phases", phase);
+}
+
+export async function ensurePhaseDir(artifactDir: string, phase: Phase): Promise<string> {
+	const dir = getPhaseDir(artifactDir, phase);
+	await ensureDir(dir);
+	return dir;
+}
+
+export function getArtifactRef(phase: Phase, filename: string): string {
+	return `phases/${phase}/${filename}`;
+}
+
+export const PHASE_ARTIFACTS: Readonly<Record<string, readonly string[]>> = Object.freeze({
+	RECON: Object.freeze(["report.md"]),
+	CHALLENGE: Object.freeze(["brief.md"]),
+	ARCHITECT: Object.freeze(["design.md"]),
+	EXPLORE: Object.freeze([]),
+	PLAN: Object.freeze(["tasks.md"]),
+	BUILD: Object.freeze([]),
+	SHIP: Object.freeze(["walkthrough.md", "decisions.md", "changelog.md"]),
+	RETROSPECTIVE: Object.freeze(["lessons.json"]),
+});

package/src/orchestrator/confidence.ts

@@ -0,0 +1,59 @@
+import type { ConfidenceEntry, Phase, PipelineState } from "./types";
+
+type ConfidenceLevel = "HIGH" | "MEDIUM" | "LOW";
+
+const LEVEL_PRIORITY: readonly ConfidenceLevel[] = ["HIGH", "MEDIUM", "LOW"] as const;
+
+export function appendConfidence(
+	state: Readonly<PipelineState>,
+	entry: Omit<ConfidenceEntry, "timestamp">,
+): PipelineState {
+	return {
+		...state,
+		confidence: [
+			...state.confidence,
+			{
+				...entry,
+				timestamp: new Date().toISOString(),
+			},
+		],
+		lastUpdatedAt: new Date().toISOString(),
+	};
+}
+
+export function summarizeConfidence(entries: readonly ConfidenceEntry[]): {
+	HIGH: number;
+	MEDIUM: number;
+	LOW: number;
+	total: number;
+	dominant: ConfidenceLevel;
+} {
+	const counts: Record<ConfidenceLevel, number> = { HIGH: 0, MEDIUM: 0, LOW: 0 };
+
+	for (const entry of entries) {
+		counts[entry.level]++;
+	}
+
+	const total = entries.length;
+
+	// Tie-break: prefer higher confidence (HIGH > MEDIUM > LOW)
+	let dominant: ConfidenceLevel = "MEDIUM"; // default for empty
+	if (total > 0) {
+		let maxCount = 0;
+		for (const level of LEVEL_PRIORITY) {
+			if (counts[level] > maxCount) {
+				maxCount = counts[level];
+				dominant = level;
+			}
+		}
+	}
+
+	return { ...counts, total, dominant };
+}
+
+export function filterByPhase(
+	entries: readonly ConfidenceEntry[],
+	phase: Phase,
+): readonly ConfidenceEntry[] {
+	return entries.filter((entry) => entry.phase === phase);
+}

package/src/orchestrator/fallback/chat-message-handler.ts

@@ -0,0 +1,49 @@
+import { parseModelString } from "./event-handler";
+import type { FallbackManager } from "./fallback-manager";
+
+/**
+ * Factory that creates a chat.message hook handler bound to the FallbackManager.
+ *
+ * When a fallback model is active, overrides `output.message.model` so OpenCode
+ * sends the request to the fallback provider/model instead of the original.
+ *
+ * NOTE: The mutation of `output.message.model` is INTENTIONAL -- the OpenCode
+ * hook API requires mutating the output object to override the model. This is
+ * the one place where mutation is correct (same pattern as configHook mutating
+ * config.agent).
+ */
+export function createChatMessageHandler(manager: FallbackManager) {
+	return async (
+		input: {
+			readonly sessionID: string;
+			readonly model?: { readonly providerID: string; readonly modelID: string };
+		},
+		output: {
+			message: { model?: { providerID: string; modelID: string } };
+			parts: unknown[];
+		},
+	): Promise<void> => {
+		const state = manager.getSessionState(input.sessionID);
+		if (!state) return;
+
+		// Skip if plugin is actively managing a fallback dispatch (Pitfall 3)
+		if (manager.isDispatchInFlight(input.sessionID)) return;
+
+		// Skip during compaction
+		if (manager.isCompactionInFlight(input.sessionID)) return;
+
+		// Auto-recovery check: revert to original model if cooldown expired
+		manager.tryRecoverToOriginal(input.sessionID);
+		const currentState = manager.getSessionState(input.sessionID);
+		if (!currentState) return;
+
+		// If on primary model, nothing to override
+		if (currentState.currentModel === currentState.originalModel) return;
+
+		// Override outgoing model to fallback model
+		const parsed = parseModelString(currentState.currentModel);
+		if (parsed) {
+			output.message.model = { providerID: parsed.providerID, modelID: parsed.modelID };
+		}
+	};
+}