@kodrunhq/opencode-autopilot 1.10.0 → 1.12.0

package/src/hooks/anti-slop.ts

@@ -0,0 +1,132 @@
+/**
+ * Anti-slop hook: detects AI-generated comment bloat in code files.
+ * Warn-only (non-blocking) -- fires as PostToolUse after file-writing tools.
+ */
+import { readFile } from "node:fs/promises";
+import { extname, isAbsolute, resolve } from "node:path";
+import {
+	CODE_EXTENSIONS,
+	COMMENT_PATTERNS,
+	EXT_COMMENT_STYLE,
+	SLOP_PATTERNS,
+} from "./slop-patterns";
+
+/** A single detected slop comment occurrence. */
+export interface SlopFinding {
+	readonly line: number;
+	readonly text: string;
+	readonly pattern: string;
+}
+
+/** Returns true if the file path has a code extension eligible for scanning. */
+export function isCodeFile(filePath: string): boolean {
+	return CODE_EXTENSIONS.has(extname(filePath).toLowerCase());
+}
+
+/**
+ * Scans content for slop comments matching curated patterns.
+ * Only examines comment text (not raw code) to avoid false positives.
+ */
+export function scanForSlopComments(content: string, ext: string): readonly SlopFinding[] {
+	const commentStyle = EXT_COMMENT_STYLE[ext];
+	if (!commentStyle) return Object.freeze([]);
+
+	const commentRegex = COMMENT_PATTERNS[commentStyle];
+	if (!commentRegex) return Object.freeze([]);
+
+	const lines = content.split("\n");
+	const findings: SlopFinding[] = [];
+
+	for (let i = 0; i < lines.length; i++) {
+		const match = commentRegex.exec(lines[i]);
+		if (!match?.[1]) continue;
+
+		const commentText = match[1].trim();
+
+		for (const pattern of SLOP_PATTERNS) {
+			if (pattern.test(commentText)) {
+				findings.push(
+					Object.freeze({
+						line: i + 1,
+						text: commentText,
+						pattern: pattern.source,
+					}),
+				);
+				break; // one finding per line
+			}
+		}
+	}
+
+	return Object.freeze(findings);
+}
+
+/** Tools that write files and should be scanned for slop. */
+const FILE_WRITING_TOOLS: ReadonlySet<string> = Object.freeze(
+	new Set(["write_file", "edit_file", "write", "edit", "create_file"]),
+);
+
+/**
+ * Creates a tool.execute.after handler that scans for slop comments.
+ * Best-effort: never throws, never blocks the pipeline.
+ */
+export function createAntiSlopHandler(options: {
+	readonly showToast: (
+		title: string,
+		message: string,
+		variant: "info" | "warning" | "error",
+	) => Promise<void>;
+}) {
+	return async (
+		hookInput: {
+			readonly tool: string;
+			readonly sessionID: string;
+			readonly callID: string;
+			readonly args: unknown;
+		},
+		_output: { title: string; output: string; metadata: unknown },
+	): Promise<void> => {
+		if (!FILE_WRITING_TOOLS.has(hookInput.tool)) return;
+
+		// Extract file path from args with type-safe narrowing
+		const args = hookInput.args;
+		if (args === null || typeof args !== "object") return;
+		const record = args as Record<string, unknown>;
+		const rawPath = record.file_path ?? record.filePath ?? record.path ?? record.file;
+		if (typeof rawPath !== "string" || rawPath.length === 0) return;
+
+		// Validate path is absolute and within cwd (prevent path traversal)
+		if (!isAbsolute(rawPath)) return;
+		const resolved = resolve(rawPath);
+		const cwd = process.cwd();
+		if (!resolved.startsWith(`${cwd}/`) && resolved !== cwd) return;
+
+		if (!isCodeFile(resolved)) return;
+		const ext = extname(resolved).toLowerCase();
+
+		// Read the actual file content — output.output is the tool's result message, not file content
+		let fileContent: string;
+		try {
+			fileContent = await readFile(resolved, "utf-8");
+		} catch {
+			return; // file unreadable — best-effort, skip
+		}
+
+		const findings = scanForSlopComments(fileContent, ext);
+		if (findings.length === 0) return;
+
+		const preview = findings
+			.slice(0, 5)
+			.map((f) => `L${f.line}: ${f.text}`)
+			.join("\n");
+
+		try {
+			await options.showToast(
+				"Anti-Slop Warning",
+				`${findings.length} AI comment(s) detected:\n${preview}`,
+				"warning",
+			);
+		} catch {
+			// best-effort -- toast failure is non-fatal
+		}
+	};
+}

package/src/hooks/slop-patterns.ts

@@ -0,0 +1,71 @@
+/**
+ * Curated regex patterns for detecting AI-generated comment bloat ("slop").
+ * All exports are frozen for immutability.
+ */
+
+/** Code file extensions eligible for anti-slop scanning. */
+export const CODE_EXTENSIONS: ReadonlySet<string> = Object.freeze(
+	new Set([
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".py",
+		".go",
+		".rs",
+		".java",
+		".cs",
+		".rb",
+		".cpp",
+		".c",
+		".h",
+	]),
+);
+
+/** Maps file extension to its single-line comment prefix. */
+export const EXT_COMMENT_STYLE: Readonly<Record<string, string>> = Object.freeze({
+	".ts": "//",
+	".tsx": "//",
+	".js": "//",
+	".jsx": "//",
+	".java": "//",
+	".cs": "//",
+	".go": "//",
+	".rs": "//",
+	".c": "//",
+	".cpp": "//",
+	".h": "//",
+	".py": "#",
+	".rb": "#",
+});
+
+/** Regex to extract comment text from a line given its comment prefix.
+ * Matches both full-line comments and inline trailing comments.
+ * Negative lookbehind (?<!:) prevents matching :// in URLs. */
+export const COMMENT_PATTERNS: Readonly<Record<string, RegExp>> = Object.freeze({
+	"//": /(?<!:)\/\/\s*(.+)/,
+	"#": /#\s*(.+)/,
+});
+
+/**
+ * Patterns matching obvious/sycophantic AI comment text.
+ * Tested against extracted comment body only (not raw code lines).
+ */
+export const SLOP_PATTERNS: readonly RegExp[] = Object.freeze([
+	/^increment\s+.*\s+by\s+\d+$/i,
+	/^decrement\s+.*\s+by\s+\d+$/i,
+	/^return\s+the\s+(result|value|data)\s*$/i,
+	/^(?:this|the)\s+(?:function|method|class)\s+(?:does|will|is used to|handles)/i,
+	/^(?:initialize|init)\s+(?:the\s+)?(?:variable|value|state)/i,
+	/^import\s+(?:the\s+)?(?:necessary|required|needed)/i,
+	/^define\s+(?:the\s+)?(?:interface|type|class|function)/i,
+	/\belegantly?\b/i,
+	/\brobust(?:ly|ness)?\b/i,
+	/\bcomprehensive(?:ly)?\b/i,
+	/\bseamless(?:ly)?\b/i,
+	/\blever(?:age|aging)\b/i,
+	/\bpowerful\b/i,
+	/\bsophisticated\b/i,
+	/\bstate[\s-]of[\s-]the[\s-]art\b/i,
+	/\bcutting[\s-]edge\b/i,
+]);

package/src/index.ts

@@ -2,6 +2,7 @@ import type { Config, Plugin } from "@opencode-ai/plugin";
 import { configHook } from "./agents";
 import { isFirstLoad, loadConfig } from "./config";
 import { runHealthChecks } from "./health/runner";
+import { createAntiSlopHandler } from "./hooks/anti-slop";
 import { installAssets } from "./installer";
 import { createMemoryCaptureHandler, createMemoryInjector, getMemoryDb } from "./memory";
 import { ContextMonitor } from "./observability/context-monitor";
@@ -150,6 +151,9 @@ const plugin: Plugin = async (input) => {
 	const chatMessageHandler = createChatMessageHandler(manager);
 	const toolExecuteAfterHandler = createToolExecuteAfterHandler(manager);
 
+	// --- Anti-slop hook initialization ---
+	const antiSlopHandler = createAntiSlopHandler({ showToast: sdkOps.showToast });
+
 	// --- Memory subsystem initialization ---
 	const memoryConfig = config?.memory ?? {
 		enabled: true,
@@ -288,6 +292,13 @@ const plugin: Plugin = async (input) => {
 			if (fallbackConfig.enabled) {
 				await toolExecuteAfterHandler(hookInput, output);
 			}
+
+			// Anti-slop comment detection (best-effort, non-blocking)
+			try {
+				await antiSlopHandler(hookInput, output);
+			} catch {
+				// best-effort
+			}
 		},
 		"experimental.chat.system.transform": async (input, output) => {
 			if (memoryInjector) {

package/src/installer.ts

@@ -196,21 +196,29 @@ export async function installAssets(
 	// Force-overwrite assets with critical fixes
 	const forceUpdate = await forceUpdateAssets(assetsDir, targetDir);
 
-	const [agents, commands, skills] = await Promise.all([
+	const [agents, commands, skills, templates] = await Promise.all([
 		processFiles(assetsDir, targetDir, "agents"),
 		processFiles(assetsDir, targetDir, "commands"),
 		processSkills(assetsDir, targetDir),
+		processFiles(assetsDir, targetDir, "templates"),
 	]);
 
 	return {
-		copied: [...forceUpdate.updated, ...agents.copied, ...commands.copied, ...skills.copied],
-		skipped: [...agents.skipped, ...commands.skipped, ...skills.skipped],
+		copied: [
+			...forceUpdate.updated,
+			...agents.copied,
+			...commands.copied,
+			...skills.copied,
+			...templates.copied,
+		],
+		skipped: [...agents.skipped, ...commands.skipped, ...skills.skipped, ...templates.skipped],
 		errors: [
 			...cleanup.errors,
 			...forceUpdate.errors,
 			...agents.errors,
 			...commands.errors,
 			...skills.errors,
+			...templates.errors,
 		],
 	};
 }

package/src/orchestrator/fallback/fallback-config.ts

@@ -14,3 +14,24 @@ export type FallbackConfig = z.infer<typeof fallbackConfigSchema>;
 
 // Pre-compute defaults for Zod v4 nested default compatibility
 export const fallbackDefaults = fallbackConfigSchema.parse({});
+
+// --- Test mode sub-schema (v6) ---
+
+export const testModeSchema = z.object({
+	enabled: z.boolean().default(false),
+	sequence: z
+		.array(z.enum(["rate_limit", "quota_exceeded", "service_unavailable", "malformed", "timeout"]))
+		.default([]),
+});
+
+export type TestModeConfig = z.infer<typeof testModeSchema>;
+export const testModeDefaults = testModeSchema.parse({});
+
+// --- V6 fallback schema (extends base with testMode) ---
+
+export const fallbackConfigSchemaV6 = fallbackConfigSchema.extend({
+	testMode: testModeSchema.default(testModeDefaults),
+});
+
+export type FallbackConfigV6 = z.infer<typeof fallbackConfigSchemaV6>;
+export const fallbackDefaultsV6 = fallbackConfigSchemaV6.parse({});

package/src/orchestrator/fallback/mock-interceptor.ts

@@ -0,0 +1,51 @@
+import { createMockError } from "../../observability/mock/mock-provider";
+import type { MockFailureMode } from "../../observability/mock/types";
+import type { TestModeConfig } from "./fallback-config";
+
+/**
+ * Deterministic sequence interceptor for fallback chain testing.
+ * Cycles through a configured sequence of failure modes, generating
+ * mock error objects compatible with the error classifier.
+ */
+export class MockInterceptor {
+	private index = 0;
+	private readonly sequence: readonly MockFailureMode[];
+
+	constructor(sequence: readonly MockFailureMode[]) {
+		this.sequence = sequence;
+	}
+
+	/** Get the next failure mode in the sequence (cycles). */
+	nextMode(): MockFailureMode {
+		if (this.sequence.length === 0) {
+			throw new Error("MockInterceptor: cannot call nextMode() on an empty sequence");
+		}
+		const mode = this.sequence[this.index % this.sequence.length];
+		this.index = (this.index + 1) % this.sequence.length;
+		return mode;
+	}
+
+	/** Get the next mock error object (frozen, matches error-classifier shapes). */
+	nextError(): unknown {
+		return createMockError(this.nextMode());
+	}
+
+	/** Reset the cycle index to 0. */
+	reset(): void {
+		this.index = 0;
+	}
+
+	/** Current position in the sequence. */
+	get position(): number {
+		return this.index;
+	}
+}
+
+/**
+ * Factory: returns MockInterceptor if testMode is enabled and has a
+ * non-empty sequence, null otherwise.
+ */
+export function createMockInterceptor(config: TestModeConfig): MockInterceptor | null {
+	if (!config.enabled || config.sequence.length === 0) return null;
+	return new MockInterceptor(config.sequence as readonly MockFailureMode[]);
+}

package/src/registry/model-groups.ts

@@ -15,6 +15,7 @@ export const AGENT_REGISTRY: Readonly<Record<string, AgentEntry>> = deepFreeze({
 	"oc-architect": { group: "architects" },
 	"oc-planner": { group: "architects" },
 	autopilot: { group: "architects" },
+	planner: { group: "architects" },
 
 	// ── Challengers ────────────────────────────────────────────
 	// Adversarial to Architects: critique proposals, enhance ideas
@@ -22,8 +23,9 @@ export const AGENT_REGISTRY: Readonly<Record<string, AgentEntry>> = deepFreeze({
 	"oc-challenger": { group: "challengers" },
 
 	// ── Builders ───────────────────────────────────────────────
-	// Code generation
+	// Code generation and debugging
 	"oc-implementer": { group: "builders" },
+	debugger: { group: "builders" },
 
 	// ── Reviewers ──────────────────────────────────────────────
 	// Code analysis, adversarial to Builders
@@ -32,6 +34,7 @@ export const AGENT_REGISTRY: Readonly<Record<string, AgentEntry>> = deepFreeze({
 	// src/review/types.ts, not AgentConfig. The review pipeline resolves their
 	// model via resolveModelForGroup("reviewers") directly.
 	"oc-reviewer": { group: "reviewers" },
+	reviewer: { group: "reviewers" },
 
 	// ── Red Team ───────────────────────────────────────────────
 	// Final adversarial pass

package/src/review/stack-gate.ts

@@ -54,6 +54,8 @@ const EXTENSION_TAGS: Readonly<Record<string, readonly string[]>> = Object.freez
 	".svelte": Object.freeze(["svelte", "javascript"]),
 	".kt": Object.freeze(["kotlin"]),
 	".kts": Object.freeze(["kotlin"]),
+	".java": Object.freeze(["java"]),
+	".cs": Object.freeze(["csharp"]),
 });
 
 /**

package/src/skills/adaptive-injector.ts

@@ -7,9 +7,10 @@
  * filtering even before any git diff is available.
  */
 
-import { access } from "node:fs/promises";
+import { access, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { sanitizeTemplateContent } from "../review/sanitize";
+import { isEnoentError } from "../utils/fs-helpers";
 import { resolveDependencyOrder } from "./dependency-resolver";
 import type { LoadedSkill } from "./loader";
 
@@ -32,6 +33,21 @@ const MANIFEST_TAGS: Readonly<Record<string, readonly string[]>> = Object.freeze
 	"requirements.txt": Object.freeze(["python"]),
 	Pipfile: Object.freeze(["python"]),
 	Gemfile: Object.freeze(["ruby"]),
+	"pom.xml": Object.freeze(["java"]),
+	"build.gradle": Object.freeze(["java"]),
+	"build.gradle.kts": Object.freeze(["java"]),
+});
+
+/**
+ * Extension-based manifest patterns for languages that use variable filenames
+ * (e.g., MyProject.csproj, MySolution.sln). Detected via readdir + endsWith
+ * matching on the project root directory. Only checks immediate children —
+ * nested .csproj files (e.g., src/MyProject/MyProject.csproj) require the
+ * .sln file at root or diff-path detection via stack-gate.ts.
+ */
+const EXT_MANIFEST_TAGS: Readonly<Record<string, readonly string[]>> = Object.freeze({
+	".csproj": Object.freeze(["csharp"]),
+	".sln": Object.freeze(["csharp"]),
 });
 
 /**
@@ -39,6 +55,8 @@ const MANIFEST_TAGS: Readonly<Record<string, readonly string[]>> = Object.freeze
  * Complements detectStackTags (which works on file paths from git diff).
  */
 export async function detectProjectStackTags(projectRoot: string): Promise<readonly string[]> {
+	const tags = new Set<string>();
+
 	const results = await Promise.all(
 		Object.entries(MANIFEST_TAGS).map(async ([manifest, manifestTags]) => {
 			try {
@@ -50,7 +68,34 @@ export async function detectProjectStackTags(projectRoot: string): Promise<reado
 		}),
 	);
 
-	return [...new Set(results.flat())];
+	for (const result of results) {
+		for (const tag of result) {
+			tags.add(tag);
+		}
+	}
+
+	// Check extension-based manifests (e.g., *.csproj, *.sln)
+	try {
+		const entries = await readdir(projectRoot);
+		for (const [ext, extTags] of Object.entries(EXT_MANIFEST_TAGS)) {
+			if (entries.some((entry) => entry.endsWith(ext))) {
+				for (const tag of extTags) {
+					tags.add(tag);
+				}
+			}
+		}
+	} catch (error: unknown) {
+		// ENOENT is expected (directory may not exist) — skip silently.
+		// Other errors (EACCES, etc.) are logged but non-fatal.
+		if (!isEnoentError(error)) {
+			console.error(
+				"[adaptive-injector] readdir failed for project root, skipping extension detection:",
+				error instanceof Error ? error.message : String(error),
+			);
+		}
+	}
+
+	return [...tags];
 }
 
 /**

package/src/tools/configure.ts

@@ -314,7 +314,7 @@ async function handleCommit(configPath?: string): Promise<string> {
 	}
 	const newConfig = {
 		...currentConfig,
-		version: 5 as const,
+		version: 6 as const,
 		configured: true,
 		groups: groupsRecord,
 		overrides: currentConfig.overrides ?? {},

package/src/tools/doctor.ts

@@ -21,6 +21,7 @@ interface DoctorOptions {
 	readonly openCodeConfig?: Config | null;
 	readonly assetsDir?: string;
 	readonly targetDir?: string;
+	readonly projectRoot?: string;
 }
 
 /**
@@ -31,6 +32,10 @@ const FIX_SUGGESTIONS: Readonly<Record<string, string>> = Object.freeze({
 		"Run `bunx @kodrunhq/opencode-autopilot 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",
+	"skill-loading": "Ensure skills directory exists in ~/.config/opencode/skills/",
+	"memory-db":
+		"Memory DB is created automatically on first memory capture -- use the plugin normally to initialize",
+	"command-accessibility": "Restart OpenCode to trigger command reinstallation from bundled assets",
 });
 
 function getFixSuggestion(checkName: string): string {
@@ -72,6 +77,7 @@ export async function doctorCore(options?: DoctorOptions): Promise<string> {
 		openCodeConfig: options?.openCodeConfig,
 		assetsDir: options?.assetsDir,
 		targetDir: options?.targetDir,
+		projectRoot: options?.projectRoot,
 	});
 
 	// Map health results to doctor checks with fix suggestions

package/src/utils/language-resolver.ts

@@ -0,0 +1,34 @@
+import { detectProjectStackTags } from "../skills/adaptive-injector";
+
+/** Cache: projectRoot -> resolved language string. */
+const cache = new Map<string, string>();
+
+/**
+ * Resolve project language tags as a human-readable string.
+ * Caches per projectRoot to avoid repeated filesystem access.
+ */
+export async function resolveLanguageTag(projectRoot: string): Promise<string> {
+	const cached = cache.get(projectRoot);
+	if (cached !== undefined) return cached;
+
+	try {
+		const tags = await detectProjectStackTags(projectRoot);
+		const result = tags.length > 0 ? [...tags].sort().join(", ") : "unknown";
+		cache.set(projectRoot, result);
+		return result;
+	} catch {
+		return "unknown";
+	}
+}
+
+/**
+ * Substitute $LANGUAGE in a text string with the resolved language tag.
+ */
+export function substituteLanguageVar(text: string, language: string): string {
+	return text.replaceAll("$LANGUAGE", language);
+}
+
+/** Clear the language cache (for testing). */
+export function clearLanguageCache(): void {
+	cache.clear();
+}