@oh-my-pi/pi-coding-agent 12.8.2 → 12.10.0

package/src/discovery/cline.ts

@@ -10,8 +10,7 @@ import { readDirEntries, readFile } from "../capability/fs";
 import type { Rule } from "../capability/rule";
 import { ruleCapability } from "../capability/rule";
 import type { LoadContext, LoadResult } from "../capability/types";
-import { parseFrontmatter } from "../utils/frontmatter";
-import { createSourceMeta, loadFilesFromDir } from "./helpers";
+import { buildRuleFromMarkdown, createSourceMeta, loadFilesFromDir } from "./helpers";
 
 const PROVIDER_ID = "cline";
 const DISPLAY_NAME = "Cline";
@@ -53,29 +52,8 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 		// Directory format: load all *.md files
 		const result = await loadFilesFromDir(ctx, found.path, PROVIDER_ID, "project", {
 			extensions: ["md"],
-			transform: (name, content, path, source) => {
-				const { frontmatter, body } = parseFrontmatter(content, { source: path });
-				const ruleName = name.replace(/\.md$/, "");
-
-				// Parse globs (can be array or single string)
-				let globs: string[] | undefined;
-				if (Array.isArray(frontmatter.globs)) {
-					globs = frontmatter.globs.filter((g): g is string => typeof g === "string");
-				} else if (typeof frontmatter.globs === "string") {
-					globs = [frontmatter.globs];
-				}
-
-				return {
-					name: ruleName,
-					path,
-					content: body,
-					globs,
-					alwaysApply: typeof frontmatter.alwaysApply === "boolean" ? frontmatter.alwaysApply : undefined,
-					description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
-					ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
-					_source: source,
-				};
-			},
+			transform: (name, content, path, source) =>
+				buildRuleFromMarkdown(name, content, path, source, { stripNamePattern: /\.md$/ }),
 		});
 
 		items.push(...result.items);
@@ -88,27 +66,8 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 			return { items, warnings };
 		}
 
-		const { frontmatter, body } = parseFrontmatter(content, { source: found.path });
 		const source = createSourceMeta(PROVIDER_ID, found.path, "project");
-
-		// Parse globs (can be array or single string)
-		let globs: string[] | undefined;
-		if (Array.isArray(frontmatter.globs)) {
-			globs = frontmatter.globs.filter((g): g is string => typeof g === "string");
-		} else if (typeof frontmatter.globs === "string") {
-			globs = [frontmatter.globs];
-		}
-
-		items.push({
-			name: "clinerules",
-			path: found.path,
-			content: body,
-			globs,
-			alwaysApply: typeof frontmatter.alwaysApply === "boolean" ? frontmatter.alwaysApply : undefined,
-			description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
-			ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
-			_source: source,
-		});
+		items.push(buildRuleFromMarkdown("clinerules.md", content, found.path, source, { ruleName: "clinerules" }));
 	}
 
 	return { items, warnings };

package/src/discovery/cursor.ts

@@ -21,8 +21,8 @@ import { ruleCapability } from "../capability/rule";
 import type { Settings } from "../capability/settings";
 import { settingsCapability } from "../capability/settings";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
-import { parseFrontmatter } from "../utils/frontmatter";
 import {
+	buildRuleFromMarkdown,
 	createSourceMeta,
 	expandEnvVarsDeep,
 	getProjectPath,
@@ -137,34 +137,7 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 }
 
 function transformMDCRule(name: string, content: string, path: string, source: SourceMeta): Rule {
-	const { frontmatter, body } = parseFrontmatter(content, { source: path });
-
-	// Extract frontmatter fields
-	const description = typeof frontmatter.description === "string" ? frontmatter.description : undefined;
-	const alwaysApply = frontmatter.alwaysApply === true;
-	const ttsrTrigger = typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined;
-
-	// Parse globs (can be array or single string)
-	let globs: string[] | undefined;
-	if (Array.isArray(frontmatter.globs)) {
-		globs = frontmatter.globs.filter((g): g is string => typeof g === "string");
-	} else if (typeof frontmatter.globs === "string") {
-		globs = [frontmatter.globs];
-	}
-
-	// Derive name from filename (strip extension)
-	const ruleName = name.replace(/\.(mdc|md)$/, "");
-
-	return {
-		name: ruleName,
-		path,
-		content: body,
-		description,
-		alwaysApply,
-		globs,
-		ttsrTrigger,
-		_source: source,
-	};
+	return buildRuleFromMarkdown(name, content, path, source, { stripNamePattern: /\.(mdc|md)$/ });
 }
 
 // =============================================================================

package/src/discovery/helpers.ts

@@ -7,6 +7,7 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { FileType, glob } from "@oh-my-pi/pi-natives";
 import { CONFIG_DIR_NAME } from "@oh-my-pi/pi-utils/dirs";
 import { readFile } from "../capability/fs";
+import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 import { parseFrontmatter } from "../utils/frontmatter";
@@ -60,6 +61,11 @@ export const SOURCE_PATHS = {
 		userAgent: ".gemini",
 		projectDir: ".gemini",
 	},
+	opencode: {
+		userBase: ".config/opencode",
+		userAgent: ".config/opencode",
+		projectDir: ".opencode",
+	},
 	cursor: {
 		userBase: ".cursor",
 		userAgent: ".cursor",
@@ -158,6 +164,43 @@ export function parseArrayOrCSV(value: unknown): string[] | undefined {
 	return undefined;
 }
 
+/**
+ * Build a canonical rule item from a markdown/markdown-frontmatter document.
+ */
+export function buildRuleFromMarkdown(
+	name: string,
+	content: string,
+	filePath: string,
+	source: SourceMeta,
+	options?: {
+		ruleName?: string;
+		stripNamePattern?: RegExp;
+	},
+): Rule {
+	const { frontmatter, body } = parseFrontmatter(content, { source: filePath });
+	const { condition, scope } = parseRuleConditionAndScope(frontmatter as RuleFrontmatter);
+
+	let globs: string[] | undefined;
+	if (Array.isArray(frontmatter.globs)) {
+		globs = frontmatter.globs.filter((item): item is string => typeof item === "string");
+	} else if (typeof frontmatter.globs === "string") {
+		globs = [frontmatter.globs];
+	}
+
+	const resolvedName = options?.ruleName ?? name.replace(options?.stripNamePattern ?? /\.(md|mdc)$/, "");
+	return {
+		name: resolvedName,
+		path: filePath,
+		content: body,
+		globs,
+		alwaysApply: frontmatter.alwaysApply === true,
+		description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
+		condition,
+		scope,
+		_source: source,
+	};
+}
+
 /**
  * Parse model field into a prioritized list.
  */

package/src/discovery/index.ts

@@ -29,6 +29,7 @@ import "./agents";
 import "./codex";
 import "./cursor";
 import "./gemini";
+import "./opencode";
 import "./github";
 import "./mcp-json";
 import "./ssh";

package/src/discovery/opencode.ts

@@ -0,0 +1,394 @@
+/**
+ * OpenCode Discovery Provider
+ *
+ * Loads configuration from OpenCode's config directories:
+ * - User: ~/.config/opencode/
+ * - Project: .opencode/ (cwd) and opencode.json (project root)
+ *
+ * Capabilities:
+ * - context-files: AGENTS.md (user-level only at ~/.config/opencode/AGENTS.md)
+ * - mcps: From opencode.json "mcp" key
+ * - settings: From opencode.json
+ * - skills: From skills/ subdirectories
+ * - slash-commands: From commands/ subdirectories
+ * - extension-modules: From plugins/ subdirectories
+ *
+ * Priority: 55 (tool-specific provider)
+ */
+import * as path from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
+import { registerProvider } from "../capability";
+import { type ContextFile, contextFileCapability } from "../capability/context-file";
+import { type ExtensionModule, extensionModuleCapability } from "../capability/extension-module";
+import { readFile } from "../capability/fs";
+import { type MCPServer, mcpCapability } from "../capability/mcp";
+import { type Settings, settingsCapability } from "../capability/settings";
+import { type Skill, skillCapability } from "../capability/skill";
+import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
+import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import { parseFrontmatter } from "../utils/frontmatter";
+import {
+	createSourceMeta,
+	discoverExtensionModulePaths,
+	expandEnvVarsDeep,
+	getExtensionNameFromPath,
+	getProjectPath,
+	getUserPath,
+	loadFilesFromDir,
+	loadSkillsFromDir,
+	parseJSON,
+} from "./helpers";
+
+const PROVIDER_ID = "opencode";
+const DISPLAY_NAME = "OpenCode";
+const PRIORITY = 55;
+
+// =============================================================================
+// JSON Config Loading
+// =============================================================================
+
+async function loadJsonConfig(configPath: string): Promise<Record<string, unknown> | null> {
+	const content = await readFile(configPath);
+	if (!content) return null;
+
+	const parsed = parseJSON<Record<string, unknown>>(content);
+	if (!parsed) {
+		logger.warn("Failed to parse OpenCode JSON config", { path: configPath });
+		return null;
+	}
+	return parsed;
+}
+
+// =============================================================================
+// Context Files (AGENTS.md)
+// =============================================================================
+
+async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFile>> {
+	const items: ContextFile[] = [];
+	const warnings: string[] = [];
+
+	// User-level only: ~/.config/opencode/AGENTS.md
+	const userAgentsMd = getUserPath(ctx, "opencode", "AGENTS.md");
+	if (userAgentsMd) {
+		const content = await readFile(userAgentsMd);
+		if (content) {
+			items.push({
+				path: userAgentsMd,
+				content,
+				level: "user",
+				_source: createSourceMeta(PROVIDER_ID, userAgentsMd, "user"),
+			});
+		}
+	}
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// MCP Servers (opencode.json → mcp)
+// =============================================================================
+
+/** OpenCode MCP server config (from opencode.json "mcp" key) */
+interface OpenCodeMCPConfig {
+	type?: "local" | "remote";
+	command?: string;
+	args?: string[];
+	env?: Record<string, string>;
+	url?: string;
+	headers?: Record<string, string>;
+	enabled?: boolean;
+	timeout?: number;
+}
+
+async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
+	const items: MCPServer[] = [];
+	const warnings: string[] = [];
+
+	// User-level: ~/.config/opencode/opencode.json
+	const userConfigPath = getUserPath(ctx, "opencode", "opencode.json");
+	if (userConfigPath) {
+		const config = await loadJsonConfig(userConfigPath);
+		if (config) {
+			const result = extractMCPServers(config, userConfigPath, "user");
+			items.push(...result.items);
+			if (result.warnings) warnings.push(...result.warnings);
+		}
+	}
+
+	// Project-level: opencode.json in project root
+	const projectConfigPath = path.join(ctx.cwd, "opencode.json");
+	const projectConfig = await loadJsonConfig(projectConfigPath);
+	if (projectConfig) {
+		const result = extractMCPServers(projectConfig, projectConfigPath, "project");
+		items.push(...result.items);
+		if (result.warnings) warnings.push(...result.warnings);
+	}
+
+	return { items, warnings };
+}
+
+function extractMCPServers(
+	config: Record<string, unknown>,
+	configPath: string,
+	level: "user" | "project",
+): LoadResult<MCPServer> {
+	const items: MCPServer[] = [];
+	const warnings: string[] = [];
+
+	if (!config.mcp || typeof config.mcp !== "object") {
+		return { items, warnings };
+	}
+
+	const servers = expandEnvVarsDeep(config.mcp as Record<string, unknown>);
+
+	for (const [name, raw] of Object.entries(servers)) {
+		if (!raw || typeof raw !== "object") {
+			warnings.push(`Invalid MCP config for "${name}" in ${configPath}`);
+			continue;
+		}
+
+		const serverConfig = raw as OpenCodeMCPConfig;
+
+		// Determine transport from OpenCode's "type" field
+		let transport: "stdio" | "sse" | "http" | undefined;
+		if (serverConfig.type === "local") {
+			transport = "stdio";
+		} else if (serverConfig.type === "remote") {
+			transport = "http";
+		} else if (serverConfig.url) {
+			transport = "http";
+		} else if (serverConfig.command) {
+			transport = "stdio";
+		}
+
+		items.push({
+			name,
+			command: serverConfig.command,
+			args: Array.isArray(serverConfig.args) ? (serverConfig.args as string[]) : undefined,
+			env: serverConfig.env && typeof serverConfig.env === "object" ? serverConfig.env : undefined,
+			url: typeof serverConfig.url === "string" ? serverConfig.url : undefined,
+			headers: serverConfig.headers && typeof serverConfig.headers === "object" ? serverConfig.headers : undefined,
+			enabled: serverConfig.enabled,
+			timeout: typeof serverConfig.timeout === "number" ? serverConfig.timeout : undefined,
+			transport,
+			_source: createSourceMeta(PROVIDER_ID, configPath, level),
+		});
+	}
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// Skills (skills/)
+// =============================================================================
+
+async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	const userSkillsDir = getUserPath(ctx, "opencode", "skills");
+	const projectSkillsDir = getProjectPath(ctx, "opencode", "skills");
+
+	const promises: Promise<LoadResult<Skill>>[] = [];
+
+	if (userSkillsDir) {
+		promises.push(
+			loadSkillsFromDir(ctx, {
+				dir: userSkillsDir,
+				providerId: PROVIDER_ID,
+				level: "user",
+			}),
+		);
+	}
+
+	if (projectSkillsDir) {
+		promises.push(
+			loadSkillsFromDir(ctx, {
+				dir: projectSkillsDir,
+				providerId: PROVIDER_ID,
+				level: "project",
+			}),
+		);
+	}
+
+	const results = await Promise.all(promises);
+	const items = results.flatMap(r => r.items);
+	const warnings = results.flatMap(r => r.warnings || []);
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// Extension Modules (plugins/)
+// =============================================================================
+
+async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<ExtensionModule>> {
+	const userPluginsDir = getUserPath(ctx, "opencode", "plugins");
+	const projectPluginsDir = getProjectPath(ctx, "opencode", "plugins");
+
+	const [userPaths, projectPaths] = await Promise.all([
+		userPluginsDir ? discoverExtensionModulePaths(ctx, userPluginsDir) : Promise.resolve([]),
+		projectPluginsDir ? discoverExtensionModulePaths(ctx, projectPluginsDir) : Promise.resolve([]),
+	]);
+
+	const items: ExtensionModule[] = [
+		...userPaths.map(extPath => ({
+			name: getExtensionNameFromPath(extPath),
+			path: extPath,
+			level: "user" as const,
+			_source: createSourceMeta(PROVIDER_ID, extPath, "user"),
+		})),
+		...projectPaths.map(extPath => ({
+			name: getExtensionNameFromPath(extPath),
+			path: extPath,
+			level: "project" as const,
+			_source: createSourceMeta(PROVIDER_ID, extPath, "project"),
+		})),
+	];
+
+	return { items, warnings: [] };
+}
+
+// =============================================================================
+// Slash Commands (commands/)
+// =============================================================================
+
+async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
+	const userCommandsDir = getUserPath(ctx, "opencode", "commands");
+	const projectCommandsDir = getProjectPath(ctx, "opencode", "commands");
+
+	const transformCommand =
+		(level: "user" | "project") => (name: string, content: string, filePath: string, source: SourceMeta) => {
+			const { frontmatter, body } = parseFrontmatter(content, { source: filePath });
+			const commandName = frontmatter.name || name.replace(/\.md$/, "");
+			return {
+				name: String(commandName),
+				path: filePath,
+				content: body,
+				level,
+				_source: source,
+			};
+		};
+
+	const promises: Promise<LoadResult<SlashCommand>>[] = [];
+
+	if (userCommandsDir) {
+		promises.push(
+			loadFilesFromDir(ctx, userCommandsDir, PROVIDER_ID, "user", {
+				extensions: ["md"],
+				transform: transformCommand("user"),
+			}),
+		);
+	}
+
+	if (projectCommandsDir) {
+		promises.push(
+			loadFilesFromDir(ctx, projectCommandsDir, PROVIDER_ID, "project", {
+				extensions: ["md"],
+				transform: transformCommand("project"),
+			}),
+		);
+	}
+
+	const results = await Promise.all(promises);
+	const items = results.flatMap(r => r.items);
+	const warnings = results.flatMap(r => r.warnings || []);
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// Settings (opencode.json)
+// =============================================================================
+
+async function loadSettings(ctx: LoadContext): Promise<LoadResult<Settings>> {
+	const items: Settings[] = [];
+	const warnings: string[] = [];
+
+	// User-level: ~/.config/opencode/opencode.json
+	const userConfigPath = getUserPath(ctx, "opencode", "opencode.json");
+	if (userConfigPath) {
+		const content = await readFile(userConfigPath);
+		if (content) {
+			const parsed = parseJSON<Record<string, unknown>>(content);
+			if (parsed) {
+				items.push({
+					path: userConfigPath,
+					data: parsed,
+					level: "user",
+					_source: createSourceMeta(PROVIDER_ID, userConfigPath, "user"),
+				});
+			} else {
+				warnings.push(`Invalid JSON in ${userConfigPath}`);
+			}
+		}
+	}
+
+	// Project-level: opencode.json in project root
+	const projectConfigPath = path.join(ctx.cwd, "opencode.json");
+	const content = await readFile(projectConfigPath);
+	if (content) {
+		const parsed = parseJSON<Record<string, unknown>>(content);
+		if (parsed) {
+			items.push({
+				path: projectConfigPath,
+				data: parsed,
+				level: "project",
+				_source: createSourceMeta(PROVIDER_ID, projectConfigPath, "project"),
+			});
+		} else {
+			warnings.push(`Invalid JSON in ${projectConfigPath}`);
+		}
+	}
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// Provider Registration
+// =============================================================================
+
+registerProvider(contextFileCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load AGENTS.md from ~/.config/opencode/",
+	priority: PRIORITY,
+	load: loadContextFiles,
+});
+
+registerProvider(mcpCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load MCP servers from opencode.json mcp key",
+	priority: PRIORITY,
+	load: loadMCPServers,
+});
+
+registerProvider(skillCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load skills from ~/.config/opencode/skills/ and .opencode/skills/",
+	priority: PRIORITY,
+	load: loadSkills,
+});
+
+registerProvider(extensionModuleCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load extension modules from ~/.config/opencode/plugins/ and .opencode/plugins/",
+	priority: PRIORITY,
+	load: loadExtensionModules,
+});
+
+registerProvider(slashCommandCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load slash commands from ~/.config/opencode/commands/ and .opencode/commands/",
+	priority: PRIORITY,
+	load: loadSlashCommands,
+});
+
+registerProvider(settingsCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load settings from opencode.json",
+	priority: PRIORITY,
+	load: loadSettings,
+});

package/src/discovery/windsurf.ts

@@ -15,8 +15,8 @@ import { readFile } from "../capability/fs";
 import { type MCPServer, mcpCapability } from "../capability/mcp";
 import { type Rule, ruleCapability } from "../capability/rule";
 import type { LoadContext, LoadResult } from "../capability/types";
-import { parseFrontmatter } from "../utils/frontmatter";
 import {
+	buildRuleFromMarkdown,
 	createSourceMeta,
 	expandEnvVarsDeep,
 	getProjectPath,
@@ -104,26 +104,8 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 	if (userPath) {
 		const content = await readFile(userPath);
 		if (content) {
-			const { frontmatter, body } = parseFrontmatter(content, { source: userPath });
-
-			// Validate and normalize globs
-			let globs: string[] | undefined;
-			if (Array.isArray(frontmatter.globs)) {
-				globs = frontmatter.globs.filter((g): g is string => typeof g === "string");
-			} else if (typeof frontmatter.globs === "string") {
-				globs = [frontmatter.globs];
-			}
-
-			items.push({
-				name: "global_rules",
-				path: userPath,
-				content: body,
-				globs,
-				alwaysApply: frontmatter.alwaysApply as boolean | undefined,
-				description: frontmatter.description as string | undefined,
-				ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
-				_source: createSourceMeta(PROVIDER_ID, userPath, "user"),
-			});
+			const source = createSourceMeta(PROVIDER_ID, userPath, "user");
+			items.push(buildRuleFromMarkdown("global_rules.md", content, userPath, source, { ruleName: "global_rules" }));
 		}
 	}
 
@@ -132,29 +114,8 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 	if (projectRulesDir) {
 		const result = await loadFilesFromDir<Rule>(ctx, projectRulesDir, PROVIDER_ID, "project", {
 			extensions: ["md"],
-			transform: (name, content, path, source) => {
-				const { frontmatter, body } = parseFrontmatter(content, { source: path });
-				const ruleName = name.replace(/\.md$/, "");
-
-				// Validate and normalize globs
-				let globs: string[] | undefined;
-				if (Array.isArray(frontmatter.globs)) {
-					globs = frontmatter.globs.filter((g): g is string => typeof g === "string");
-				} else if (typeof frontmatter.globs === "string") {
-					globs = [frontmatter.globs];
-				}
-
-				return {
-					name: ruleName,
-					path,
-					content: body,
-					globs,
-					alwaysApply: frontmatter.alwaysApply as boolean | undefined,
-					description: frontmatter.description as string | undefined,
-					ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
-					_source: source,
-				};
-			},
+			transform: (name, content, path, source) =>
+				buildRuleFromMarkdown(name, content, path, source, { stripNamePattern: /\.md$/ }),
 		});
 		items.push(...result.items);
 		if (result.warnings) warnings.push(...result.warnings);