@kodrunhq/opencode-autopilot 0.1.0

package/src/tools/review.ts

@@ -0,0 +1,295 @@
+/**
+ * oc_review tool -- multi-agent code review.
+ *
+ * Stateful between invocations:
+ * - scope arg -> start new review (stage 1 dispatch)
+ * - findings arg -> advance pipeline to next stage
+ * - no args with active state -> return status
+ * - no args without state -> error
+ *
+ * State persisted at {projectRoot}/.opencode-autopilot/current-review.json
+ * Memory persisted at {projectRoot}/.opencode-autopilot/review-memory.json
+ */
+
+import { execFile } from "node:child_process";
+import { readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { tool } from "@opencode-ai/plugin";
+import { REVIEW_AGENTS, SPECIALIZED_AGENTS } from "../review/agents/index";
+import {
+	createEmptyMemory,
+	loadReviewMemory,
+	pruneMemory,
+	saveReviewMemory,
+} from "../review/memory";
+import type { ReviewState } from "../review/pipeline";
+import { advancePipeline } from "../review/pipeline";
+import { reviewStateSchema } from "../review/schemas";
+import { selectAgents } from "../review/selection";
+import { detectStackTags } from "../review/stack-gate";
+import { ensureDir, isEnoentError } from "../utils/fs-helpers";
+import { getProjectArtifactDir } from "../utils/paths";
+
+interface ReviewArgs {
+	readonly scope?: string;
+	readonly filter?: string;
+	readonly directory?: string;
+	readonly findings?: string;
+}
+
+const execFileAsync = promisify(execFile);
+
+const STATE_FILE = "current-review.json";
+
+/**
+ * Get changed file paths for the given review scope.
+ * Uses execFile (not exec) to prevent shell injection.
+ * Returns empty array on any error (best-effort).
+ */
+async function getChangedFiles(
+	scope: string,
+	projectRoot: string,
+	directory?: string,
+): Promise<readonly string[]> {
+	try {
+		let args: string[];
+		switch (scope) {
+			case "staged":
+				args = ["diff", "--cached", "--name-only"];
+				break;
+			case "unstaged":
+				args = ["diff", "--name-only"];
+				break;
+			case "branch":
+				args = ["diff-tree", "--no-commit-id", "--name-only", "--root", "-r", "HEAD"];
+				break;
+			case "directory":
+				args = directory ? ["diff", "--name-only", "--", directory] : ["diff", "--name-only"];
+				break;
+			default:
+				args = ["diff", "--name-only", "HEAD"];
+				break;
+		}
+		const { stdout } = await execFileAsync("git", args, { cwd: projectRoot, timeout: 10000 });
+		return stdout.trim().split("\n").filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Load review state from disk. Returns null if no active review.
+ */
+async function loadReviewState(artifactDir: string): Promise<ReviewState | null> {
+	const statePath = join(artifactDir, STATE_FILE);
+	try {
+		const raw = await readFile(statePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		return reviewStateSchema.parse(parsed) as ReviewState;
+	} catch (error: unknown) {
+		if (isEnoentError(error)) return null;
+		// Treat parse/schema errors as recoverable — delete corrupt file
+		if (error instanceof SyntaxError || (error && typeof error === "object" && "issues" in error)) {
+			try {
+				await unlink(statePath);
+			} catch {
+				/* ignore cleanup errors */
+			}
+			return null;
+		}
+		throw error;
+	}
+}
+
+/**
+ * Save review state atomically.
+ */
+async function saveReviewState(state: ReviewState, artifactDir: string): Promise<void> {
+	await ensureDir(artifactDir);
+	// Validate before writing (bidirectional validation, same as orchestrator state)
+	const validated = reviewStateSchema.parse(state);
+	const statePath = join(artifactDir, STATE_FILE);
+	const tmpPath = `${statePath}.tmp.${Date.now()}`;
+	await writeFile(tmpPath, JSON.stringify(validated, null, 2), "utf-8");
+	await rename(tmpPath, statePath);
+}
+
+/**
+ * Delete review state file (pipeline complete or error cleanup).
+ */
+async function clearReviewState(artifactDir: string): Promise<void> {
+	const statePath = join(artifactDir, STATE_FILE);
+	try {
+		await unlink(statePath);
+	} catch (error: unknown) {
+		if (!isEnoentError(error)) throw error;
+	}
+}
+
+/**
+ * Start a new review -- detect stacks, select agents, and build stage 1 dispatch prompts.
+ */
+async function startNewReview(
+	scope: string,
+	projectRoot: string,
+	options?: { readonly filter?: string; readonly directory?: string },
+): Promise<{
+	readonly state: ReviewState;
+	readonly agents: readonly { readonly name: string; readonly prompt: string }[];
+}> {
+	// Detect stacks from changed files via git (run in projectRoot)
+	const changedFiles = await getChangedFiles(scope, projectRoot, options?.directory);
+	const detectedStacks = detectStackTags(changedFiles);
+
+	// Build diff analysis from changed file paths
+	const diffAnalysis = {
+		hasTests: changedFiles.some((f) => f.includes("test") || f.includes("spec")),
+		hasAuth: changedFiles.some(
+			(f) => f.includes("auth") || f.includes("login") || f.includes("session"),
+		),
+		hasConfig: changedFiles.some(
+			(f) => f.includes("config") || f.includes("settings") || f.includes(".env"),
+		),
+		fileCount: changedFiles.length,
+	};
+
+	// Select agents from all candidates (universal + specialized)
+	const allCandidates = [...REVIEW_AGENTS, ...SPECIALIZED_AGENTS];
+	const selection = selectAgents(detectedStacks, diffAnalysis, allCandidates);
+
+	const selectedNames = selection.selected.map((a) => a.name);
+
+	// Build stage 1 prompts (specialist review with diff placeholder)
+	const agentPrompts = selection.selected.map((agent) => {
+		const prompt = agent.prompt
+			.replace("{{DIFF}}", `[Diff for scope: ${scope}]`)
+			.replace("{{PRIOR_FINDINGS}}", "No prior findings yet.")
+			.replace("{{MEMORY}}", "");
+		return Object.freeze({ name: agent.name, prompt });
+	});
+
+	const state: ReviewState = {
+		stage: 1,
+		selectedAgentNames: selectedNames,
+		accumulatedFindings: [],
+		scope,
+		startedAt: new Date().toISOString(),
+	};
+
+	return { state, agents: Object.freeze(agentPrompts) };
+}
+
+export async function reviewCore(args: ReviewArgs, projectRoot: string): Promise<string> {
+	try {
+		const artifactDir = getProjectArtifactDir(projectRoot);
+		const currentState = await loadReviewState(artifactDir);
+
+		// Case 1: No state, scope provided -> start new review
+		if (currentState === null && args.scope) {
+			const { state, agents } = await startNewReview(args.scope, projectRoot, {
+				filter: args.filter,
+				directory: args.directory,
+			});
+
+			// Load memory for false positive context
+			const memory = await loadReviewMemory(projectRoot);
+			if (memory) {
+				// Inject false positive context into prompts (via {{MEMORY}} already replaced above)
+				// Future enhancement: pass FP context to agent prompts
+			}
+
+			await saveReviewState(state, artifactDir);
+
+			return JSON.stringify({
+				action: "dispatch",
+				stage: 1,
+				agents,
+			});
+		}
+
+		// Case 2: No state, no scope -> error
+		if (currentState === null && !args.scope) {
+			return JSON.stringify({
+				action: "error",
+				message: "No active review. Provide scope to start.",
+			});
+		}
+
+		// Case 3: State exists, findings provided -> advance pipeline
+		if (currentState !== null && args.findings) {
+			const result = advancePipeline(args.findings, currentState);
+
+			if (result.action === "dispatch" && result.state) {
+				await saveReviewState(result.state, artifactDir);
+				return JSON.stringify({
+					action: "dispatch",
+					stage: result.stage,
+					agents: result.agents,
+					message: result.message,
+				});
+			}
+
+			if (result.action === "complete") {
+				// Update memory with findings
+				const memory = (await loadReviewMemory(projectRoot)) ?? createEmptyMemory();
+				const updatedMemory = pruneMemory({
+					...memory,
+					recentFindings: [...memory.recentFindings, ...(result.report?.findings ?? [])],
+					lastReviewedAt: new Date().toISOString(),
+				});
+				await saveReviewMemory(updatedMemory, projectRoot);
+
+				// Clear state
+				await clearReviewState(artifactDir);
+
+				return JSON.stringify({
+					action: "complete",
+					report: result.report,
+				});
+			}
+
+			if (result.action === "error") {
+				await clearReviewState(artifactDir);
+				return JSON.stringify({
+					action: "error",
+					message: result.message ?? "Pipeline error",
+				});
+			}
+		}
+
+		// Case 4: State exists, no findings -> return status
+		if (currentState !== null && !args.findings) {
+			return JSON.stringify({
+				action: "status",
+				stage: currentState.stage,
+				message: "Awaiting findings from dispatched agents",
+			});
+		}
+
+		return JSON.stringify({ action: "error", message: "Unexpected state" });
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
+		return JSON.stringify({ action: "error", message });
+	}
+}
+
+export const ocReview = tool({
+	description:
+		"Run multi-agent code review. Provide scope (staged|unstaged|branch|all|directory) to start, or findings from dispatched agents to advance the pipeline. Returns JSON with action (dispatch|complete|status|error).",
+	args: {
+		scope: tool.schema
+			.enum(["staged", "unstaged", "branch", "all", "directory"])
+			.optional()
+			.describe("Review scope"),
+		filter: tool.schema.string().optional().describe("Regex pattern to filter files"),
+		directory: tool.schema.string().optional().describe("Directory path for directory scope"),
+		findings: tool.schema
+			.string()
+			.optional()
+			.describe("JSON findings from previously dispatched review agents"),
+	},
+	async execute(args) {
+		return reviewCore(args, process.cwd());
+	},
+});

package/src/tools/state.ts

@@ -0,0 +1,112 @@
+import { tool } from "@opencode-ai/plugin";
+import { appendDecision, loadState, patchState, saveState } from "../orchestrator/state";
+import { getProjectArtifactDir } from "../utils/paths";
+
+const PATCHABLE_FIELDS = ["status", "arenaConfidence", "exploreTriggered"] as const;
+
+interface StateArgs {
+	readonly subcommand: string;
+	readonly field?: string;
+	readonly value?: string;
+	readonly phase?: string;
+	readonly agent?: string;
+	readonly decision?: string;
+	readonly rationale?: string;
+}
+
+export async function stateCore(args: StateArgs, artifactDir: string): Promise<string> {
+	try {
+		switch (args.subcommand) {
+			case "load": {
+				const state = await loadState(artifactDir);
+				if (state === null) {
+					return JSON.stringify({ error: "no_state" });
+				}
+				return JSON.stringify(state);
+			}
+
+			case "get": {
+				if (!args.field) {
+					return JSON.stringify({ error: "field required" });
+				}
+				const state = await loadState(artifactDir);
+				if (state === null) {
+					return JSON.stringify({ error: "no_state" });
+				}
+				const value = state[args.field as keyof typeof state];
+				return JSON.stringify({ field: args.field, value });
+			}
+
+			case "patch": {
+				if (!args.field) {
+					return JSON.stringify({ error: "field required" });
+				}
+				if (!(PATCHABLE_FIELDS as readonly string[]).includes(args.field)) {
+					return JSON.stringify({
+						error: `field not patchable: ${args.field}. Allowed: ${PATCHABLE_FIELDS.join(", ")}`,
+					});
+				}
+				const state = await loadState(artifactDir);
+				if (state === null) {
+					return JSON.stringify({ error: "no_state" });
+				}
+				// Coerce value based on field type
+				let coercedValue: string | boolean | null = args.value ?? null;
+				if (args.field === "exploreTriggered") {
+					coercedValue = args.value === "true";
+				}
+				if (args.field === "arenaConfidence" && args.value === "null") {
+					coercedValue = null;
+				}
+				const updated = patchState(state, { [args.field]: coercedValue });
+				await saveState(updated, artifactDir);
+				return JSON.stringify({ ok: true });
+			}
+
+			case "append-decision": {
+				if (!args.phase || !args.agent || !args.decision || !args.rationale) {
+					return JSON.stringify({
+						error: "phase, agent, decision, and rationale are required",
+					});
+				}
+				const state = await loadState(artifactDir);
+				if (state === null) {
+					return JSON.stringify({ error: "no_state" });
+				}
+				const updated = appendDecision(state, {
+					phase: args.phase,
+					agent: args.agent,
+					decision: args.decision,
+					rationale: args.rationale,
+				});
+				await saveState(updated, artifactDir);
+				return JSON.stringify({ ok: true, decisions: updated.decisions.length });
+			}
+
+			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 ocState = tool({
+	description:
+		"Manage orchestrator pipeline state. Subcommands: load (full state), get (single field), patch (update field), append-decision (add decision entry).",
+	args: {
+		subcommand: tool.schema
+			.enum(["load", "get", "patch", "append-decision"])
+			.describe("Operation to perform"),
+		field: tool.schema.string().optional().describe("Field name for get/patch subcommands"),
+		value: tool.schema.string().optional().describe("Value for patch subcommand"),
+		phase: tool.schema.string().optional().describe("Phase name for append-decision"),
+		agent: tool.schema.string().optional().describe("Agent name for append-decision"),
+		decision: tool.schema.string().optional().describe("Decision text for append-decision"),
+		rationale: tool.schema.string().optional().describe("Rationale text for append-decision"),
+	},
+	async execute(args) {
+		return stateCore(args, getProjectArtifactDir(process.cwd()));
+	},
+});

package/src/utils/fs-helpers.ts

@@ -0,0 +1,39 @@
+import { constants } from "node:fs";
+import { access, copyFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export function isEnoentError(error: unknown): error is NodeJS.ErrnoException {
+	return (
+		error instanceof Error && "code" in error && (error as NodeJS.ErrnoException).code === "ENOENT"
+	);
+}
+
+export async function fileExists(path: string): Promise<boolean> {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function ensureDir(dirPath: string): Promise<void> {
+	await mkdir(dirPath, { recursive: true });
+}
+
+export async function copyIfMissing(source: string, target: string): Promise<{ copied: boolean }> {
+	await ensureDir(dirname(target));
+	try {
+		await copyFile(source, target, constants.COPYFILE_EXCL);
+		return { copied: true };
+	} catch (error: unknown) {
+		if (
+			error instanceof Error &&
+			"code" in error &&
+			(error as NodeJS.ErrnoException).code === "EEXIST"
+		) {
+			return { copied: false };
+		}
+		throw error;
+	}
+}

package/src/utils/gitignore.ts

@@ -0,0 +1,27 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { isEnoentError } from "./fs-helpers";
+
+const GITIGNORE_ENTRY = ".opencode-autopilot/";
+
+export async function ensureGitignore(projectRoot: string): Promise<void> {
+	const gitignorePath = join(projectRoot, ".gitignore");
+
+	let content: string;
+	try {
+		content = await readFile(gitignorePath, "utf-8");
+	} catch (error: unknown) {
+		if (isEnoentError(error)) {
+			await writeFile(gitignorePath, `${GITIGNORE_ENTRY}\n`, "utf-8");
+			return;
+		}
+		throw error;
+	}
+
+	if (content.includes(GITIGNORE_ENTRY)) {
+		return;
+	}
+
+	const suffix = content.endsWith("\n") ? "" : "\n";
+	await writeFile(gitignorePath, `${content}${suffix}${GITIGNORE_ENTRY}\n`, "utf-8");
+}

package/src/utils/paths.ts

@@ -0,0 +1,17 @@
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = import.meta.dir ?? dirname(fileURLToPath(import.meta.url));
+
+export function getGlobalConfigDir(): string {
+	return join(homedir(), ".config", "opencode");
+}
+
+export function getAssetsDir(): string {
+	return join(__dirname, "..", "..", "assets");
+}
+
+export function getProjectArtifactDir(projectRoot: string): string {
+	return join(projectRoot, ".opencode-autopilot");
+}

package/src/utils/validators.ts

@@ -0,0 +1,57 @@
+export const ASSET_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+
+export const MAX_NAME_LENGTH = 64;
+
+export const BUILT_IN_COMMANDS: ReadonlySet<string> = new Set([
+	"init",
+	"undo",
+	"redo",
+	"share",
+	"help",
+	"config",
+	"compact",
+	"clear",
+	"cost",
+	"login",
+	"logout",
+	"bug",
+]);
+
+interface ValidationResult {
+	readonly valid: boolean;
+	readonly error?: string;
+}
+
+export function validateAssetName(name: string): ValidationResult {
+	if (name.length === 0 || name.length > MAX_NAME_LENGTH) {
+		return Object.freeze({
+			valid: false,
+			error: `Name must be 1-${MAX_NAME_LENGTH} characters. Got ${name.length}.`,
+		});
+	}
+
+	if (!ASSET_NAME_REGEX.test(name)) {
+		return Object.freeze({
+			valid: false,
+			error: `Name '${name}' is invalid. Names must be 1-${MAX_NAME_LENGTH} lowercase alphanumeric characters with hyphens (e.g., 'my-agent').`,
+		});
+	}
+
+	return Object.freeze({ valid: true });
+}
+
+export function validateCommandName(name: string): ValidationResult {
+	const assetResult = validateAssetName(name);
+	if (!assetResult.valid) {
+		return assetResult;
+	}
+
+	if (BUILT_IN_COMMANDS.has(name)) {
+		return Object.freeze({
+			valid: false,
+			error: `Command name '${name}' conflicts with a built-in OpenCode command. Choose a different name.`,
+		});
+	}
+
+	return Object.freeze({ valid: true });
+}