@kodrunhq/opencode-autopilot 0.1.0

package/src/tools/forensics.ts

@@ -0,0 +1,88 @@
+import { tool } from "@opencode-ai/plugin";
+import { loadState } from "../orchestrator/state";
+import { getProjectArtifactDir } from "../utils/paths";
+
+/**
+ * BUILD failures are terminal (strike overflow). All other phases are recoverable.
+ */
+function isRecoverable(failedPhase: string): boolean {
+	return failedPhase !== "BUILD";
+}
+
+/**
+ * Suggest the best recovery action based on failed phase and recoverability.
+ * - Not recoverable -> "restart"
+ * - RECON (nothing completed to resume from) -> "restart"
+ * - All other recoverable phases -> "resume"
+ */
+function getSuggestedAction(failedPhase: string, recoverable: boolean): "resume" | "restart" {
+	if (!recoverable) return "restart";
+	if (failedPhase === "RECON") return "restart";
+	return "resume";
+}
+
+export async function forensicsCore(
+	_args: Record<string, never>,
+	projectRoot: string,
+): Promise<string> {
+	const artifactDir = getProjectArtifactDir(projectRoot);
+	let state: Awaited<ReturnType<typeof loadState>>;
+	try {
+		state = await loadState(artifactDir);
+	} catch (error: unknown) {
+		const detail =
+			error instanceof SyntaxError
+				? "state file contains invalid JSON"
+				: error !== null && typeof error === "object" && "issues" in error
+					? "state file failed schema validation"
+					: "state file is unreadable";
+		return JSON.stringify({
+			action: "error",
+			message: `Pipeline state is corrupt: ${detail}`,
+			recoverable: false,
+			suggestedAction: "manual",
+		});
+	}
+
+	if (state === null) {
+		return JSON.stringify({ action: "error", message: "No pipeline state found" });
+	}
+
+	if (state.status !== "FAILED") {
+		return JSON.stringify({
+			action: "error",
+			message: `No failure to diagnose -- pipeline status: ${state.status}`,
+		});
+	}
+
+	if (!state.failureContext) {
+		return JSON.stringify({
+			action: "error",
+			message: "No failure metadata recorded",
+		});
+	}
+
+	const { failureContext } = state;
+	const recoverable = isRecoverable(failureContext.failedPhase);
+	const suggestedAction = getSuggestedAction(failureContext.failedPhase, recoverable);
+	const phasesCompleted = state.phases.filter((p) => p.status === "DONE").map((p) => p.name);
+
+	return JSON.stringify({
+		failedPhase: failureContext.failedPhase,
+		failedAgent: failureContext.failedAgent,
+		errorMessage: failureContext.errorMessage,
+		lastSuccessfulPhase: failureContext.lastSuccessfulPhase,
+		recoverable,
+		suggestedAction,
+		phasesCompleted,
+	});
+}
+
+export const ocForensics = tool({
+	description:
+		"Diagnose a failed orchestrator pipeline run. Returns structured JSON with failing phase, root cause, and whether the failure is recoverable. Invoke after a pipeline error.",
+	args: {},
+	async execute(_args) {
+		return forensicsCore({}, process.cwd());
+	},
+});

package/src/tools/orchestrate.ts

@@ -0,0 +1,310 @@
+import { join } from "node:path";
+import { tool } from "@opencode-ai/plugin";
+import { PHASE_HANDLERS } from "../orchestrator/handlers/index";
+import type { DispatchResult } from "../orchestrator/handlers/types";
+import { buildLessonContext } from "../orchestrator/lesson-injection";
+import { loadLessonMemory } from "../orchestrator/lesson-memory";
+import { completePhase, getNextPhase } from "../orchestrator/phase";
+import { buildSkillContext, loadSkillContent } from "../orchestrator/skill-injection";
+import { createInitialState, loadState, patchState, saveState } from "../orchestrator/state";
+import type { Phase } from "../orchestrator/types";
+import { isEnoentError } from "../utils/fs-helpers";
+import { ensureGitignore } from "../utils/gitignore";
+import { getGlobalConfigDir, getProjectArtifactDir } from "../utils/paths";
+import { reviewCore } from "./review";
+
+interface OrchestrateArgs {
+	readonly idea?: string;
+	readonly result?: string;
+}
+
+/**
+ * Apply state updates from a DispatchResult if present, then save.
+ * Returns the updated state.
+ */
+async function applyStateUpdates(
+	state: Readonly<import("../orchestrator/types").PipelineState>,
+	handlerResult: DispatchResult,
+	artifactDir: string,
+): Promise<import("../orchestrator/types").PipelineState> {
+	const updates = handlerResult._stateUpdates;
+	if (updates) {
+		const updated = patchState(state, updates);
+		await saveState(updated, artifactDir);
+		return updated;
+	}
+	return state;
+}
+
+/**
+ * When a handler dispatches "oc-reviewer", call reviewCore directly instead
+ * of returning the dispatch instruction. This avoids the JSON round-trip
+ * for the review integration in BUILD phase (per CONTEXT.md).
+ */
+async function maybeInlineReview(
+	handlerResult: DispatchResult,
+	artifactDir: string,
+): Promise<{ readonly inlined: boolean; readonly reviewResult?: string }> {
+	if (
+		handlerResult.action === "dispatch" &&
+		handlerResult.agent === "oc-reviewer" &&
+		handlerResult.prompt
+	) {
+		const projectRoot = join(artifactDir, "..");
+		const reviewResult = await reviewCore({ scope: "branch" }, projectRoot);
+		return { inlined: true, reviewResult };
+	}
+	return { inlined: false };
+}
+
+/**
+ * Attempt to inject lesson context into a dispatch prompt.
+ * Best-effort: failures are silently swallowed to avoid breaking dispatch.
+ */
+async function injectLessonContext(
+	prompt: string,
+	phase: string,
+	artifactDir: string,
+): Promise<string> {
+	try {
+		const projectRoot = join(artifactDir, "..");
+		const memory = await loadLessonMemory(projectRoot);
+		if (memory && memory.lessons.length > 0) {
+			const ctx = buildLessonContext(memory.lessons, phase as Phase);
+			if (ctx) {
+				return prompt + ctx;
+			}
+		}
+	} catch (error: unknown) {
+		if (
+			isEnoentError(error) ||
+			error instanceof SyntaxError ||
+			(error !== null && typeof error === "object" && "issues" in error)
+		) {
+			return prompt; // I/O, parse, or validation error -- non-critical
+		}
+		// Treat any NodeJS.ErrnoException (EACCES, EPERM, etc.) as non-critical
+		if (error !== null && typeof error === "object") {
+			const errWithCode = error as { code?: unknown };
+			if (typeof errWithCode.code === "string") {
+				return prompt;
+			}
+		}
+		throw error; // re-throw programmer errors
+	}
+	return prompt;
+}
+
+/**
+ * Attempt to inject coding-standards skill context into a dispatch prompt.
+ * Best-effort: failures are silently swallowed to avoid breaking dispatch.
+ */
+async function injectSkillContext(prompt: string): Promise<string> {
+	try {
+		const baseDir = getGlobalConfigDir();
+		const content = await loadSkillContent(baseDir);
+		const ctx = buildSkillContext(content);
+		if (ctx) return prompt + ctx;
+	} catch {
+		// Best-effort: swallow all errors (same as lesson injection)
+	}
+	return prompt;
+}
+
+/**
+ * Process a handler's DispatchResult, handling complete/dispatch/dispatch_multi/error.
+ * On complete, advances the phase and invokes the next handler.
+ */
+async function processHandlerResult(
+	handlerResult: DispatchResult,
+	state: Readonly<import("../orchestrator/types").PipelineState>,
+	artifactDir: string,
+): Promise<string> {
+	// Apply state updates from handler if present
+	const currentState = await applyStateUpdates(state, handlerResult, artifactDir);
+
+	switch (handlerResult.action) {
+		case "error":
+			return JSON.stringify(handlerResult);
+
+		case "dispatch": {
+			// Check if this is a review dispatch that should be inlined
+			const { inlined, reviewResult } = await maybeInlineReview(handlerResult, artifactDir);
+			if (inlined && reviewResult) {
+				// Feed the review result back into the current phase handler
+				const reloadedState = await loadState(artifactDir);
+				if (reloadedState?.currentPhase) {
+					const handler = PHASE_HANDLERS[reloadedState.currentPhase];
+					const nextResult = await handler(reloadedState, artifactDir, reviewResult);
+					return processHandlerResult(nextResult, reloadedState, artifactDir);
+				}
+			}
+			// Inject lesson + skill context into dispatch prompt (best-effort)
+			if (handlerResult.prompt && handlerResult.phase) {
+				const enrichedPrompt = await injectLessonContext(
+					handlerResult.prompt,
+					handlerResult.phase,
+					artifactDir,
+				);
+				const withSkills = await injectSkillContext(enrichedPrompt);
+				if (withSkills !== handlerResult.prompt) {
+					return JSON.stringify({ ...handlerResult, prompt: withSkills });
+				}
+			}
+			return JSON.stringify(handlerResult);
+		}
+
+		case "dispatch_multi": {
+			// Inject lesson + skill context into each agent's prompt (best-effort)
+			// Load lesson and skill context once and reuse for all agents in the batch
+			if (handlerResult.agents && handlerResult.phase) {
+				const lessonSuffix = await injectLessonContext(
+					"",
+					handlerResult.phase as string,
+					artifactDir,
+				);
+				const skillSuffix = await injectSkillContext("");
+				const combinedSuffix = lessonSuffix + (skillSuffix || "");
+				if (combinedSuffix) {
+					const enrichedAgents = handlerResult.agents.map((entry) => ({
+						...entry,
+						prompt: entry.prompt + combinedSuffix,
+					}));
+					return JSON.stringify({ ...handlerResult, agents: enrichedAgents });
+				}
+			}
+			return JSON.stringify(handlerResult);
+		}
+
+		case "complete": {
+			if (currentState.currentPhase === null) {
+				return JSON.stringify({
+					action: "complete",
+					summary: `Pipeline completed. Idea: ${currentState.idea}`,
+				});
+			}
+
+			const nextPhase = getNextPhase(currentState.currentPhase);
+			const advanced = completePhase(currentState);
+			await saveState(advanced, artifactDir);
+
+			if (nextPhase === null) {
+				// Terminal phase completed
+				const finished = { ...advanced, status: "COMPLETED" as const };
+				await saveState(finished, artifactDir);
+				return JSON.stringify({
+					action: "complete",
+					summary: `Pipeline completed all 8 phases. Idea: ${currentState.idea}`,
+				});
+			}
+
+			// Invoke the next phase handler immediately
+			const nextHandler = PHASE_HANDLERS[nextPhase];
+			const nextResult = await nextHandler(advanced, artifactDir);
+			return processHandlerResult(nextResult, advanced, artifactDir);
+		}
+
+		default:
+			return JSON.stringify({
+				action: "error",
+				message: `Unknown handler action: "${String((handlerResult as unknown as Record<string, unknown>).action)}"`,
+			});
+	}
+}
+
+export async function orchestrateCore(args: OrchestrateArgs, artifactDir: string): Promise<string> {
+	try {
+		const state = await loadState(artifactDir);
+
+		// No state and no idea -> error
+		if (state === null && !args.idea) {
+			return JSON.stringify({
+				action: "error",
+				message: "No active run. Provide an idea to start.",
+			});
+		}
+
+		// No state but idea provided -> create initial state and dispatch RECON via handler
+		if (state === null && args.idea) {
+			const newState = createInitialState(args.idea);
+			await saveState(newState, artifactDir);
+
+			// Best-effort .gitignore update
+			try {
+				const projectRoot = join(artifactDir, "..");
+				await ensureGitignore(projectRoot);
+			} catch {
+				// Swallow gitignore errors -- non-critical
+			}
+
+			const handler = PHASE_HANDLERS[newState.currentPhase as Phase];
+			const handlerResult = await handler(newState, artifactDir);
+			return processHandlerResult(handlerResult, newState, artifactDir);
+		}
+
+		// State exists
+		if (state !== null) {
+			// Pipeline already completed
+			if (state.currentPhase === null) {
+				return JSON.stringify({
+					action: "complete",
+					summary: `Pipeline already completed. Idea: ${state.idea}`,
+				});
+			}
+
+			// Delegate to current phase handler
+			const handler = PHASE_HANDLERS[state.currentPhase];
+			const handlerResult = await handler(state, artifactDir, args.result);
+			return processHandlerResult(handlerResult, state, artifactDir);
+		}
+
+		return JSON.stringify({ action: "error", message: "Unexpected state" });
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
+		const safeMessage = message.replace(/[/\\][^\s"']+/g, "[PATH]").slice(0, 4096);
+
+		// Persist failure metadata for forensics (best-effort)
+		try {
+			const currentState = await loadState(artifactDir);
+			if (currentState?.currentPhase) {
+				const lastDone = currentState.phases.filter((p) => p.status === "DONE").pop();
+				const failureContext = {
+					failedPhase: currentState.currentPhase,
+					failedAgent: null as string | null,
+					errorMessage: safeMessage,
+					timestamp: new Date().toISOString(),
+					lastSuccessfulPhase: lastDone?.name ?? null,
+				};
+				const failed = patchState(currentState, {
+					status: "FAILED" as const,
+					failureContext,
+				});
+				await saveState(failed, artifactDir);
+			}
+		} catch {
+			// Swallow save errors -- original error takes priority
+		}
+
+		return JSON.stringify({ action: "error", message: safeMessage });
+	}
+}
+
+export const ocOrchestrate = tool({
+	description:
+		"Drive the orchestrator pipeline. Provide an idea to start a new run, or a result to advance the current phase. Returns JSON with action (dispatch/dispatch_multi/complete/error).",
+	args: {
+		idea: tool.schema
+			.string()
+			.max(4096)
+			.optional()
+			.describe("Idea to start a new orchestration run"),
+		result: tool.schema
+			.string()
+			.max(1_048_576)
+			.optional()
+			.describe("Result from previous agent to advance the pipeline"),
+	},
+	async execute(args) {
+		return orchestrateCore(args, getProjectArtifactDir(process.cwd()));
+	},
+});

package/src/tools/phase.ts

@@ -0,0 +1,92 @@
+import { tool } from "@opencode-ai/plugin";
+import { completePhase, getPhaseStatus, validateTransition } from "../orchestrator/phase";
+import { phaseSchema } from "../orchestrator/schemas";
+import { loadState, saveState } from "../orchestrator/state";
+import { getProjectArtifactDir } from "../utils/paths";
+
+interface PhaseArgs {
+	readonly subcommand: string;
+	readonly from?: string;
+	readonly to?: string;
+}
+
+export async function phaseCore(args: PhaseArgs, artifactDir: string): Promise<string> {
+	try {
+		switch (args.subcommand) {
+			case "status": {
+				const state = await loadState(artifactDir);
+				if (state === null) {
+					return JSON.stringify({ error: "no_state" });
+				}
+				const currentPhase = state.currentPhase;
+				if (currentPhase === null) {
+					return JSON.stringify({
+						currentPhase: null,
+						status: state.status,
+					});
+				}
+				const phaseStatus = getPhaseStatus(state, currentPhase);
+				return JSON.stringify({
+					currentPhase,
+					status: phaseStatus?.status ?? "UNKNOWN",
+				});
+			}
+
+			case "complete": {
+				const state = await loadState(artifactDir);
+				if (state === null) {
+					return JSON.stringify({ error: "no_state" });
+				}
+				const previousPhase = state.currentPhase;
+				const updated = completePhase(state);
+				await saveState(updated, artifactDir);
+				return JSON.stringify({
+					ok: true,
+					previousPhase,
+					currentPhase: updated.currentPhase,
+				});
+			}
+
+			case "validate": {
+				if (!args.from || !args.to) {
+					return JSON.stringify({
+						error: "from and to phases are required",
+					});
+				}
+				try {
+					const fromPhase = phaseSchema.parse(args.from);
+					const toPhase = phaseSchema.parse(args.to);
+					validateTransition(fromPhase, toPhase);
+					return JSON.stringify({ valid: true });
+				} catch (validationError: unknown) {
+					const message =
+						validationError instanceof Error ? validationError.message : String(validationError);
+					return JSON.stringify({ valid: false, error: message });
+				}
+			}
+
+			default:
+				return JSON.stringify({
+					error: `unknown subcommand: ${args.subcommand}`,
+				});
+		}
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
+		return JSON.stringify({ error: message });
+	}
+}
+
+export const ocPhase = tool({
+	description:
+		"Manage orchestrator phase transitions. Subcommands: status (current phase), complete (advance to next), validate (check transition validity).",
+	args: {
+		subcommand: tool.schema
+			.enum(["status", "complete", "validate"])
+			.describe("Operation to perform"),
+		from: tool.schema.string().optional().describe("Source phase for validate subcommand"),
+		to: tool.schema.string().optional().describe("Target phase for validate subcommand"),
+	},
+	async execute(args) {
+		return phaseCore(args, getProjectArtifactDir(process.cwd()));
+	},
+});

package/src/tools/placeholder.ts

@@ -0,0 +1,11 @@
+import { tool } from "@opencode-ai/plugin";
+
+export const ocPlaceholder = tool({
+	description: "Verifies that the OpenCode Assets plugin is loaded and working",
+	args: {
+		message: tool.schema.string().max(1000).describe("A test message to echo back"),
+	},
+	async execute(args) {
+		return `OpenCode Assets plugin is active. Your message: ${args.message}`;
+	},
+});

package/src/tools/plan.ts

@@ -0,0 +1,56 @@
+import { tool } from "@opencode-ai/plugin";
+import { countByStatus, groupByWave } from "../orchestrator/plan";
+import { loadState } from "../orchestrator/state";
+import { getProjectArtifactDir } from "../utils/paths";
+
+interface PlanArgs {
+	readonly subcommand: string;
+}
+
+export async function planCore(args: PlanArgs, artifactDir: string): Promise<string> {
+	try {
+		switch (args.subcommand) {
+			case "waves": {
+				const state = await loadState(artifactDir);
+				if (state === null) {
+					return JSON.stringify({ error: "no_state" });
+				}
+				const waveMap = groupByWave(state.tasks);
+				// Convert Map to plain object for JSON serialization
+				const waves: Record<string, readonly unknown[]> = {};
+				for (const [wave, tasks] of waveMap) {
+					waves[String(wave)] = tasks;
+				}
+				return JSON.stringify({ waves });
+			}
+
+			case "status-count": {
+				const state = await loadState(artifactDir);
+				if (state === null) {
+					return JSON.stringify({ error: "no_state" });
+				}
+				const counts = countByStatus(state.tasks);
+				return JSON.stringify(counts);
+			}
+
+			default:
+				return JSON.stringify({
+					error: `unknown subcommand: ${args.subcommand}`,
+				});
+		}
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
+		return JSON.stringify({ error: message });
+	}
+}
+
+export const ocPlan = tool({
+	description:
+		"Query orchestrator plan data. Subcommands: waves (tasks grouped by wave), status-count (task counts by status).",
+	args: {
+		subcommand: tool.schema.enum(["waves", "status-count"]).describe("Operation to perform"),
+	},
+	async execute(args) {
+		return planCore(args, getProjectArtifactDir(process.cwd()));
+	},
+});