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

package/src/config.ts

@@ -1,4 +1,4 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 
@@ -9,12 +9,20 @@ import packageJson from "../package.json" with { type: "json" };
 // App Config (from embedded package.json)
 // =============================================================================
 
-export const APP_NAME: string = (packageJson as { piConfig?: { name?: string } }).piConfig?.name || "pi";
+export const APP_NAME: string = (packageJson as { ompConfig?: { name?: string } }).ompConfig?.name || "omp";
 export const CONFIG_DIR_NAME: string =
-	(packageJson as { piConfig?: { configDir?: string } }).piConfig?.configDir || ".pi";
+	(packageJson as { ompConfig?: { configDir?: string } }).ompConfig?.configDir || ".omp";
 export const VERSION: string = (packageJson as { version: string }).version;
 
-// e.g., PI_CODING_AGENT_DIR or TAU_CODING_AGENT_DIR
+const priorityList = [
+	{ dir: ".omp", globalAgentDir: ".omp/agent" },
+	{ dir: ".pi", globalAgentDir: ".pi/agent" },
+	{ dir: ".claude" },
+	{ dir: ".codex" },
+	{ dir: ".gemini" },
+];
+
+// e.g., OMP_CODING_AGENT_DIR
 export const ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
 
 // =============================================================================
@@ -58,10 +66,10 @@ export function getChangelogPath(): string {
 }
 
 // =============================================================================
-// User Config Paths (~/.pi/agent/*)
+// User Config Paths (~/.omp/agent/*)
 // =============================================================================
 
-/** Get the agent config directory (e.g., ~/.pi/agent/) */
+/** Get the agent config directory (e.g., ~/.omp/agent/) */
 export function getAgentDir(): string {
 	return process.env[ENV_AGENT_DIR] || join(homedir(), CONFIG_DIR_NAME, "agent");
 }
@@ -105,3 +113,279 @@ export function getSessionsDir(): string {
 export function getDebugLogPath(): string {
 	return join(getAgentDir(), `${APP_NAME}-debug.log`);
 }
+
+// =============================================================================
+// Multi-Config Directory Helpers
+// =============================================================================
+
+/**
+ * Config directory bases in priority order (highest first).
+ * User-level: ~/.omp/agent, ~/.pi/agent, ~/.claude, ~/.codex, ~/.gemini
+ * Project-level: .omp, .pi, .claude, .codex, .gemini
+ */
+const USER_CONFIG_BASES = priorityList.map(({ dir, globalAgentDir }) => ({
+	base: () => join(homedir(), globalAgentDir ?? dir),
+	name: dir,
+}));
+
+const PROJECT_CONFIG_BASES = priorityList.map(({ dir }) => ({
+	base: dir,
+	name: dir,
+}));
+
+export interface ConfigDirEntry {
+	path: string;
+	source: string; // e.g., ".omp", ".pi", ".claude"
+	level: "user" | "project";
+}
+
+export interface GetConfigDirsOptions {
+	/** Include user-level directories (~/.omp/agent/...). Default: true */
+	user?: boolean;
+	/** Include project-level directories (.omp/...). Default: true */
+	project?: boolean;
+	/** Current working directory for project paths. Default: process.cwd() */
+	cwd?: string;
+	/** Only return directories that exist. Default: false */
+	existingOnly?: boolean;
+}
+
+/**
+ * Get all config directories for a subpath, ordered by priority (highest first).
+ *
+ * @param subpath - Subpath within config dirs (e.g., "commands", "hooks", "agents")
+ * @param options - Options for filtering
+ * @returns Array of directory entries, highest priority first
+ *
+ * @example
+ * // Get all command directories
+ * getConfigDirs("commands")
+ * // → [{ path: "~/.omp/agent/commands", source: ".omp", level: "user" }, ...]
+ *
+ * @example
+ * // Get only existing project skill directories
+ * getConfigDirs("skills", { user: false, existingOnly: true })
+ */
+export function getConfigDirs(subpath: string, options: GetConfigDirsOptions = {}): ConfigDirEntry[] {
+	const { user = true, project = true, cwd = process.cwd(), existingOnly = false } = options;
+	const results: ConfigDirEntry[] = [];
+
+	// User-level directories (highest priority)
+	if (user) {
+		for (const { base, name } of USER_CONFIG_BASES) {
+			const path = join(base(), subpath);
+			if (!existingOnly || existsSync(path)) {
+				results.push({ path, source: name, level: "user" });
+			}
+		}
+	}
+
+	// Project-level directories
+	if (project) {
+		for (const { base, name } of PROJECT_CONFIG_BASES) {
+			const path = resolve(cwd, base, subpath);
+			if (!existingOnly || existsSync(path)) {
+				results.push({ path, source: name, level: "project" });
+			}
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Get all config directory paths for a subpath (convenience wrapper).
+ * Returns just the paths, highest priority first.
+ */
+export function getConfigDirPaths(subpath: string, options: GetConfigDirsOptions = {}): string[] {
+	return getConfigDirs(subpath, options).map((e) => e.path);
+}
+
+export interface ConfigFileResult<T> {
+	path: string;
+	source: string;
+	level: "user" | "project";
+	content: T;
+}
+
+/**
+ * Read the first existing config file from priority-ordered locations.
+ *
+ * @param subpath - Subpath within config dirs (e.g., "settings.json", "models.json")
+ * @param options - Options for filtering (same as getConfigDirs)
+ * @returns The parsed content and metadata, or undefined if not found
+ *
+ * @example
+ * const result = readConfigFile<Settings>("settings.json", { project: false });
+ * if (result) {
+ *   console.log(`Loaded from ${result.path}`);
+ *   console.log(result.content);
+ * }
+ */
+export function readConfigFile<T = unknown>(
+	subpath: string,
+	options: GetConfigDirsOptions = {},
+): ConfigFileResult<T> | undefined {
+	const dirs = getConfigDirs("", { ...options, existingOnly: false });
+
+	for (const { path: base, source, level } of dirs) {
+		const filePath = join(base, subpath);
+		if (existsSync(filePath)) {
+			try {
+				const content = readFileSync(filePath, "utf-8");
+				return {
+					path: filePath,
+					source,
+					level,
+					content: JSON.parse(content) as T,
+				};
+			} catch {
+				// Continue to next file on parse error
+			}
+		}
+	}
+
+	return undefined;
+}
+
+/**
+ * Get all existing config files for a subpath (for merging scenarios).
+ * Returns in priority order (highest first).
+ */
+export function readAllConfigFiles<T = unknown>(
+	subpath: string,
+	options: GetConfigDirsOptions = {},
+): ConfigFileResult<T>[] {
+	const dirs = getConfigDirs("", { ...options, existingOnly: false });
+	const results: ConfigFileResult<T>[] = [];
+
+	for (const { path: base, source, level } of dirs) {
+		const filePath = join(base, subpath);
+		if (existsSync(filePath)) {
+			try {
+				const content = readFileSync(filePath, "utf-8");
+				results.push({
+					path: filePath,
+					source,
+					level,
+					content: JSON.parse(content) as T,
+				});
+			} catch {
+				// Skip files that fail to parse
+			}
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Find the first existing config file (for non-JSON files like SYSTEM.md).
+ * Returns just the path, or undefined if not found.
+ */
+export function findConfigFile(subpath: string, options: GetConfigDirsOptions = {}): string | undefined {
+	const dirs = getConfigDirs("", { ...options, existingOnly: false });
+
+	for (const { path: base } of dirs) {
+		const filePath = join(base, subpath);
+		if (existsSync(filePath)) {
+			return filePath;
+		}
+	}
+
+	return undefined;
+}
+
+/**
+ * Find the first existing config file with metadata.
+ */
+export function findConfigFileWithMeta(
+	subpath: string,
+	options: GetConfigDirsOptions = {},
+): Omit<ConfigFileResult<never>, "content"> | undefined {
+	const dirs = getConfigDirs("", { ...options, existingOnly: false });
+
+	for (const { path: base, source, level } of dirs) {
+		const filePath = join(base, subpath);
+		if (existsSync(filePath)) {
+			return { path: filePath, source, level };
+		}
+	}
+
+	return undefined;
+}
+
+// =============================================================================
+// Walk-Up Config Discovery (for monorepo scenarios)
+// =============================================================================
+
+function isDirectory(p: string): boolean {
+	try {
+		return statSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Find nearest config directory by walking up from cwd.
+ * Checks all config bases (.omp, .pi, .claude) at each level.
+ *
+ * @param subpath - Subpath within config dirs (e.g., "commands", "agents")
+ * @param cwd - Starting directory
+ * @returns First existing directory found, or undefined
+ */
+export function findNearestProjectConfigDir(subpath: string, cwd: string = process.cwd()): ConfigDirEntry | undefined {
+	let currentDir = cwd;
+
+	while (true) {
+		// Check all config bases at this level, in priority order
+		for (const { base, name } of PROJECT_CONFIG_BASES) {
+			const candidate = join(currentDir, base, subpath);
+			if (isDirectory(candidate)) {
+				return { path: candidate, source: name, level: "project" };
+			}
+		}
+
+		// Move up one directory
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) break; // Reached root
+		currentDir = parentDir;
+	}
+
+	return undefined;
+}
+
+/**
+ * Find all nearest config directories by walking up from cwd.
+ * Returns one entry per config base (.omp, .pi, .claude) - the nearest one found.
+ * Results are in priority order (highest first).
+ */
+export function findAllNearestProjectConfigDirs(subpath: string, cwd: string = process.cwd()): ConfigDirEntry[] {
+	const results: ConfigDirEntry[] = [];
+	const foundBases = new Set<string>();
+
+	let currentDir = cwd;
+
+	while (foundBases.size < PROJECT_CONFIG_BASES.length) {
+		for (const { base, name } of PROJECT_CONFIG_BASES) {
+			if (foundBases.has(name)) continue;
+
+			const candidate = join(currentDir, base, subpath);
+			if (isDirectory(candidate)) {
+				results.push({ path: candidate, source: name, level: "project" });
+				foundBases.add(name);
+			}
+		}
+
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+
+	// Sort by priority order
+	const order = PROJECT_CONFIG_BASES.map((b) => b.name);
+	results.sort((a, b) => order.indexOf(a.source) - order.indexOf(b.source));
+
+	return results;
+}

package/src/core/auth-storage.ts

@@ -15,6 +15,7 @@ import {
 	type OAuthCredentials,
 	type OAuthProvider,
 } from "@oh-my-pi/pi-ai";
+import { logger } from "./logger";
 
 export type ApiKeyCredential = {
 	type: "api_key";
@@ -31,13 +32,21 @@ export type AuthStorageData = Record<string, AuthCredential>;
 
 /**
  * Credential storage backed by a JSON file.
+ * Reads from multiple fallback paths, writes to primary path.
  */
 export class AuthStorage {
 	private data: AuthStorageData = {};
 	private runtimeOverrides: Map<string, string> = new Map();
 	private fallbackResolver?: (provider: string) => string | undefined;
 
-	constructor(private authPath: string) {
+	/**
+	 * @param authPath - Primary path for reading/writing auth.json
+	 * @param fallbackPaths - Additional paths to check when reading (legacy support)
+	 */
+	constructor(
+		private authPath: string,
+		private fallbackPaths: string[] = [],
+	) {
 		this.reload();
 	}
 
@@ -66,17 +75,31 @@ export class AuthStorage {
 
 	/**
 	 * Reload credentials from disk.
+	 * Checks primary path first, then fallback paths.
 	 */
 	reload(): void {
-		if (!existsSync(this.authPath)) {
-			this.data = {};
-			return;
-		}
-		try {
-			this.data = JSON.parse(readFileSync(this.authPath, "utf-8"));
-		} catch {
-			this.data = {};
+		const pathsToCheck = [this.authPath, ...this.fallbackPaths];
+
+		logger.debug("AuthStorage.reload checking paths", { paths: pathsToCheck });
+
+		for (const authPath of pathsToCheck) {
+			const exists = existsSync(authPath);
+			logger.debug("AuthStorage.reload path check", { path: authPath, exists });
+
+			if (exists) {
+				try {
+					this.data = JSON.parse(readFileSync(authPath, "utf-8"));
+					logger.debug("AuthStorage.reload loaded", { path: authPath, providers: Object.keys(this.data) });
+					return;
+				} catch (e) {
+					logger.error("AuthStorage failed to parse auth file", { path: authPath, error: String(e) });
+					// Continue to next path on parse error
+				}
+			}
 		}
+
+		logger.warn("AuthStorage no auth file found", { checkedPaths: pathsToCheck });
+		this.data = {};
 	}
 
 	/**

package/src/core/bash-executor.ts

@@ -132,7 +132,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
 				const randomId = crypto.getRandomValues(new Uint8Array(8));
 				const id = Array.from(randomId, (b) => b.toString(16).padStart(2, "0")).join("");
-				tempFilePath = join(tmpdir(), `pi-bash-${id}.log`);
+				tempFilePath = join(tmpdir(), `omp-bash-${id}.log`);
 				tempFileStream = createWriteStream(tempFilePath);
 				// Write already-buffered chunks to temp file
 				for (const chunk of outputChunks) {

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

@@ -5,10 +5,10 @@
  * to avoid import resolution issues with custom commands loaded from user directories.
  */
 
-import * as fs from "node:fs";
+import { type Dirent, existsSync, readdirSync } from "node:fs";
 import * as path from "node:path";
 import * as typebox from "@sinclair/typebox";
-import { CONFIG_DIR_NAME, getAgentDir } from "../../config";
+import { getAgentDir, getConfigDirs } from "../../config";
 import * as piCodingAgent from "../../index";
 import { execCommand } from "../exec";
 import { createReviewCommand } from "./bundled/review";
@@ -60,36 +60,6 @@ async function loadCommandModule(
 	}
 }
 
-/**
- * Discover command modules from a directory.
- * Loads index.ts files from subdirectories (e.g., commands/deploy/index.ts).
- */
-function discoverCommandsInDir(dir: string): string[] {
-	if (!fs.existsSync(dir)) {
-		return [];
-	}
-
-	const commands: 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)) {
-					commands.push(indexPath);
-				}
-			}
-		}
-	} catch {
-		return [];
-	}
-
-	return commands;
-}
-
 export interface DiscoverCustomCommandsOptions {
 	/** Current working directory. Default: process.cwd() */
 	cwd?: string;
@@ -103,34 +73,58 @@ export interface DiscoverCustomCommandsResult {
 }
 
 /**
- * Discover custom command modules from standard locations:
- * - agentDir/commands/[name]/index.ts (user)
- * - cwd/.pi/commands/[name]/index.ts (project)
+ * Discover custom command modules (TypeScript slash commands).
+ * Markdown slash commands are handled by core/slash-commands.ts.
  */
 export function discoverCustomCommands(options: DiscoverCustomCommandsOptions = {}): DiscoverCustomCommandsResult {
 	const cwd = options.cwd ?? process.cwd();
 	const agentDir = options.agentDir ?? getAgentDir();
-
 	const paths: Array<{ path: string; source: CustomCommandSource }> = [];
 	const seen = new Set<string>();
 
-	const addPaths = (modulePaths: string[], source: CustomCommandSource) => {
-		for (const p of modulePaths) {
-			const resolved = path.resolve(p);
-			if (!seen.has(resolved)) {
-				seen.add(resolved);
-				paths.push({ path: p, source });
-			}
-		}
+	const addPath = (commandPath: string, source: CustomCommandSource): void => {
+		const resolved = path.resolve(commandPath);
+		if (seen.has(resolved)) return;
+		seen.add(resolved);
+		paths.push({ path: resolved, source });
 	};
 
-	// 1. User commands: agentDir/commands/
-	const userCommandsDir = path.join(agentDir, "commands");
-	addPaths(discoverCommandsInDir(userCommandsDir), "user");
+	const commandDirs: Array<{ path: string; source: CustomCommandSource }> = [];
+	if (agentDir) {
+		const userCommandsDir = path.join(agentDir, "commands");
+		if (existsSync(userCommandsDir)) {
+			commandDirs.push({ path: userCommandsDir, source: "user" });
+		}
+	}
+
+	for (const entry of getConfigDirs("commands", { cwd, existingOnly: true })) {
+		const source = entry.level === "user" ? "user" : "project";
+		if (!commandDirs.some((d) => d.path === entry.path)) {
+			commandDirs.push({ path: entry.path, source });
+		}
+	}
 
-	// 2. Project commands: cwd/.pi/commands/
-	const projectCommandsDir = path.join(cwd, CONFIG_DIR_NAME, "commands");
-	addPaths(discoverCommandsInDir(projectCommandsDir), "project");
+	const indexCandidates = ["index.ts", "index.js", "index.mjs", "index.cjs"];
+	for (const { path: commandsDir, source } of commandDirs) {
+		let entries: Dirent[];
+		try {
+			entries = readdirSync(commandsDir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+			const commandDir = path.join(commandsDir, entry.name);
+
+			for (const filename of indexCandidates) {
+				const candidate = path.join(commandDir, filename);
+				if (existsSync(candidate)) {
+					addPath(candidate, source);
+					break;
+				}
+			}
+		}
+	}
 
 	return { paths };
 }

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

@@ -17,5 +17,6 @@ export type {
 	ExecResult,
 	LoadedCustomTool,
 	RenderResultOptions,
+	ToolLoadError,
 } from "./types";
 export { wrapCustomTool, wrapCustomTools } from "./wrapper";