@wahack/pi-coding-agent 15.11.0

package/src/discovery/opencode.ts

@@ -0,0 +1,398 @@
+/**
+ * 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, parseFrontmatter, tryParseJson } 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 { settings } from "../config/settings";
+
+import {
+	buildExtensionModuleItems,
+	createSourceMeta,
+	discoverExtensionModulePaths,
+	expandEnvVarsDeep,
+	getProjectPath,
+	getUserPath,
+	loadFilesFromDir,
+	scanSkillsFromDir,
+} 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 = tryParseJson<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(
+			scanSkillsFromDir(ctx, {
+				dir: userSkillsDir,
+				providerId: PROVIDER_ID,
+				level: "user",
+			}),
+		);
+	}
+
+	if (projectSkillsDir) {
+		promises.push(
+			scanSkillsFromDir(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 = buildExtensionModuleItems(PROVIDER_ID, userPaths, projectPaths);
+
+	return { items, warnings: [] };
+}
+
+// =============================================================================
+// Slash Commands (commands/)
+// =============================================================================
+
+/**
+ * Read the OpenCode command-loading toggles from settings.
+ * Falls back to true (current behavior) when settings are not initialized,
+ * e.g. inside discovery unit tests that run without Settings.init().
+ */
+function readOpencodeCommandToggles(): { enableUser: boolean; enableProject: boolean } {
+	try {
+		return {
+			enableUser: settings.get("commands.enableOpencodeUser") ?? true,
+			enableProject: settings.get("commands.enableOpencodeProject") ?? true,
+		};
+	} catch {
+		return { enableUser: true, enableProject: true };
+	}
+}
+
+async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
+	const { enableUser, enableProject } = readOpencodeCommandToggles();
+	const userCommandsDir = enableUser ? getUserPath(ctx, "opencode", "commands") : null;
+	const projectCommandsDir = enableProject ? getProjectPath(ctx, "opencode", "commands") : null;
+
+	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 = tryParseJson<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 = tryParseJson<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/plugin-dir-roots.ts

@@ -0,0 +1,28 @@
+import * as path from "node:path";
+
+/** Synthetic plugin root for a --plugin-dir path. Shape-compatible with ClaudePluginRoot. */
+export interface PluginDirRoot {
+	id: string;
+	marketplace: string;
+	plugin: string;
+	version: string;
+	path: string;
+	scope: "user" | "project";
+}
+
+/**
+ * Build a synthetic plugin root from a --plugin-dir resolved path.
+ * @param resolvedPath Absolute path to the plugin directory
+ * @param manifestName Plugin name from manifest; falls back to directory basename
+ */
+export function buildPluginDirRoot(resolvedPath: string, manifestName?: string): PluginDirRoot {
+	const pluginName = manifestName || path.basename(resolvedPath);
+	return {
+		id: `${pluginName}@__local__`,
+		marketplace: "__local__",
+		plugin: pluginName,
+		version: "local",
+		path: resolvedPath,
+		scope: "user",
+	};
+}

package/src/discovery/ssh.ts

@@ -0,0 +1,153 @@
+/**
+ * SSH JSON Provider
+ *
+ * Discovers SSH hosts from managed omp config paths and legacy root ssh.json files.
+ * Priority: 5 (low, project/user config discovery)
+ */
+import * as path from "node:path";
+import { getSSHConfigPath, tryParseJson } from "@oh-my-pi/pi-utils";
+import { registerProvider } from "../capability";
+import { readFile } from "../capability/fs";
+import { type SSHHost, sshCapability } from "../capability/ssh";
+import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import { expandTilde } from "../tools/path-utils";
+import { createSourceMeta, expandEnvVarsDeep } from "./helpers";
+
+const PROVIDER_ID = "ssh-json";
+const DISPLAY_NAME = "SSH Config";
+
+interface SSHConfigFile {
+	hosts?: Record<
+		string,
+		{
+			host?: string;
+			username?: string;
+			port?: number | string;
+			compat?: boolean | string;
+			key?: string;
+			keyPath?: string;
+			description?: string;
+		}
+	>;
+}
+
+function parsePort(value: number | string | undefined): number | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isNaN(parsed) ? undefined : parsed;
+}
+
+function parseCompat(value: boolean | string | undefined): boolean | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value === "boolean") return value;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "true" || normalized === "1" || normalized === "yes") return true;
+	if (normalized === "false" || normalized === "0" || normalized === "no") return false;
+	return undefined;
+}
+
+function normalizeHost(
+	name: string,
+	raw: NonNullable<SSHConfigFile["hosts"]>[string],
+	source: SourceMeta,
+	home: string,
+	warnings: string[],
+): SSHHost | null {
+	if (!raw.host) {
+		warnings.push(`Missing host for SSH entry: ${name}`);
+		return null;
+	}
+
+	const port = parsePort(raw.port);
+	if (raw.port !== undefined && port === undefined) {
+		warnings.push(`Invalid port for SSH entry ${name}: ${String(raw.port)}`);
+	}
+
+	const compat = parseCompat(raw.compat);
+	if (raw.compat !== undefined && compat === undefined) {
+		warnings.push(`Invalid compat flag for SSH entry ${name}: ${String(raw.compat)}`);
+	}
+
+	const keyValue = raw.keyPath ?? raw.key;
+	const keyPath = keyValue ? expandTilde(keyValue, home) : undefined;
+
+	return {
+		name,
+		host: raw.host,
+		username: raw.username,
+		port,
+		keyPath,
+		description: raw.description,
+		compat,
+		_source: source,
+	};
+}
+
+async function loadSshJsonFile(
+	ctx: LoadContext,
+	filePath: string,
+	level: "user" | "project",
+): Promise<LoadResult<SSHHost>> {
+	const items: SSHHost[] = [];
+	const warnings: string[] = [];
+	const content = await readFile(filePath);
+	if (content === null) {
+		return { items, warnings };
+	}
+	const parsed = tryParseJson<SSHConfigFile>(content);
+	if (!parsed) {
+		warnings.push(`Failed to parse JSON in ${filePath}`);
+		return { items, warnings };
+	}
+	const config = expandEnvVarsDeep(parsed);
+	if (!config.hosts || typeof config.hosts !== "object") {
+		warnings.push(`Missing hosts in ${filePath}`);
+		return { items, warnings };
+	}
+
+	const source = createSourceMeta(PROVIDER_ID, filePath, level);
+	for (const [name, rawHost] of Object.entries(config.hosts)) {
+		if (!name.trim()) {
+			warnings.push(`Invalid SSH host name in ${filePath}`);
+			continue;
+		}
+		if (!rawHost || typeof rawHost !== "object") {
+			warnings.push(`Invalid host entry in ${filePath}: ${name}`);
+			continue;
+		}
+		const host = normalizeHost(name, rawHost, source, ctx.home, warnings);
+		if (host) items.push(host);
+	}
+
+	return {
+		items,
+		warnings: warnings.length > 0 ? warnings : undefined,
+	};
+}
+async function load(ctx: LoadContext): Promise<LoadResult<SSHHost>> {
+	const candidateSources: Array<{ path: string; level: "user" | "project" }> = [
+		{ path: getSSHConfigPath("project", ctx.cwd), level: "project" },
+		{ path: getSSHConfigPath("user", ctx.cwd), level: "user" },
+		{ path: path.join(ctx.cwd, "ssh.json"), level: "project" },
+		{ path: path.join(ctx.cwd, ".ssh.json"), level: "project" },
+	];
+	const uniqueSources = candidateSources.filter(
+		(source, index, arr) => arr.findIndex(candidate => candidate.path === source.path) === index,
+	);
+	const results = await Promise.all(uniqueSources.map(source => loadSshJsonFile(ctx, source.path, source.level)));
+	const allItems = results.flatMap(r => r.items);
+	const allWarnings = results.flatMap(r => r.warnings ?? []);
+	return {
+		items: allItems,
+		warnings: allWarnings.length > 0 ? allWarnings : undefined,
+	};
+}
+
+registerProvider(sshCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load SSH hosts from managed omp paths and legacy ssh.json/.ssh.json files",
+	priority: 5,
+	load,
+});

package/src/discovery/substitute-plugin-root.ts

@@ -0,0 +1,29 @@
+/**
+ * Recursively substitute ${CLAUDE_PLUGIN_ROOT} and ${OMP_PLUGIN_ROOT}
+ * with the actual plugin root path in strings, arrays, and plain objects.
+ */
+// Use concatenation to avoid noTemplateCurlyInString lint rule on literal placeholder names
+const CLAUDE_VAR = "$" + "{CLAUDE_PLUGIN_ROOT}";
+const OMP_VAR = "$" + "{OMP_PLUGIN_ROOT}";
+
+export function substitutePluginRoot<T>(value: T, rootPath: string): T {
+	if (typeof value === "string") {
+		return value.replaceAll(CLAUDE_VAR, rootPath).replaceAll(OMP_VAR, rootPath) as T;
+	}
+	if (Array.isArray(value)) {
+		return value.map(v => substitutePluginRoot(v, rootPath)) as T;
+	}
+	if (value && typeof value === "object") {
+		const result: Record<string, unknown> = Object.create(null);
+		for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+			Object.defineProperty(result, k, {
+				value: substitutePluginRoot(v, rootPath),
+				enumerable: true,
+				writable: true,
+				configurable: true,
+			});
+		}
+		return result as T;
+	}
+	return value;
+}