@kodrunhq/opencode-autopilot 1.2.1 → 1.3.0

package/assets/commands/quick.md

@@ -0,0 +1,7 @@
+---
+description: Run a quick task (skip research/architecture, go straight to plan+build+ship)
+---
+
+Invoke the `oc_quick` tool with the following arguments, skipping research and architecture and going straight to plan, build, and ship:
+
+$ARGUMENTS

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kodrunhq/opencode-autopilot",
-	"version": "1.2.1",
+	"version": "1.3.0",
 	"description": "Curated agents, skills, and commands for the OpenCode AI coding CLI — autonomous orchestrator, multi-agent code review, model fallback, and in-session asset creation tools.",
 	"main": "src/index.ts",
 	"keywords": [

package/src/health/checks.ts

@@ -0,0 +1,125 @@
+import { access } from "node:fs/promises";
+import type { Config } from "@opencode-ai/plugin";
+import { loadConfig } from "../config";
+import { AGENT_NAMES } from "../orchestrator/handlers/types";
+import { getAssetsDir, getGlobalConfigDir } from "../utils/paths";
+import type { HealthResult } from "./types";
+
+/**
+ * Check that the plugin config file exists and passes Zod validation.
+ * loadConfig returns null when the file is missing, and throws on invalid JSON/schema.
+ */
+export async function configHealthCheck(configPath?: string): Promise<HealthResult> {
+	try {
+		const config = await loadConfig(configPath);
+		if (config === null) {
+			return Object.freeze({
+				name: "config-validity",
+				status: "fail" as const,
+				message: "Plugin config file not found",
+			});
+		}
+		return Object.freeze({
+			name: "config-validity",
+			status: "pass" as const,
+			message: `Config v${config.version} loaded and valid`,
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "config-validity",
+			status: "fail" as const,
+			message: `Config validation failed: ${msg}`,
+		});
+	}
+}
+
+/** Standard agent names, derived from the agents barrel export. */
+const STANDARD_AGENT_NAMES: readonly string[] = Object.freeze([
+	"researcher",
+	"metaprompter",
+	"documenter",
+	"pr-reviewer",
+	"autopilot",
+]);
+
+/** Pipeline agent names, derived from AGENT_NAMES in the orchestrator. */
+const PIPELINE_AGENT_NAMES: readonly string[] = Object.freeze(Object.values(AGENT_NAMES));
+
+/** All expected agent names (standard + pipeline). */
+const EXPECTED_AGENTS: readonly string[] = Object.freeze([
+	...STANDARD_AGENT_NAMES,
+	...PIPELINE_AGENT_NAMES,
+]);
+
+/**
+ * Check that all expected agents are injected into the OpenCode config.
+ * Requires the OpenCode config object (from the config hook).
+ */
+export async function agentHealthCheck(config: Config | null): Promise<HealthResult> {
+	if (!config?.agent) {
+		return Object.freeze({
+			name: "agent-injection",
+			status: "fail" as const,
+			message: "No OpenCode config or agent map available",
+		});
+	}
+
+	const agentMap = config.agent;
+	const missing = EXPECTED_AGENTS.filter((name) => !(name in agentMap));
+
+	if (missing.length > 0) {
+		return Object.freeze({
+			name: "agent-injection",
+			status: "fail" as const,
+			message: `${missing.length} agent(s) missing: ${missing.join(", ")}`,
+			details: Object.freeze(missing),
+		});
+	}
+
+	return Object.freeze({
+		name: "agent-injection",
+		status: "pass" as const,
+		message: `All ${EXPECTED_AGENTS.length} agents injected`,
+	});
+}
+
+/**
+ * Check that the source and target asset directories exist and are accessible.
+ */
+export async function assetHealthCheck(
+	assetsDir?: string,
+	targetDir?: string,
+): Promise<HealthResult> {
+	const source = assetsDir ?? getAssetsDir();
+	const target = targetDir ?? getGlobalConfigDir();
+
+	try {
+		await access(source);
+	} catch (error: unknown) {
+		const code = (error as NodeJS.ErrnoException).code;
+		const detail = code === "ENOENT" ? "missing" : `inaccessible (${code})`;
+		return Object.freeze({
+			name: "asset-directories",
+			status: "fail" as const,
+			message: `Asset source directory ${detail}: ${source}`,
+		});
+	}
+
+	try {
+		await access(target);
+		return Object.freeze({
+			name: "asset-directories",
+			status: "pass" as const,
+			message: `Asset directories exist: source=${source}, target=${target}`,
+		});
+	} catch (error: unknown) {
+		const code = (error as NodeJS.ErrnoException).code;
+		const detail = code === "ENOENT" ? "missing" : `inaccessible (${code})`;
+		return Object.freeze({
+			name: "asset-directories",
+			status: "fail" as const,
+			message: `Asset target directory ${detail}: ${target}`,
+		});
+	}
+}

package/src/health/index.ts

@@ -0,0 +1,3 @@
+export { agentHealthCheck, assetHealthCheck, configHealthCheck } from "./checks";
+export { runHealthChecks } from "./runner";
+export type { HealthReport, HealthResult } from "./types";

package/src/health/runner.ts

@@ -0,0 +1,56 @@
+import type { Config } from "@opencode-ai/plugin";
+import { agentHealthCheck, assetHealthCheck, configHealthCheck } from "./checks";
+import type { HealthReport, HealthResult } from "./types";
+
+/**
+ * Map a settled promise result to a HealthResult.
+ * Fulfilled results pass through; rejected results become fail entries.
+ */
+function settledToResult(
+	outcome: PromiseSettledResult<HealthResult>,
+	fallbackName: string,
+): HealthResult {
+	if (outcome.status === "fulfilled") {
+		return outcome.value;
+	}
+	const msg = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
+	return Object.freeze({
+		name: fallbackName,
+		status: "fail" as const,
+		message: `Check threw unexpectedly: ${msg}`,
+	});
+}
+
+/**
+ * Run all health checks and aggregate into a HealthReport.
+ * Each check runs independently — a failure in one does not skip others.
+ * Uses Promise.allSettled so a throwing check cannot kill the entire report.
+ */
+export async function runHealthChecks(options?: {
+	configPath?: string;
+	openCodeConfig?: Config | null;
+	assetsDir?: string;
+	targetDir?: string;
+}): Promise<HealthReport> {
+	const start = Date.now();
+
+	const settled = await Promise.allSettled([
+		configHealthCheck(options?.configPath),
+		agentHealthCheck(options?.openCodeConfig ?? null),
+		assetHealthCheck(options?.assetsDir, options?.targetDir),
+	]);
+
+	const fallbackNames = ["config-validity", "agent-injection", "asset-directories"];
+	const results: readonly HealthResult[] = Object.freeze(
+		settled.map((outcome, i) => settledToResult(outcome, fallbackNames[i])),
+	);
+
+	const allPassed = results.every((r) => r.status === "pass");
+	const duration = Date.now() - start;
+
+	return Object.freeze({
+		results,
+		allPassed,
+		duration,
+	});
+}

package/src/health/types.ts

@@ -0,0 +1,20 @@
+/**
+ * Health check result for a single diagnostic check.
+ * Immutable — frozen on creation by each check function.
+ */
+export interface HealthResult {
+	readonly name: string;
+	readonly status: "pass" | "fail";
+	readonly message: string;
+	readonly details?: readonly string[];
+}
+
+/**
+ * Aggregated health report from running all checks.
+ * Immutable — frozen on creation by runHealthChecks.
+ */
+export interface HealthReport {
+	readonly results: readonly HealthResult[];
+	readonly allPassed: boolean;
+	readonly duration: number;
+}

package/src/index.ts

@@ -1,6 +1,7 @@
 import type { Config, Plugin } from "@opencode-ai/plugin";
 import { configHook } from "./agents";
 import { isFirstLoad, loadConfig } from "./config";
+import { runHealthChecks } from "./health/runner";
 import { installAssets } from "./installer";
 import type { SdkOperations } from "./orchestrator/fallback";
 import {
@@ -21,10 +22,12 @@ import {
 import { ocCreateAgent } from "./tools/create-agent";
 import { ocCreateCommand } from "./tools/create-command";
 import { ocCreateSkill } from "./tools/create-skill";
+import { ocDoctor } from "./tools/doctor";
 import { ocForensics } from "./tools/forensics";
 import { ocOrchestrate } from "./tools/orchestrate";
 import { ocPhase } from "./tools/phase";
 import { ocPlan } from "./tools/plan";
+import { ocQuick } from "./tools/quick";
 import { ocReview } from "./tools/review";
 import { ocState } from "./tools/state";
 
@@ -62,6 +65,11 @@ const plugin: Plugin = async (input) => {
 	const config = await loadConfig();
 	const fallbackConfig = config?.fallback ?? fallbackDefaults;
 
+	// Self-healing health checks on every load (non-blocking, <100ms target)
+	runHealthChecks().catch(() => {
+		// Health check failures are non-fatal — oc_doctor provides manual diagnostics
+	});
+
 	// --- Fallback subsystem initialization ---
 	const sdkOps: SdkOperations = {
 		abortSession: async (sessionID) => {
@@ -126,6 +134,8 @@ const plugin: Plugin = async (input) => {
 			oc_phase: ocPhase,
 			oc_plan: ocPlan,
 			oc_orchestrate: ocOrchestrate,
+			oc_doctor: ocDoctor,
+			oc_quick: ocQuick,
 			oc_forensics: ocForensics,
 			oc_review: ocReview,
 		},

package/src/tools/configure.ts

@@ -85,15 +85,25 @@ interface ConfigureArgs {
 
 /**
  * Discover available models from the stored provider data.
- * Returns a map of provider ID -> list of "providerId/modelId" strings.
+ * Returns a map of provider ID -> list of fully-qualified model ID strings.
+ *
+ * Uses the model's own `id` field (which may contain sub-provider paths like
+ * "anthropic/claude-opus-4-6" for a Zen provider) to construct the full
+ * "provider/model" path. This ensures Zen-proxied models display as
+ * "zen/anthropic/claude-opus-4-6" matching OpenCode's native `/models` output.
  */
 function discoverAvailableModels(): Map<string, string[]> {
 	const modelsByProvider = new Map<string, string[]>();
 
 	for (const provider of availableProviders) {
 		const modelIds: string[] = [];
-		for (const modelKey of Object.keys(provider.models)) {
-			modelIds.push(`${provider.id}/${modelKey}`);
+		for (const [modelKey, modelData] of Object.entries(provider.models)) {
+			// Prefer the model's id field — it carries sub-provider paths
+			// (e.g. "anthropic/claude-opus-4-6" under a "zen" provider).
+			// Fall back to the record key when the id is absent or empty.
+			const modelId = modelData.id || modelKey;
+			const fullId = `${provider.id}/${modelId}`;
+			modelIds.push(fullId);
 		}
 		if (modelIds.length > 0) {
 			modelsByProvider.set(provider.id, modelIds);

package/src/tools/doctor.ts

@@ -0,0 +1,111 @@
+import type { Config } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import { runHealthChecks } from "../health/runner";
+import type { HealthResult } from "../health/types";
+
+/**
+ * A single check in the doctor report, with an optional fix suggestion.
+ */
+interface DoctorCheck {
+	readonly name: string;
+	readonly status: "pass" | "fail";
+	readonly message: string;
+	readonly fixSuggestion: string | null;
+}
+
+/**
+ * Options for doctorCore — all optional for testability.
+ */
+interface DoctorOptions {
+	readonly configPath?: string;
+	readonly openCodeConfig?: Config | null;
+	readonly assetsDir?: string;
+	readonly targetDir?: string;
+}
+
+/**
+ * Map check names to actionable fix suggestions (per D-11).
+ */
+const FIX_SUGGESTIONS: Readonly<Record<string, string>> = Object.freeze({
+	"config-validity":
+		"Run /oc-configure to reconfigure, or delete ~/.config/opencode/opencode-autopilot.json to reset",
+	"agent-injection": "Restart OpenCode to trigger agent re-injection via config hook",
+	"asset-directories": "Restart OpenCode to trigger asset reinstallation",
+});
+
+function getFixSuggestion(checkName: string): string {
+	return FIX_SUGGESTIONS[checkName] ?? "Restart OpenCode to trigger auto-repair";
+}
+
+function formatCheck(result: HealthResult): DoctorCheck {
+	return Object.freeze({
+		name: result.name,
+		status: result.status,
+		message: result.message,
+		fixSuggestion: result.status === "fail" ? getFixSuggestion(result.name) : null,
+	});
+}
+
+/**
+ * Build human-readable pass/fail display text (like `brew doctor` output).
+ */
+function buildDisplayText(checks: readonly DoctorCheck[], duration: number): string {
+	const lines = checks.map((c) => {
+		const icon = c.status === "pass" ? "OK" : "FAIL";
+		const line = `[${icon}] ${c.name}: ${c.message}`;
+		return c.fixSuggestion ? `${line}\n     Fix: ${c.fixSuggestion}` : line;
+	});
+	lines.push("", `Completed in ${duration}ms`);
+	return lines.join("\n");
+}
+
+/**
+ * Core diagnostic function — runs all health checks and returns a structured
+ * JSON report. Follows the *Core + tool() wrapper pattern per CLAUDE.md.
+ *
+ * The hook-registration check is informational: if oc_doctor is callable,
+ * the plugin is registered. Always passes.
+ */
+export async function doctorCore(options?: DoctorOptions): Promise<string> {
+	const report = await runHealthChecks({
+		configPath: options?.configPath,
+		openCodeConfig: options?.openCodeConfig,
+		assetsDir: options?.assetsDir,
+		targetDir: options?.targetDir,
+	});
+
+	// Map health results to doctor checks with fix suggestions
+	const healthChecks = report.results.map(formatCheck);
+
+	// Hook-registration check: if oc_doctor is callable, hooks are registered
+	const hookCheck: DoctorCheck = Object.freeze({
+		name: "hook-registration",
+		status: "pass" as const,
+		message: "Plugin tools registered (oc_doctor callable)",
+		fixSuggestion: null,
+	});
+
+	const allChecks = [...healthChecks, hookCheck];
+	const allPassed = report.allPassed && hookCheck.status === "pass";
+	const displayText = buildDisplayText(allChecks, report.duration);
+
+	return JSON.stringify({
+		action: "doctor",
+		checks: allChecks,
+		allPassed,
+		displayText,
+		duration: report.duration,
+	});
+}
+
+// --- Tool wrapper ---
+
+export const ocDoctor = tool({
+	description:
+		"Run plugin health diagnostics. Reports pass/fail status for config, agents, " +
+		"assets, and hooks. Like `brew doctor` for opencode-autopilot.",
+	args: {},
+	async execute() {
+		return doctorCore();
+	},
+});

package/src/tools/quick.ts

@@ -0,0 +1,126 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tool } from "@opencode-ai/plugin";
+import { ensurePhaseDir } from "../orchestrator/artifacts";
+import { PHASES, pipelineStateSchema } from "../orchestrator/schemas";
+import { loadState, saveState } from "../orchestrator/state";
+import { ensureGitignore } from "../utils/gitignore";
+import { getProjectArtifactDir } from "../utils/paths";
+import { orchestrateCore } from "./orchestrate";
+
+/** Phases skipped in quick mode (per D-17: skip RECON, CHALLENGE, ARCHITECT, EXPLORE). */
+const QUICK_SKIP_PHASES: ReadonlySet<string> = new Set([
+	"RECON",
+	"CHALLENGE",
+	"ARCHITECT",
+	"EXPLORE",
+] as const);
+
+interface QuickArgs {
+	readonly idea: string;
+}
+
+/**
+ * Core logic for the /quick command.
+ * Creates a pipeline state that starts at PLAN (skipping discovery phases),
+ * then delegates to orchestrateCore to continue the pipeline.
+ */
+export async function quickCore(args: QuickArgs, artifactDir: string): Promise<string> {
+	// 1. Validate idea
+	if (!args.idea || args.idea.trim().length === 0) {
+		return JSON.stringify({
+			action: "error",
+			message: "No idea provided. Usage: /quick <describe the task>",
+		});
+	}
+
+	// 2. Check for existing in-progress run
+	const existing = await loadState(artifactDir);
+	if (existing !== null && existing.status === "IN_PROGRESS") {
+		return JSON.stringify({
+			action: "error",
+			message:
+				"An orchestration run is already in progress. Complete or reset it before starting a quick task.",
+		});
+	}
+
+	// 3. Create quick-mode initial state (starts at PLAN, skips discovery phases)
+	const now = new Date().toISOString();
+	const quickState = pipelineStateSchema.parse({
+		schemaVersion: 2,
+		status: "IN_PROGRESS",
+		idea: args.idea,
+		currentPhase: "PLAN",
+		startedAt: now,
+		lastUpdatedAt: now,
+		phases: PHASES.map((name) => ({
+			name,
+			status: QUICK_SKIP_PHASES.has(name) ? "SKIPPED" : name === "PLAN" ? "IN_PROGRESS" : "PENDING",
+			...(QUICK_SKIP_PHASES.has(name) ? { completedAt: now } : {}),
+		})),
+		decisions: [
+			{
+				timestamp: now,
+				phase: "PLAN",
+				agent: "oc-quick",
+				decision: "Skip discovery phases",
+				rationale: "Quick task mode: user explicitly requested simplified pipeline via /quick",
+			},
+		],
+		confidence: [],
+		tasks: [],
+		arenaConfidence: null,
+		exploreTriggered: false,
+	});
+
+	// 4. Persist quick state to disk
+	await saveState(quickState, artifactDir);
+
+	// 5. Create minimal stub artifacts for skipped phases so the PLAN handler
+	//    has something to reference (design.md for ARCHITECT, brief.md for CHALLENGE).
+	//    Uses "wx" flag to avoid overwriting existing files.
+	const stubs: readonly {
+		readonly phase: "ARCHITECT" | "CHALLENGE";
+		readonly file: string;
+		readonly content: string;
+	}[] = [
+		{ phase: "ARCHITECT", file: "design.md", content: "# Design\n\n_Skipped in quick mode._\n" },
+		{
+			phase: "CHALLENGE",
+			file: "brief.md",
+			content: "# Challenge Brief\n\n_Skipped in quick mode._\n",
+		},
+	];
+	for (const stub of stubs) {
+		const phaseDir = await ensurePhaseDir(artifactDir, stub.phase);
+		try {
+			await writeFile(join(phaseDir, stub.file), stub.content, { flag: "wx" });
+		} catch (error) {
+			const err = error as NodeJS.ErrnoException;
+			if (err.code !== "EEXIST") {
+				throw err;
+			}
+		}
+	}
+
+	// 6. Best-effort .gitignore update (same pattern as orchestrateCore)
+	try {
+		await ensureGitignore(join(artifactDir, ".."));
+	} catch {
+		// Non-critical -- swallow gitignore errors
+	}
+
+	// 7. Delegate to orchestrateCore to continue from PLAN phase
+	return orchestrateCore({ result: undefined }, artifactDir);
+}
+
+export const ocQuick = tool({
+	description:
+		"Run a quick task through a simplified pipeline. Skips research and architecture phases (RECON, CHALLENGE, ARCHITECT, EXPLORE) and goes straight to PLAN -> BUILD -> SHIP -> RETROSPECTIVE. Use for small, well-understood tasks.",
+	args: {
+		idea: tool.schema.string().min(1).max(4096).describe("The task to accomplish"),
+	},
+	async execute(args) {
+		return quickCore(args, getProjectArtifactDir(process.cwd()));
+	},
+});