@oh-my-pi/pi-coding-agent 2.3.1337 → 3.0.1337

package/src/core/custom-tools/loader.ts

@@ -5,11 +5,11 @@
  * to avoid import resolution issues with custom tools loaded from user directories.
  */
 
-import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as typebox from "@sinclair/typebox";
-import { getAgentDir } from "../../config";
+import { toolCapability } from "../../capability/tool";
+import { type CustomTool, loadSync } from "../../discovery";
 import * as piCodingAgent from "../../index";
 import { theme } from "../../modes/interactive/theme/theme";
 import type { ExecOptions } from "../exec";
@@ -73,6 +73,13 @@ function createNoOpUIContext(): HookUIContext {
 	};
 }
 
+/** Error with source metadata */
+interface ToolLoadError {
+	path: string;
+	error: string;
+	source?: { provider: string; providerName: string; level: "user" | "project" };
+}
+
 /**
  * Load a single tool module using native Bun import.
  */
@@ -80,15 +87,28 @@ async function loadTool(
 	toolPath: string,
 	cwd: string,
 	sharedApi: CustomToolAPI,
-): Promise<{ tools: LoadedCustomTool[] | null; error: string | null }> {
+	source?: { provider: string; providerName: string; level: "user" | "project" },
+): Promise<{ tools: LoadedCustomTool[] | null; error: ToolLoadError | null }> {
 	const resolvedPath = resolveToolPath(toolPath, cwd);
 
+	// Skip declarative tool files (.md, .json) - these are metadata only, not executable modules
+	if (resolvedPath.endsWith(".md") || resolvedPath.endsWith(".json")) {
+		return {
+			tools: null,
+			error: {
+				path: toolPath,
+				error: "Declarative tool files (.md, .json) cannot be loaded as executable modules",
+				source,
+			},
+		};
+	}
+
 	try {
 		const module = await import(resolvedPath);
 		const factory = (module.default ?? module) as CustomToolFactory;
 
 		if (typeof factory !== "function") {
-			return { tools: null, error: "Tool must export a default function" };
+			return { tools: null, error: { path: toolPath, error: "Tool must export a default function", source } };
 		}
 
 		const toolResult = await factory(sharedApi);
@@ -98,28 +118,35 @@ async function loadTool(
 			path: toolPath,
 			resolvedPath,
 			tool,
+			source,
 		}));
 
 		return { tools: loadedTools, error: null };
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
-		return { tools: null, error: `Failed to load tool: ${message}` };
+		return { tools: null, error: { path: toolPath, error: `Failed to load tool: ${message}`, source } };
 	}
 }
 
+/** Tool path with optional source metadata */
+interface ToolPathWithSource {
+	path: string;
+	source?: { provider: string; providerName: string; level: "user" | "project" };
+}
+
 /**
  * Load all tools from configuration.
- * @param paths - Array of tool file paths
+ * @param pathsWithSources - Array of tool paths with optional source metadata
  * @param cwd - Current working directory for resolving relative paths
  * @param builtInToolNames - Names of built-in tools to check for conflicts
  */
 export async function loadCustomTools(
-	paths: string[],
+	pathsWithSources: ToolPathWithSource[],
 	cwd: string,
 	builtInToolNames: string[],
 ): Promise<CustomToolsLoadResult> {
 	const tools: LoadedCustomTool[] = [];
-	const errors: Array<{ path: string; error: string }> = [];
+	const errors: ToolLoadError[] = [];
 	const seenNames = new Set<string>(builtInToolNames);
 
 	// Shared API object - all tools get the same instance
@@ -134,11 +161,11 @@ export async function loadCustomTools(
 		pi: piCodingAgent,
 	};
 
-	for (const toolPath of paths) {
-		const { tools: loadedTools, error } = await loadTool(toolPath, cwd, sharedApi);
+	for (const { path: toolPath, source } of pathsWithSources) {
+		const { tools: loadedTools, error } = await loadTool(toolPath, cwd, sharedApi, source);
 
 		if (error) {
-			errors.push({ path: toolPath, error });
+			errors.push(error);
 			continue;
 		}
 
@@ -149,6 +176,7 @@ export async function loadCustomTools(
 					errors.push({
 						path: toolPath,
 						error: `Tool name "${loadedTool.tool.name}" conflicts with existing tool`,
+						source,
 					});
 					continue;
 				}
@@ -170,81 +198,51 @@ export async function loadCustomTools(
 }
 
 /**
- * Discover tool files from a directory.
- * Only loads index.ts files from subdirectories (e.g., tools/mytool/index.ts).
- */
-function discoverToolsInDir(dir: string): string[] {
-	if (!fs.existsSync(dir)) {
-		return [];
-	}
-
-	const tools: string[] = [];
-
-	try {
-		const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-		for (const entry of entries) {
-			if (entry.isDirectory() || entry.isSymbolicLink()) {
-				// Check for index.ts in subdirectory
-				const indexPath = path.join(dir, entry.name, "index.ts");
-				if (fs.existsSync(indexPath)) {
-					tools.push(indexPath);
-				}
-			}
-		}
-	} catch {
-		return [];
-	}
-
-	return tools;
-}
-
-/**
- * Discover and load tools from standard locations:
- * 1. agentDir/tools/*.ts (global)
- * 2. cwd/.pi/tools/*.ts (project-local)
- * 3. Installed plugins (~/.pi/plugins/node_modules/*)
- *
- * Plus any explicitly configured paths from settings or CLI.
+ * Discover and load tools from standard locations via capability system:
+ * 1. User and project tools discovered by capability providers
+ * 2. Installed plugins (~/.omp/plugins/node_modules/*)
+ * 3. Explicitly configured paths from settings or CLI
  *
  * @param configuredPaths - Explicit paths from settings.json and CLI --tool flags
  * @param cwd - Current working directory
  * @param builtInToolNames - Names of built-in tools to check for conflicts
- * @param agentDir - Agent config directory. Default: from getAgentDir()
  */
 export async function discoverAndLoadCustomTools(
 	configuredPaths: string[],
 	cwd: string,
 	builtInToolNames: string[],
-	agentDir: string = getAgentDir(),
 ): Promise<CustomToolsLoadResult> {
-	const allPaths: string[] = [];
+	const allPathsWithSources: ToolPathWithSource[] = [];
 	const seen = new Set<string>();
 
 	// Helper to add paths without duplicates
-	const addPaths = (paths: string[]) => {
-		for (const p of paths) {
-			const resolved = path.resolve(p);
-			if (!seen.has(resolved)) {
-				seen.add(resolved);
-				allPaths.push(p);
-			}
+	const addPath = (p: string, source?: { provider: string; providerName: string; level: "user" | "project" }) => {
+		const resolved = path.resolve(p);
+		if (!seen.has(resolved)) {
+			seen.add(resolved);
+			allPathsWithSources.push({ path: p, source });
 		}
 	};
 
-	// 1. Global tools: agentDir/tools/
-	const globalToolsDir = path.join(agentDir, "tools");
-	addPaths(discoverToolsInDir(globalToolsDir));
-
-	// 2. Project-local tools: cwd/.pi/tools/
-	const localToolsDir = path.join(cwd, ".pi", "tools");
-	addPaths(discoverToolsInDir(localToolsDir));
+	// 1. Discover tools via capability system (user + project from all providers)
+	const discoveredTools = loadSync<CustomTool>(toolCapability.id, { cwd });
+	for (const tool of discoveredTools.items) {
+		addPath(tool.path, {
+			provider: tool._source.provider,
+			providerName: tool._source.providerName,
+			level: tool.level,
+		});
+	}
 
-	// 3. Plugin tools: ~/.pi/plugins/node_modules/*/
-	addPaths(getAllPluginToolPaths(cwd));
+	// 2. Plugin tools: ~/.omp/plugins/node_modules/*/
+	for (const pluginPath of getAllPluginToolPaths(cwd)) {
+		addPath(pluginPath, { provider: "plugin", providerName: "Plugin", level: "user" });
+	}
 
-	// 4. Explicitly configured paths (can override/add)
-	addPaths(configuredPaths.map((p) => resolveToolPath(p, cwd)));
+	// 3. Explicitly configured paths (can override/add)
+	for (const configPath of configuredPaths) {
+		addPath(resolveToolPath(configPath, cwd), { provider: "config", providerName: "Config", level: "project" });
+	}
 
-	return loadCustomTools(allPaths, cwd, builtInToolNames);
+	return loadCustomTools(allPathsWithSources, cwd, builtInToolNames);
 }

package/src/core/custom-tools/types.ts

@@ -163,12 +163,21 @@ export interface LoadedCustomTool {
 	resolvedPath: string;
 	/** The original custom tool instance */
 	tool: CustomTool;
+	/** Source metadata (provider and level) */
+	source?: { provider: string; providerName: string; level: "user" | "project" };
+}
+
+/** Error with source metadata */
+export interface ToolLoadError {
+	path: string;
+	error: string;
+	source?: { provider: string; providerName: string; level: "user" | "project" };
 }
 
 /** Result from loading custom tools */
 export interface CustomToolsLoadResult {
 	tools: LoadedCustomTool[];
-	errors: Array<{ path: string; error: string }>;
+	errors: ToolLoadError[];
 	/** Update the UI context for all loaded tools. Call when mode initializes. */
 	setUIContext(uiContext: CustomToolUIContext, hasUI: boolean): void;
 }

package/src/core/hooks/loader.ts

@@ -2,15 +2,15 @@
  * Hook loader - loads TypeScript hook modules using native Bun import.
  */
 
-import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as typebox from "@sinclair/typebox";
-import { getAgentDir } from "../../config";
+import { hookCapability } from "../../capability/hook";
+import type { Hook } from "../../discovery";
+import { loadSync } from "../../discovery";
 import * as piCodingAgent from "../../index";
 import { logger } from "../logger";
 import type { HookMessage } from "../messages";
-import { getAllPluginHookPaths } from "../plugins/loader";
 import type { SessionManager } from "../session-manager";
 import { execCommand } from "./runner";
 import type { ExecOptions, HookAPI, HookFactory, HookMessageRenderer, RegisteredCommand } from "./types";
@@ -254,37 +254,15 @@ export async function loadHooks(paths: string[], cwd: string): Promise<LoadHooks
 }
 
 /**
- * Discover hook files from a directory.
- * Returns all .ts files (and symlinks to .ts files) in the directory (non-recursive).
- */
-function discoverHooksInDir(dir: string): string[] {
-	if (!fs.existsSync(dir)) {
-		return [];
-	}
-
-	try {
-		const entries = fs.readdirSync(dir, { withFileTypes: true });
-		return entries
-			.filter((e) => (e.isFile() || e.isSymbolicLink()) && e.name.endsWith(".ts"))
-			.map((e) => path.join(dir, e.name));
-	} catch {
-		return [];
-	}
-}
-
-/**
- * Discover and load hooks from standard locations:
- * 1. agentDir/hooks/*.ts (global)
- * 2. cwd/.pi/hooks/*.ts (project-local)
- * 3. Installed plugins (~/.pi/plugins/node_modules/*)
+ * Discover and load hooks from all registered providers.
+ * Uses the capability API to discover hook paths from:
+ * 1. OMP native configs (.omp/.pi hooks/)
+ * 2. Installed plugins
+ * 3. Other editor/IDE configurations
  *
  * Plus any explicitly configured paths from settings.
  */
-export async function discoverAndLoadHooks(
-	configuredPaths: string[],
-	cwd: string,
-	agentDir: string = getAgentDir(),
-): Promise<LoadHooksResult> {
+export async function discoverAndLoadHooks(configuredPaths: string[], cwd: string): Promise<LoadHooksResult> {
 	const allPaths: string[] = [];
 	const seen = new Set<string>();
 
@@ -299,18 +277,11 @@ export async function discoverAndLoadHooks(
 		}
 	};
 
-	// 1. Global hooks: agentDir/hooks/
-	const globalHooksDir = path.join(agentDir, "hooks");
-	addPaths(discoverHooksInDir(globalHooksDir));
-
-	// 2. Project-local hooks: cwd/.pi/hooks/
-	const localHooksDir = path.join(cwd, ".pi", "hooks");
-	addPaths(discoverHooksInDir(localHooksDir));
-
-	// 3. Plugin hooks: ~/.pi/plugins/node_modules/*/
-	addPaths(getAllPluginHookPaths(cwd));
+	// 1. Discover hooks via capability API
+	const discovered = loadSync<Hook>(hookCapability.id, { cwd });
+	addPaths(discovered.items.map((hook) => hook.path));
 
-	// 4. Explicitly configured paths (can override/add)
+	// 2. Explicitly configured paths (can override/add)
 	addPaths(configuredPaths.map((p) => resolveHookPath(p, cwd)));
 
 	return loadHooks(allPaths, cwd);

package/src/core/index.ts

@@ -38,7 +38,6 @@ export {
 export {
 	createMCPManager,
 	discoverAndLoadMCPTools,
-	expandEnvVars,
 	loadAllMCPConfigs,
 	type MCPConfigFile,
 	type MCPLoadResult,

package/src/core/logger.ts

@@ -1,7 +1,7 @@
 /**
- * Centralized file logger for pi.
+ * Centralized file logger for omp.
  *
- * Logs to ~/.pi/logs/ with size-based rotation, supporting concurrent pi instances.
+ * Logs to ~/.omp/logs/ with size-based rotation, supporting concurrent omp instances.
  * Each log entry includes process.pid for traceability.
  */
 
@@ -12,7 +12,7 @@ import winston from "winston";
 import DailyRotateFile from "winston-daily-rotate-file";
 import { CONFIG_DIR_NAME } from "../config";
 
-/** Get the logs directory (~/.pi/logs/) */
+/** Get the logs directory (~/.omp/logs/) */
 function getLogsDir(): string {
 	return join(homedir(), CONFIG_DIR_NAME, "logs");
 }
@@ -49,7 +49,7 @@ const logFormat = winston.format.combine(
 /** Size-based rotating file transport */
 const fileTransport = new DailyRotateFile({
 	dirname: ensureLogsDir(),
-	filename: "pi.%DATE%.log",
+	filename: "omp.%DATE%.log",
 	datePattern: "YYYY-MM-DD",
 	maxSize: "10m",
 	maxFiles: 5,
@@ -73,10 +73,10 @@ export interface Logger {
 }
 
 /**
- * Centralized logger for pi.
+ * Centralized logger for omp.
  *
- * Logs to ~/.pi/logs/pi.YYYY-MM-DD.log with size-based rotation.
- * Safe for concurrent access from multiple pi instances.
+ * Logs to ~/.omp/logs/omp.YYYY-MM-DD.log with size-based rotation.
+ * Safe for concurrent access from multiple omp instances.
  *
  * @example
  * ```typescript

package/src/core/mcp/client.ts

@@ -30,7 +30,7 @@ const CONNECTION_TIMEOUT_MS = 30_000;
 
 /** Client info sent during initialization */
 const CLIENT_INFO = {
-	name: "pi-coding-agent",
+	name: "omp-coding-agent",
 	version: "1.0.0",
 };