@kodrunhq/opencode-autopilot 0.1.3 → 1.1.0

package/src/tools/configure.ts

@@ -0,0 +1,320 @@
+import type { Config } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import { createDefaultConfig, loadConfig, saveConfig } from "../config";
+import { checkDiversity } from "../registry/diversity";
+import { diagnose } from "../registry/doctor";
+import {
+	AGENT_REGISTRY,
+	ALL_GROUP_IDS,
+	DIVERSITY_RULES,
+	GROUP_DEFINITIONS,
+} from "../registry/model-groups";
+import type { DiversityWarning, GroupModelAssignment } from "../registry/types";
+
+// --- Module-level state ---
+
+// Module-level mutable state is intentional: oc_configure is a session-scoped
+// workflow where assignments accumulate across multiple "assign" calls before
+// being persisted by "commit". The Map is cleared on commit and reset.
+
+/**
+ * In-progress group assignments, keyed by GroupId.
+ * Populated by "assign" subcommand, persisted by "commit", cleared by "reset".
+ * Held in memory — configuration is a single-session flow.
+ */
+let pendingAssignments: Map<string, GroupModelAssignment> = new Map();
+
+/**
+ * Reference to the OpenCode host config, set by the plugin's config hook.
+ * Retained for potential future use by subcommands.
+ */
+// biome-ignore lint/correctness/noUnusedVariables: retained for API compatibility
+let openCodeConfig: Config | null = null;
+
+/**
+ * Provider data from the OpenCode SDK, set during plugin initialization.
+ * Each entry maps a provider ID to its available models.
+ */
+let availableProviders: ReadonlyArray<{
+	readonly id: string;
+	readonly name: string;
+	readonly models: Readonly<Record<string, { readonly id: string; readonly name: string }>>;
+}> = [];
+
+// --- Exported helpers for test/plugin wiring ---
+
+export function resetPendingAssignments(): void {
+	pendingAssignments = new Map();
+	availableProviders = [];
+}
+
+export function setOpenCodeConfig(config: Config | null): void {
+	openCodeConfig = config;
+}
+
+export function setAvailableProviders(
+	providers: ReadonlyArray<{
+		readonly id: string;
+		readonly name: string;
+		readonly models: Readonly<Record<string, { readonly id: string; readonly name: string }>>;
+	}>,
+): void {
+	availableProviders = providers;
+}
+
+// --- Core logic ---
+
+interface ConfigureArgs {
+	readonly subcommand: "start" | "assign" | "commit" | "doctor" | "reset";
+	readonly group?: string;
+	readonly primary?: string;
+	readonly fallbacks?: string;
+}
+
+/**
+ * Discover available models from the stored provider data.
+ * Returns a map of provider ID -> list of "providerId/modelId" strings.
+ */
+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}`);
+		}
+		if (modelIds.length > 0) {
+			modelsByProvider.set(provider.id, modelIds);
+		}
+	}
+
+	return modelsByProvider;
+}
+
+function serializeDiversityWarnings(warnings: readonly DiversityWarning[]): readonly {
+	groups: readonly string[];
+	severity: string;
+	sharedFamily: string;
+	reason: string;
+}[] {
+	return warnings.map((w) => ({
+		groups: w.groups,
+		severity: w.rule.severity,
+		sharedFamily: w.sharedFamily,
+		reason: w.rule.reason,
+	}));
+}
+
+async function handleStart(configPath?: string): Promise<string> {
+	const modelsByProvider = discoverAvailableModels();
+
+	// Load current plugin config to show existing assignments
+	const currentConfig = await loadConfig(configPath);
+
+	// Build groups with agents derived from AGENT_REGISTRY
+	const groups = ALL_GROUP_IDS.map((groupId) => {
+		const def = GROUP_DEFINITIONS[groupId];
+		const agents = Object.entries(AGENT_REGISTRY)
+			.filter(([, entry]) => entry.group === groupId)
+			.map(([name]) => name);
+
+		return {
+			id: def.id,
+			label: def.label,
+			purpose: def.purpose,
+			recommendation: def.recommendation,
+			tier: def.tier,
+			order: def.order,
+			agents,
+			currentAssignment: currentConfig?.groups[groupId] ?? null,
+		};
+	});
+
+	return JSON.stringify({
+		action: "configure",
+		stage: "start",
+		availableModels: Object.fromEntries(modelsByProvider),
+		groups,
+		currentConfig: currentConfig
+			? { configured: currentConfig.configured, groups: currentConfig.groups }
+			: null,
+		diversityRules: DIVERSITY_RULES,
+	});
+}
+
+function handleAssign(args: ConfigureArgs): string {
+	const { group, primary, fallbacks: fallbacksStr } = args;
+
+	// Validate group
+	if (!group || !ALL_GROUP_IDS.includes(group as (typeof ALL_GROUP_IDS)[number])) {
+		return JSON.stringify({
+			action: "error",
+			message: `Invalid group: '${group ?? ""}'. Valid groups: ${ALL_GROUP_IDS.join(", ")}`,
+		});
+	}
+
+	// Validate primary
+	if (!primary || primary.trim().length === 0) {
+		return JSON.stringify({
+			action: "error",
+			message: "Primary model is required for assign subcommand.",
+		});
+	}
+
+	const trimmedPrimary = primary.trim();
+
+	// Parse fallbacks
+	const parsedFallbacks = fallbacksStr
+		? fallbacksStr
+				.split(",")
+				.map((s) => s.trim())
+				.filter(Boolean)
+		: [];
+
+	// Store assignment
+	const assignment: GroupModelAssignment = Object.freeze({
+		primary: trimmedPrimary,
+		fallbacks: Object.freeze(parsedFallbacks),
+	});
+	pendingAssignments.set(group, assignment);
+
+	// Run diversity check on all pending assignments
+	const assignmentRecord: Record<string, GroupModelAssignment> =
+		Object.fromEntries(pendingAssignments);
+	const diversityWarnings = serializeDiversityWarnings(checkDiversity(assignmentRecord));
+
+	return JSON.stringify({
+		action: "configure",
+		stage: "assigned",
+		group,
+		primary: trimmedPrimary,
+		fallbacks: parsedFallbacks,
+		assignedCount: pendingAssignments.size,
+		totalGroups: ALL_GROUP_IDS.length,
+		diversityWarnings,
+	});
+}
+
+async function handleCommit(configPath?: string): Promise<string> {
+	// Validate all groups assigned
+	if (pendingAssignments.size < ALL_GROUP_IDS.length) {
+		const assigned = new Set(pendingAssignments.keys());
+		const missing = ALL_GROUP_IDS.filter((id) => !assigned.has(id));
+		return JSON.stringify({
+			action: "error",
+			message: `Cannot commit: ${missing.length} group(s) missing assignments: ${missing.join(", ")}`,
+		});
+	}
+
+	// Load current config or create default
+	const currentConfig = (await loadConfig(configPath)) ?? createDefaultConfig();
+
+	// Build new config — convert readonly fallbacks to mutable for Zod schema compatibility
+	const groupsRecord: Record<string, { primary: string; fallbacks: string[] }> = {};
+	for (const [key, val] of pendingAssignments) {
+		groupsRecord[key] = { primary: val.primary, fallbacks: [...val.fallbacks] };
+	}
+	const newConfig = {
+		...currentConfig,
+		version: 4 as const,
+		configured: true,
+		groups: groupsRecord,
+		overrides: currentConfig.overrides ?? {},
+	};
+
+	// Save
+	await saveConfig(newConfig, configPath);
+
+	// Clear pending
+	const savedGroups = { ...groupsRecord };
+	pendingAssignments.clear();
+
+	// Final diversity check
+	const diversityWarnings = serializeDiversityWarnings(checkDiversity(savedGroups));
+
+	return JSON.stringify({
+		action: "configure",
+		stage: "committed",
+		groups: savedGroups,
+		diversityWarnings,
+		configPath: configPath ?? "~/.config/opencode/opencode-autopilot.json",
+	});
+}
+
+async function handleDoctor(configPath?: string): Promise<string> {
+	const config = await loadConfig(configPath);
+	const result = diagnose(config);
+
+	return JSON.stringify({
+		action: "configure",
+		stage: "doctor",
+		checks: {
+			configExists: result.configExists,
+			schemaValid: result.schemaValid,
+			configured: result.configured,
+			groupsAssigned: result.groupsAssigned,
+		},
+		diversityWarnings: serializeDiversityWarnings(result.diversityWarnings),
+		allPassed: result.allPassed,
+	});
+}
+
+function handleReset(): string {
+	pendingAssignments.clear();
+	return JSON.stringify({
+		action: "configure",
+		stage: "reset",
+		message: "All in-progress assignments cleared.",
+	});
+}
+
+// --- Public API ---
+
+export async function configureCore(args: ConfigureArgs, configPath?: string): Promise<string> {
+	switch (args.subcommand) {
+		case "start":
+			return handleStart(configPath);
+		case "assign":
+			return handleAssign(args);
+		case "commit":
+			return handleCommit(configPath);
+		case "doctor":
+			return handleDoctor(configPath);
+		case "reset":
+			return handleReset();
+		default:
+			return JSON.stringify({
+				action: "error",
+				message: `Unknown subcommand: '${args.subcommand}'`,
+			});
+	}
+}
+
+// --- Tool wrapper ---
+
+export const ocConfigure = tool({
+	description:
+		"Configure model assignments for opencode-autopilot agent groups. " +
+		"Subcommands: start (discover models), assign (set group model), " +
+		"commit (persist), doctor (diagnose), reset (clear in-progress).",
+	args: {
+		subcommand: tool.schema
+			.enum(["start", "assign", "commit", "doctor", "reset"])
+			.describe("Action to perform"),
+		group: tool.schema
+			.string()
+			.optional()
+			.describe("Group ID for assign subcommand (e.g. 'architects')"),
+		primary: tool.schema
+			.string()
+			.optional()
+			.describe("Primary model ID for assign subcommand (e.g. 'anthropic/claude-opus-4-6')"),
+		fallbacks: tool.schema
+			.string()
+			.optional()
+			.describe("Comma-separated fallback model IDs for assign subcommand"),
+	},
+	async execute(args) {
+		return configureCore(args);
+	},
+});

package/assets/agents/placeholder-agent.md

@@ -1,13 +0,0 @@
----
-description: A placeholder agent installed by opencode-autopilot to verify the plugin is working
-mode: all
-permission:
-  read: allow
-  edit: deny
-  bash: deny
-  webfetch: deny
-  task: deny
----
-You are a placeholder agent installed by the opencode-autopilot plugin. Your purpose is to confirm the plugin's asset installation is working correctly.
-
-When invoked, explain that you are a placeholder and suggest the user explore other agents provided by the opencode-autopilot plugin.

package/assets/commands/configure.md

@@ -1,17 +0,0 @@
----
-description: Configure the opencode-autopilot plugin -- assign models to agents
----
-The opencode-autopilot plugin supports configuration for model mapping. You can assign specific models to each agent provided by the plugin by editing the config file at `~/.config/opencode/opencode-autopilot.json`.
-
-The config file uses this format:
-```json
-{
-  "version": 1,
-  "configured": true,
-  "models": {
-    "agent-name": "provider/model-id"
-  }
-}
-```
-
-Note: An interactive configuration tool will be added in a future phase to automate this process.

package/src/tools/placeholder.ts

@@ -1,11 +0,0 @@
-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}`;
-	},
-});