@kodrunhq/opencode-autopilot 1.17.0 → 1.19.0

package/src/context/discovery.ts

@@ -0,0 +1,94 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import type { ContextSource, DiscoveryOptions } from "./types";
+
+const CHARS_PER_TOKEN = 4;
+const DEFAULT_MAX_DEPTH = 3;
+const PRIORITY_DEPTH_BONUS = 10;
+
+const CONTEXT_FILE_DEFINITIONS = Object.freeze([
+	Object.freeze({ name: "AGENTS.md", relativePath: "AGENTS.md", priority: 90 }),
+	Object.freeze({ name: "CLAUDE.md", relativePath: "CLAUDE.md", priority: 85 }),
+	Object.freeze({ name: "README.md", relativePath: "README.md", priority: 50 }),
+	Object.freeze({ name: ".opencode/agents.md", relativePath: ".opencode/agents.md", priority: 80 }),
+]);
+
+const discoveryCache = new Map<string, readonly ContextSource[]>();
+
+function createCacheKey(projectRoot: string, maxDepth: number): string {
+	return `${resolve(projectRoot)}::${maxDepth}`;
+}
+
+function buildSearchRoots(projectRoot: string, maxDepth: number): readonly string[] {
+	const roots: string[] = [];
+	let currentRoot = resolve(projectRoot);
+
+	for (let depth = 0; depth <= maxDepth; depth += 1) {
+		roots.push(currentRoot);
+		const parentRoot = dirname(currentRoot);
+		if (parentRoot === currentRoot) {
+			break;
+		}
+		currentRoot = parentRoot;
+	}
+
+	return roots;
+}
+
+function estimateTokens(content: string): number {
+	return Math.ceil(content.length / CHARS_PER_TOKEN);
+}
+
+export function clearContextDiscoveryCache(projectRoot?: string): void {
+	if (!projectRoot) {
+		discoveryCache.clear();
+		return;
+	}
+
+	const projectRootPrefix = `${resolve(projectRoot)}::`;
+	for (const key of discoveryCache.keys()) {
+		if (key.startsWith(projectRootPrefix)) {
+			discoveryCache.delete(key);
+		}
+	}
+}
+
+export async function discoverContextFiles(
+	options: DiscoveryOptions,
+): Promise<readonly ContextSource[]> {
+	const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+	const cacheKey = createCacheKey(options.projectRoot, maxDepth);
+	const cached = discoveryCache.get(cacheKey);
+	if (cached !== undefined) {
+		return cached;
+	}
+
+	const roots = buildSearchRoots(options.projectRoot, maxDepth);
+	const sources: ContextSource[] = [];
+
+	for (const [depth, root] of roots.entries()) {
+		for (const definition of CONTEXT_FILE_DEFINITIONS) {
+			const filePath = join(root, definition.relativePath);
+			try {
+				const content = await readFile(filePath, "utf-8");
+				sources.push({
+					name: definition.name,
+					filePath,
+					content,
+					priority: definition.priority + (maxDepth - depth + 1) * PRIORITY_DEPTH_BONUS,
+					tokenEstimate: estimateTokens(content),
+				});
+			} catch (error: unknown) {
+				if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+					throw error;
+				}
+			}
+		}
+	}
+
+	const orderedSources = [...sources].sort(
+		(left, right) => right.priority - left.priority || left.filePath.localeCompare(right.filePath),
+	);
+	discoveryCache.set(cacheKey, orderedSources);
+	return orderedSources;
+}

package/src/context/index.ts

@@ -0,0 +1,14 @@
+export { allocateBudget, truncateToTokens } from "./budget";
+export { createCompactionHandler } from "./compaction-handler";
+export { clearContextDiscoveryCache, discoverContextFiles } from "./discovery";
+export {
+	type ContextInjector,
+	type ContextInjectorOptions,
+	createContextInjector,
+} from "./injector";
+export type {
+	ContextBudget,
+	ContextInjectionResult,
+	ContextSource,
+	DiscoveryOptions,
+} from "./types";

package/src/context/injector.ts

@@ -0,0 +1,119 @@
+import { getLogger } from "../logging/domains";
+import { allocateBudget, truncateToTokens } from "./budget";
+import { clearContextDiscoveryCache, discoverContextFiles } from "./discovery";
+import type { ContextInjectionResult, ContextSource, DiscoveryOptions } from "./types";
+
+const DEFAULT_TOTAL_BUDGET = 4000;
+const DEFAULT_TTL_MS = 5 * 60 * 1000;
+const logger = getLogger("context", "injector");
+
+export interface ContextInjectorOptions {
+	readonly projectRoot: string;
+	readonly totalBudget?: number;
+	readonly ttlMs?: number;
+	readonly now?: () => number;
+	readonly discover?: (options: DiscoveryOptions) => Promise<readonly ContextSource[]>;
+}
+
+interface InjectorInput {
+	readonly sessionID?: string;
+}
+
+interface InjectorOutput {
+	system: string[];
+}
+
+interface CacheEntry {
+	readonly result: ContextInjectionResult;
+	readonly expiresAt: number;
+}
+
+export interface ContextInjector {
+	(input: InjectorInput, output: InjectorOutput): Promise<void>;
+	clearCache(sessionID?: string): void;
+}
+
+function buildInjectionText(
+	sources: readonly ContextSource[],
+	allocations: ReadonlyMap<string, number>,
+): {
+	readonly injectedText: string;
+	readonly truncated: boolean;
+} {
+	let truncated = false;
+	const sections: string[] = [];
+
+	for (const source of sources) {
+		const allocation = allocations.get(source.filePath) ?? 0;
+		if (allocation <= 0) {
+			continue;
+		}
+
+		if (allocation < source.tokenEstimate) {
+			truncated = true;
+		}
+
+		sections.push(
+			`---\n[Source: ${source.name}]\n${truncateToTokens(source.content, allocation)}\n---`,
+		);
+	}
+
+	return {
+		injectedText: sections.length > 0 ? `\n${sections.join("\n")}\n` : "",
+		truncated,
+	};
+}
+
+export function createContextInjector(options: ContextInjectorOptions): ContextInjector {
+	const discover = options.discover ?? discoverContextFiles;
+	const now = options.now ?? Date.now;
+	const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+	const totalBudget = options.totalBudget ?? DEFAULT_TOTAL_BUDGET;
+	const cache = new Map<string, CacheEntry>();
+
+	const injector: ContextInjector = async (input, output) => {
+		try {
+			if (!input.sessionID) {
+				return;
+			}
+
+			const cached = cache.get(input.sessionID);
+			if (cached !== undefined && cached.expiresAt > now()) {
+				if (cached.result.injectedText.length > 0) {
+					output.system.push(cached.result.injectedText);
+				}
+				return;
+			}
+
+			const sources = await discover({ projectRoot: options.projectRoot, maxDepth: 3 });
+			const { allocations, totalUsed } = allocateBudget(sources, totalBudget);
+			const { injectedText, truncated } = buildInjectionText(sources, allocations);
+
+			const result: ContextInjectionResult = {
+				injectedText,
+				sources,
+				totalTokens: totalUsed,
+				truncated,
+			};
+
+			cache.set(input.sessionID, { result, expiresAt: now() + ttlMs });
+
+			if (injectedText.length > 0) {
+				output.system.push(injectedText);
+			}
+		} catch (error) {
+			logger.warn("context injection failed", { error: String(error) });
+		}
+	};
+
+	injector.clearCache = (sessionID?: string) => {
+		if (sessionID) {
+			cache.delete(sessionID);
+		} else {
+			cache.clear();
+		}
+		clearContextDiscoveryCache(options.projectRoot);
+	};
+
+	return injector;
+}

package/src/context/types.ts

@@ -0,0 +1,24 @@
+export interface ContextSource {
+	readonly name: string;
+	readonly filePath: string;
+	readonly content: string;
+	readonly priority: number;
+	readonly tokenEstimate: number;
+}
+
+export interface ContextBudget {
+	readonly totalTokens: number;
+	readonly allocations: ReadonlyMap<string, number>;
+}
+
+export interface ContextInjectionResult {
+	readonly injectedText: string;
+	readonly sources: readonly ContextSource[];
+	readonly totalTokens: number;
+	readonly truncated: boolean;
+}
+
+export interface DiscoveryOptions {
+	readonly projectRoot: string;
+	readonly maxDepth?: number;
+}

package/src/health/checks.ts

@@ -1,10 +1,13 @@
 import { Database } from "bun:sqlite";
 import { access, readFile, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import type { Config } from "@opencode-ai/plugin";
 import { parse } from "yaml";
 import { loadConfig } from "../config";
+import { getGlobalMcpManager } from "../mcp";
 import { AGENT_NAMES } from "../orchestrator/handlers/types";
+import { ALL_GROUP_IDS } from "../registry/model-groups";
+import { getAllCategories } from "../routing";
 import { detectProjectStackTags, filterSkillsByStack } from "../skills/adaptive-injector";
 import { loadAllSkills } from "../skills/loader";
 import {
@@ -15,6 +18,8 @@ import {
 } from "../utils/paths";
 import type { HealthResult } from "./types";
 
+const VALID_CATEGORY_NAMES = new Set(getAllCategories().map((definition) => definition.category));
+
 /**
  * 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.
@@ -44,7 +49,7 @@ export async function configHealthCheck(configPath?: string): Promise<HealthResu
 	}
 }
 
-const LATEST_CONFIG_VERSION = 6;
+const LATEST_CONFIG_VERSION = 7;
 
 export async function configVersionCheck(configPath?: string): Promise<HealthResult> {
 	try {
@@ -141,13 +146,85 @@ export async function configGroupsCheck(configPath?: string): Promise<HealthResu
 	}
 }
 
+/** v7 config fields that must be present on a v7 config. */
+const V7_REQUIRED_FIELDS: readonly string[] = Object.freeze([
+	"background",
+	"routing",
+	"recovery",
+	"mcp",
+]);
+
+/**
+ * Check that v7 configs contain all four new top-level fields introduced in v7:
+ * background, routing, recovery, and mcp.
+ * Inspects the raw on-disk JSON so that Zod default-filling does not mask
+ * actually-missing fields. Pre-v7 configs receive a pass with a migration notice.
+ */
+export async function configV7FieldsCheck(configPath?: string): Promise<HealthResult> {
+	const resolvedPath = configPath ?? join(getGlobalConfigDir(), "opencode-autopilot.json");
+	try {
+		let raw: Record<string, unknown>;
+		try {
+			const content = await readFile(resolvedPath, "utf-8");
+			raw = JSON.parse(content) as Record<string, unknown>;
+		} catch (error: unknown) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+				return Object.freeze({
+					name: "config-v7-fields",
+					status: "fail" as const,
+					message: "Config file not found",
+				});
+			}
+			throw error;
+		}
+
+		const version = typeof raw.version === "number" ? raw.version : 0;
+
+		if (version < 7) {
+			return Object.freeze({
+				name: "config-v7-fields",
+				status: "pass" as const,
+				message: `Config v${version} will gain v7 fields (background, routing, recovery, mcp) on next load`,
+			});
+		}
+
+		const missingFields = V7_REQUIRED_FIELDS.filter((field) => !(field in raw));
+
+		if (missingFields.length > 0) {
+			return Object.freeze({
+				name: "config-v7-fields",
+				status: "fail" as const,
+				message: `Config v7 is missing required fields: ${missingFields.join(", ")}`,
+				details: Object.freeze(missingFields),
+			});
+		}
+
+		return Object.freeze({
+			name: "config-v7-fields",
+			status: "pass" as const,
+			message: `Config v7 fields present: ${V7_REQUIRED_FIELDS.join(", ")}`,
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "config-v7-fields",
+			status: "fail" as const,
+			message: `Config v7 fields check 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",
+	"coder",
+	"debugger",
+	"planner",
+	"reviewer",
+	"security-auditor",
 ]);
 
 /** Pipeline agent names, derived from AGENT_NAMES in the orchestrator. */
@@ -342,6 +419,88 @@ export async function skillHealthCheck(
 	}
 }
 
+export async function mcpHealthCheck(configPath?: string): Promise<HealthResult> {
+	try {
+		const config = await loadConfig(configPath);
+		if (config === null) {
+			return Object.freeze({
+				name: "mcp-health",
+				status: "fail" as const,
+				message: "Plugin config file not found",
+			});
+		}
+
+		if (!config.mcp.enabled) {
+			return Object.freeze({
+				name: "mcp-health",
+				status: "pass" as const,
+				message: "MCP disabled in config",
+			});
+		}
+
+		const manager = getGlobalMcpManager();
+		if (manager) {
+			const healthResults = await manager.healthCheckAll();
+			if (healthResults.length === 0) {
+				return Object.freeze({
+					name: "mcp-health",
+					status: "pass" as const,
+					message: "MCP enabled, no servers running",
+				});
+			}
+
+			const unhealthy = healthResults.filter((result) => result.state !== "healthy");
+			const details = Object.freeze(
+				healthResults.map((result) => {
+					const status = result.state === "healthy" ? "ok" : result.state;
+					const errorSuffix = result.error ? ` - ${result.error}` : "";
+					return `${result.serverName} (${result.skillName}): ${status}${errorSuffix}`;
+				}),
+			);
+
+			if (unhealthy.length > 0) {
+				return Object.freeze({
+					name: "mcp-health",
+					status: "warn" as const,
+					message: `MCP enabled: ${healthResults.length} server(s), ${unhealthy.length} unhealthy`,
+					details,
+				});
+			}
+
+			return Object.freeze({
+				name: "mcp-health",
+				status: "pass" as const,
+				message: `MCP enabled: ${healthResults.length} server(s) healthy`,
+				details,
+			});
+		}
+
+		const skillsDir = join(configPath ? dirname(configPath) : getGlobalConfigDir(), "skills");
+		const skills = await loadAllSkills(skillsDir);
+		const mcpSkills = [...skills.values()].filter((skill) => skill.frontmatter.mcp !== null);
+		const details = Object.freeze(
+			mcpSkills.map((skill) => {
+				const mcp = skill.frontmatter.mcp;
+				return `${skill.frontmatter.name}: ${mcp?.serverName} (${mcp?.transport})`;
+			}),
+		);
+
+		return Object.freeze({
+			name: "mcp-health",
+			status: "pass" as const,
+			message: `MCP enabled with ${mcpSkills.length} MCP-capable skill${mcpSkills.length === 1 ? "" : "s"} (manager not initialized)`,
+			details,
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "mcp-health",
+			status: "fail" as const,
+			message: `MCP health check failed: ${msg}`,
+		});
+	}
+}
+
 /**
  * Check memory DB health: existence, readability, observation count.
  * Does NOT call getMemoryDb() to avoid creating an empty DB as a side effect.
@@ -505,3 +664,55 @@ export async function commandHealthCheck(targetDir?: string): Promise<HealthResu
 		details: Object.freeze(issues),
 	});
 }
+
+export async function routingHealthCheck(configPath?: string): Promise<HealthResult> {
+	try {
+		const invalidDefinitions = getAllCategories().flatMap((definition) => {
+			const issues: string[] = [];
+			if (!VALID_CATEGORY_NAMES.has(definition.category)) {
+				issues.push(`${definition.category}: unknown category`);
+			}
+			if (!ALL_GROUP_IDS.includes(definition.modelGroup as (typeof ALL_GROUP_IDS)[number])) {
+				issues.push(`${definition.category}: invalid model group '${definition.modelGroup}'`);
+			}
+			if (definition.maxIterations < 1) {
+				issues.push(`${definition.category}: maxIterations must be >= 1`);
+			}
+			if (definition.timeoutSeconds < 1) {
+				issues.push(`${definition.category}: timeoutSeconds must be >= 1`);
+			}
+			return issues;
+		});
+
+		const config = await loadConfig(configPath);
+		const invalidOverrides = Object.keys(config?.routing.categories ?? {}).flatMap(
+			(categoryName) =>
+				VALID_CATEGORY_NAMES.has(categoryName as import("../types/routing").Category)
+					? []
+					: [`Invalid routing override category '${categoryName}'`],
+		);
+
+		const issues = [...invalidDefinitions, ...invalidOverrides];
+		if (issues.length > 0) {
+			return Object.freeze({
+				name: "routing-health",
+				status: "fail" as const,
+				message: `${issues.length} routing issue(s) found`,
+				details: Object.freeze(issues),
+			});
+		}
+
+		return Object.freeze({
+			name: "routing-health",
+			status: "pass" as const,
+			message: `All ${getAllCategories().length} routing categories and overrides are valid`,
+		});
+	} catch (error: unknown) {
+		const msg = error instanceof Error ? error.message : String(error);
+		return Object.freeze({
+			name: "routing-health",
+			status: "fail" as const,
+			message: `Routing health check failed: ${msg}`,
+		});
+	}
+}

package/src/health/index.ts

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

package/src/health/runner.ts

@@ -4,8 +4,11 @@ import {
 	assetHealthCheck,
 	commandHealthCheck,
 	configHealthCheck,
+	configV7FieldsCheck,
+	mcpHealthCheck,
 	memoryHealthCheck,
 	nativeAgentSuppressionHealthCheck,
+	routingHealthCheck,
 	skillHealthCheck,
 } from "./checks";
 import type { HealthReport, HealthResult } from "./types";
@@ -43,16 +46,22 @@ export async function runHealthChecks(options?: {
 }): Promise<HealthReport> {
 	const start = Date.now();
 
+	const configOutcome = await Promise.allSettled([configHealthCheck(options?.configPath)]);
+
 	const settled = await Promise.allSettled([
-		configHealthCheck(options?.configPath),
 		agentHealthCheck(options?.openCodeConfig ?? null),
 		nativeAgentSuppressionHealthCheck(options?.openCodeConfig ?? null),
 		assetHealthCheck(options?.assetsDir, options?.targetDir),
 		skillHealthCheck(options?.projectRoot ?? process.cwd()),
 		memoryHealthCheck(options?.targetDir),
 		commandHealthCheck(options?.targetDir),
+		configV7FieldsCheck(options?.configPath),
+		routingHealthCheck(options?.configPath),
+		mcpHealthCheck(options?.configPath),
 	]);
 
+	const allSettled = [...configOutcome, ...settled];
+
 	const fallbackNames = [
 		"config-validity",
 		"agent-injection",
@@ -61,9 +70,12 @@ export async function runHealthChecks(options?: {
 		"skill-loading",
 		"memory-db",
 		"command-accessibility",
+		"config-v7-fields",
+		"routing-health",
+		"mcp-health",
 	];
 	const results: readonly HealthResult[] = Object.freeze(
-		settled.map((outcome, i) => settledToResult(outcome, fallbackNames[i])),
+		allSettled.map((outcome, i) => settledToResult(outcome, fallbackNames[i])),
 	);
 
 	const allPassed = results.every((r) => r.status === "pass");