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

package/src/capability/prompt.ts

@@ -0,0 +1,35 @@
+/**
+ * Prompts Capability
+ *
+ * Reusable prompt templates (Codex format) available via /prompts: menu.
+ */
+
+import { defineCapability } from "./index";
+import type { SourceMeta } from "./types";
+
+/**
+ * A reusable prompt template.
+ */
+export interface Prompt {
+	/** Prompt name (filename without extension) */
+	name: string;
+	/** Absolute path to prompt file */
+	path: string;
+	/** Prompt content (markdown) */
+	content: string;
+	/** Source metadata */
+	_source: SourceMeta;
+}
+
+export const promptCapability = defineCapability<Prompt>({
+	id: "prompts",
+	displayName: "Prompts",
+	description: "Reusable prompt templates available via /prompts: menu",
+	key: (prompt) => prompt.name,
+	validate: (prompt) => {
+		if (!prompt.name) return "Missing name";
+		if (!prompt.path) return "Missing path";
+		if (prompt.content === undefined) return "Missing content";
+		return undefined;
+	},
+});

package/src/capability/rule.ts

@@ -0,0 +1,52 @@
+/**
+ * Rules Capability
+ *
+ * Project-specific rules from Cursor (.mdc), Windsurf (.md), and Cline formats.
+ * Translated to a canonical shape regardless of source format.
+ */
+
+import { defineCapability } from "./index";
+import type { SourceMeta } from "./types";
+
+/**
+ * Parsed frontmatter from MDC rule files (Cursor format).
+ */
+export interface RuleFrontmatter {
+	description?: string;
+	globs?: string[];
+	alwaysApply?: boolean;
+	[key: string]: unknown;
+}
+
+/**
+ * A rule providing project-specific guidance and constraints.
+ */
+export interface Rule {
+	/** Rule name (derived from filename) */
+	name: string;
+	/** Absolute path to rule file */
+	path: string;
+	/** Rule content (after frontmatter stripped) */
+	content: string;
+	/** Globs this rule applies to (if any) */
+	globs?: string[];
+	/** Whether to always include this rule */
+	alwaysApply?: boolean;
+	/** Description (for agent-requested rules) */
+	description?: string;
+	/** Source metadata */
+	_source: SourceMeta;
+}
+
+export const ruleCapability = defineCapability<Rule>({
+	id: "rules",
+	displayName: "Rules",
+	description: "Project-specific rules and constraints (Cursor MDC, Windsurf, Cline formats)",
+	key: (rule) => rule.name,
+	validate: (rule) => {
+		if (!rule.name) return "Missing rule name";
+		if (!rule.path) return "Missing rule path";
+		if (!rule.content || typeof rule.content !== "string") return "Rule must have content";
+		return undefined;
+	},
+});

package/src/capability/settings.ts

@@ -0,0 +1,35 @@
+/**
+ * Settings Capability
+ *
+ * Configuration settings from various sources (JSON, TOML, etc.)
+ */
+
+import { defineCapability } from "./index";
+import type { SourceMeta } from "./types";
+
+/**
+ * A settings file.
+ */
+export interface Settings {
+	/** Absolute path to settings file */
+	path: string;
+	/** Parsed settings data */
+	data: Record<string, unknown>;
+	/** Source level */
+	level: "user" | "project";
+	/** Source metadata */
+	_source: SourceMeta;
+}
+
+export const settingsCapability = defineCapability<Settings>({
+	id: "settings",
+	displayName: "Settings",
+	description: "Configuration settings from various sources",
+	// Settings are merged, not deduplicated by key
+	key: () => undefined,
+	validate: (settings) => {
+		if (!settings.path) return "Missing path";
+		if (!settings.data || typeof settings.data !== "object") return "Missing or invalid data";
+		return undefined;
+	},
+});

package/src/capability/skill.ts

@@ -0,0 +1,49 @@
+/**
+ * Skills Capability
+ *
+ * Skills provide specialized knowledge or workflows that extend agent capabilities.
+ */
+
+import { defineCapability } from "./index";
+import type { SourceMeta } from "./types";
+
+/**
+ * Parsed frontmatter from a skill file.
+ */
+export interface SkillFrontmatter {
+	name?: string;
+	description?: string;
+	globs?: string[];
+	alwaysApply?: boolean;
+	[key: string]: unknown;
+}
+
+/**
+ * A skill that provides specialized knowledge or workflows.
+ */
+export interface Skill {
+	/** Skill name (unique key, derived from filename or frontmatter) */
+	name: string;
+	/** Absolute path to skill file */
+	path: string;
+	/** Skill content (markdown) */
+	content: string;
+	/** Parsed frontmatter */
+	frontmatter?: SkillFrontmatter;
+	/** Source level */
+	level: "user" | "project";
+	/** Source metadata */
+	_source: SourceMeta;
+}
+
+export const skillCapability = defineCapability<Skill>({
+	id: "skills",
+	displayName: "Skills",
+	description: "Specialized knowledge and workflow files that extend agent capabilities",
+	key: (skill) => skill.name,
+	validate: (skill) => {
+		if (!skill.name) return "Missing skill name";
+		if (!skill.path) return "Missing skill path";
+		return undefined;
+	},
+});

package/src/capability/slash-command.ts

@@ -0,0 +1,40 @@
+/**
+ * Slash Commands Capability
+ *
+ * File-based slash commands defined as markdown files.
+ */
+
+import { defineCapability } from "./index";
+import type { SourceMeta } from "./types";
+
+/**
+ * A file-based slash command.
+ */
+export interface SlashCommand {
+	/** Command name (without leading slash) */
+	name: string;
+	/** Absolute path to command file */
+	path: string;
+	/** Command content (markdown template) */
+	content: string;
+	/** Source level */
+	level: "user" | "project" | "native";
+	/** Source metadata */
+	_source: SourceMeta;
+}
+
+export const slashCommandCapability = defineCapability<SlashCommand>({
+	id: "slash-commands",
+	displayName: "Slash Commands",
+	description: "Custom slash commands defined as markdown files",
+	key: (cmd) => cmd.name,
+	validate: (cmd) => {
+		if (!cmd.name) return "Missing name";
+		if (!cmd.path) return "Missing path";
+		if (cmd.content === undefined) return "Missing content";
+		if (cmd.level !== "user" && cmd.level !== "project" && cmd.level !== "native") {
+			return "Invalid level: must be 'user', 'project', or 'native'";
+		}
+		return undefined;
+	},
+});

package/src/capability/system-prompt.ts

@@ -0,0 +1,35 @@
+/**
+ * System Prompt Capability
+ *
+ * Custom system prompt files (SYSTEM.md) that modify the agent's base system prompt.
+ * Distinct from context-files which are user instructions shown in conversation.
+ */
+
+import { defineCapability } from "./index";
+import type { SourceMeta } from "./types";
+
+/**
+ * A system prompt customization file.
+ */
+export interface SystemPrompt {
+	/** Absolute path to the file */
+	path: string;
+	/** File content */
+	content: string;
+	/** Which level this came from */
+	level: "user" | "project";
+	/** Source metadata */
+	_source: SourceMeta;
+}
+
+export const systemPromptCapability = defineCapability<SystemPrompt>({
+	id: "system-prompt",
+	displayName: "System Prompt",
+	description: "Custom system prompt files (SYSTEM.md) that modify agent behavior",
+	key: (sp) => sp.level,
+	validate: (sp) => {
+		if (!sp.path) return "Missing path";
+		if (sp.content === undefined) return "Missing content";
+		return undefined;
+	},
+});

package/src/capability/tool.ts

@@ -0,0 +1,38 @@
+/**
+ * Custom Tools Capability
+ *
+ * User-defined tools that extend agent capabilities.
+ */
+
+import { defineCapability } from "./index";
+import type { SourceMeta } from "./types";
+
+/**
+ * A custom tool definition.
+ */
+export interface CustomTool {
+	/** Tool name (unique key) */
+	name: string;
+	/** Absolute path to tool definition file */
+	path: string;
+	/** Tool description */
+	description?: string;
+	/** Tool implementation (script path or inline) */
+	implementation?: string;
+	/** Source level */
+	level: "user" | "project";
+	/** Source metadata */
+	_source: SourceMeta;
+}
+
+export const toolCapability = defineCapability<CustomTool>({
+	id: "tools",
+	displayName: "Custom Tools",
+	description: "User-defined tools that extend agent capabilities",
+	key: (tool) => tool.name,
+	validate: (tool) => {
+		if (!tool.name) return "Missing name";
+		if (!tool.path) return "Missing path";
+		return undefined;
+	},
+});

package/src/capability/types.ts

@@ -0,0 +1,166 @@
+/**
+ * Core types for the capability-based config discovery system.
+ *
+ * This architecture inverts control: instead of callers knowing about paths like
+ * `.claude`, `.codex`, `.gemini`, they simply ask for `load("mcps")` and get back
+ * a unified array of MCP servers.
+ */
+
+/**
+ * Context passed to every provider loader.
+ */
+export interface LoadContext {
+	/** Current working directory (project root) */
+	cwd: string;
+	/** User home directory */
+	home: string;
+	/** Filesystem helpers (cached) */
+	fs: {
+		exists(path: string): boolean;
+		isDir(path: string): boolean;
+		isFile(path: string): boolean;
+		readFile(path: string): string | null;
+		readDir(path: string): string[];
+		/** Walk up from cwd looking for a file/dir, returns first match */
+		walkUp(name: string, opts?: { file?: boolean; dir?: boolean }): string | null;
+	};
+}
+
+/**
+ * Result from a provider's load function.
+ */
+export interface LoadResult<T> {
+	items: T[];
+	/** Warnings encountered during loading (parse errors, etc.) */
+	warnings?: string[];
+}
+
+/**
+ * A provider that can load items for a capability.
+ */
+export interface Provider<T> {
+	/** Unique provider ID (e.g., "claude", "omp", "mcp-json", "agents-md") */
+	id: string;
+
+	/** Human-readable name for UI display (e.g., "Claude Code", "OpenAI Codex") */
+	displayName: string;
+
+	/** Short description for settings UI (e.g., "Load config from ~/.claude and .claude/") */
+	description: string;
+
+	/**
+	 * Priority (higher = checked first, wins on conflicts).
+	 * Suggested ranges:
+	 *   100+ : Primary providers (omp, pi)
+	 *   50-99: Tool-specific providers (claude, codex, gemini)
+	 *   1-49 : Shared standards (mcp-json, agents-md)
+	 */
+	priority: number;
+
+	/**
+	 * Load items for this capability.
+	 * Returns items in provider's preferred order (usually project before user).
+	 */
+	load(ctx: LoadContext): LoadResult<T> | Promise<LoadResult<T>>;
+}
+
+/**
+ * Options for loading a capability.
+ */
+export interface LoadOptions {
+	/** Only use these providers (by ID). Default: all registered */
+	providers?: string[];
+	/** Exclude these providers (by ID). Default: none */
+	excludeProviders?: string[];
+	/** Custom cwd. Default: process.cwd() */
+	cwd?: string;
+	/** Include items even if they fail validation. Default: false */
+	includeInvalid?: boolean;
+}
+
+/**
+ * Source metadata attached to every loaded item.
+ */
+export interface SourceMeta {
+	/** Provider ID that loaded this item */
+	provider: string;
+	/** Provider display name (for UI) */
+	providerName: string;
+	/** Absolute path to the source file */
+	path: string;
+	/** Whether this came from user-level, project-level, or native config */
+	level: "user" | "project" | "native";
+}
+
+/**
+ * Merged result from loading a capability across all providers.
+ */
+export interface CapabilityResult<T> {
+	/** Deduplicated items in priority order */
+	items: Array<T & { _source: SourceMeta }>;
+	/** All items including shadowed duplicates (for diagnostics) */
+	all: Array<T & { _source: SourceMeta; _shadowed?: boolean }>;
+	/** Warnings from all providers */
+	warnings: string[];
+	/** Which providers contributed items (IDs) */
+	providers: string[];
+}
+
+/**
+ * Definition of a capability.
+ */
+export interface Capability<T> {
+	/** Capability ID (e.g., "mcps", "skills", "context-files") */
+	id: string;
+
+	/** Human-readable name for UI display (e.g., "MCP Servers", "Skills") */
+	displayName: string;
+
+	/** Short description for settings/status UI */
+	description: string;
+
+	/**
+	 * Extract a unique key from an item for deduplication.
+	 * Items with the same key: first one wins (highest priority provider).
+	 * Return undefined to never deduplicate (all items kept).
+	 */
+	key(item: T): string | undefined;
+
+	/**
+	 * Optional validation. Return error message if invalid, undefined if valid.
+	 */
+	validate?(item: T): string | undefined;
+
+	/** Registered providers, sorted by priority (highest first) */
+	providers: Provider<T>[];
+}
+
+/**
+ * Metadata about a capability (for introspection/UI).
+ */
+export interface CapabilityInfo {
+	id: string;
+	displayName: string;
+	description: string;
+	providers: Array<{
+		id: string;
+		displayName: string;
+		description: string;
+		priority: number;
+		enabled: boolean;
+	}>;
+}
+
+/**
+ * Metadata about a provider (for introspection/UI).
+ */
+export interface ProviderInfo {
+	id: string;
+	displayName: string;
+	description: string;
+	priority: number;
+	/** Which capabilities this provider is registered for */
+	capabilities: string[];
+	/** Whether this provider is currently enabled */
+	enabled: boolean;
+}

package/src/cli/args.ts

@@ -153,8 +153,8 @@ ${chalk.bold("Usage:")}
 
 ${chalk.bold("Options:")}
   --model <pattern>              Model to use (fuzzy match: "opus", "gpt-5.2", or "p-openai/gpt-5.2")
-  --smol <id>                    Smol/fast model for lightweight tasks (or PI_SMOL_MODEL env)
-  --slow <id>                    Slow/reasoning model for thorough analysis (or PI_SLOW_MODEL env)
+   --smol <id>                    Smol/fast model for lightweight tasks (or OMP_SMOL_MODEL env)
+   --slow <id>                    Slow/reasoning model for thorough analysis (or OMP_SLOW_MODEL env)
   --api-key <key>                API key (defaults to env vars)
   --system-prompt <text>         System prompt (default: coding assistant prompt)
   --append-system-prompt <text>  Append text or file contents to the system prompt

package/src/cli/plugin-cli.ts

@@ -1,10 +1,11 @@
 /**
  * Plugin CLI command handlers.
  *
- * Handles `pi plugin <command>` subcommands for plugin lifecycle management.
+ * Handles `omp plugin <command>` subcommands for plugin lifecycle management.
  */
 
 import chalk from "chalk";
+import { APP_NAME } from "../config";
 import { PluginManager, parseSettingValue, validateSetting } from "../core/plugins/index";
 
 // =============================================================================
@@ -153,12 +154,12 @@ async function handleInstall(
 	flags: { json?: boolean; force?: boolean; dryRun?: boolean },
 ): Promise<void> {
 	if (packages.length === 0) {
-		console.error(chalk.red("Usage: pi plugin install <package[@version]>[features] ..."));
+		console.error(chalk.red(`Usage: ${APP_NAME} plugin install <package[@version]>[features] ...`));
 		console.error(chalk.dim("Examples:"));
-		console.error(chalk.dim("  pi plugin install @oh-my-pi/exa"));
-		console.error(chalk.dim("  pi plugin install @oh-my-pi/exa[search,websets]"));
-		console.error(chalk.dim("  pi plugin install @oh-my-pi/exa[*]  # all features"));
-		console.error(chalk.dim("  pi plugin install @oh-my-pi/exa[]   # no optional features"));
+		console.error(chalk.dim(`  ${APP_NAME} plugin install @oh-my-pi/exa`));
+		console.error(chalk.dim(`  ${APP_NAME} plugin install @oh-my-pi/exa[search,websets]`));
+		console.error(chalk.dim(`  ${APP_NAME} plugin install @oh-my-pi/exa[*]  # all features`));
+		console.error(chalk.dim(`  ${APP_NAME} plugin install @oh-my-pi/exa[]   # no optional features`));
 		process.exit(1);
 	}
 
@@ -190,7 +191,7 @@ async function handleInstall(
 
 async function handleUninstall(manager: PluginManager, packages: string[], flags: { json?: boolean }): Promise<void> {
 	if (packages.length === 0) {
-		console.error(chalk.red("Usage: pi plugin uninstall <package> ..."));
+		console.error(chalk.red(`Usage: ${APP_NAME} plugin uninstall <package> ...`));
 		process.exit(1);
 	}
 
@@ -220,7 +221,7 @@ async function handleList(manager: PluginManager, flags: { json?: boolean }): Pr
 
 	if (plugins.length === 0) {
 		console.log(chalk.dim("No plugins installed"));
-		console.log(chalk.dim("\nInstall plugins with: pi plugin install <package>"));
+		console.log(chalk.dim(`\nInstall plugins with: ${APP_NAME} plugin install <package>`));
 		return;
 	}
 
@@ -254,7 +255,7 @@ async function handleList(manager: PluginManager, flags: { json?: boolean }): Pr
 
 async function handleLink(manager: PluginManager, paths: string[], flags: { json?: boolean }): Promise<void> {
 	if (paths.length === 0) {
-		console.error(chalk.red("Usage: pi plugin link <path>"));
+		console.error(chalk.red(`Usage: ${APP_NAME} plugin link <path>`));
 		process.exit(1);
 	}
 
@@ -313,7 +314,9 @@ async function handleFeatures(
 	flags: { json?: boolean; enable?: string; disable?: string; set?: string },
 ): Promise<void> {
 	if (args.length === 0) {
-		console.error(chalk.red("Usage: pi plugin features <plugin> [--enable f1,f2] [--disable f1] [--set f1,f2]"));
+		console.error(
+			chalk.red(`Usage: ${APP_NAME} plugin features <plugin> [--enable f1,f2] [--disable f1] [--set f1,f2]`),
+		);
 		process.exit(1);
 	}
 
@@ -404,7 +407,9 @@ async function handleConfig(
 	flags: { json?: boolean; local?: boolean },
 ): Promise<void> {
 	if (args.length === 0) {
-		console.error(chalk.red("Usage: pi plugin config <list|get|set|delete|validate> <plugin> [key] [value]"));
+		console.error(
+			chalk.red(`Usage: ${APP_NAME} plugin config <list|get|set|delete|validate> <plugin> [key] [value]`),
+		);
 		process.exit(1);
 	}
 
@@ -560,7 +565,7 @@ async function handleConfigValidate(manager: PluginManager, flags: { json?: bool
 
 async function handleEnable(manager: PluginManager, plugins: string[], flags: { json?: boolean }): Promise<void> {
 	if (plugins.length === 0) {
-		console.error(chalk.red("Usage: pi plugin enable <plugin> ..."));
+		console.error(chalk.red(`Usage: ${APP_NAME} plugin enable <plugin> ...`));
 		process.exit(1);
 	}
 
@@ -582,7 +587,7 @@ async function handleEnable(manager: PluginManager, plugins: string[], flags: {
 
 async function handleDisable(manager: PluginManager, plugins: string[], flags: { json?: boolean }): Promise<void> {
 	if (plugins.length === 0) {
-		console.error(chalk.red("Usage: pi plugin disable <plugin> ..."));
+		console.error(chalk.red(`Usage: ${APP_NAME} plugin disable <plugin> ...`));
 		process.exit(1);
 	}
 
@@ -607,7 +612,7 @@ async function handleDisable(manager: PluginManager, plugins: string[], flags: {
 // =============================================================================
 
 export function printPluginHelp(): void {
-	console.log(`${chalk.bold("pi plugin")} - Plugin lifecycle management
+	console.log(`${chalk.bold(`${APP_NAME} plugin`)} - Plugin lifecycle management
 
 ${chalk.bold("Commands:")}
   install <pkg[@ver]>[features]  Install plugins from npm
@@ -641,10 +646,10 @@ ${chalk.bold("Options:")}
   -l, --local  Use project-local overrides
 
 ${chalk.bold("Examples:")}
-  pi plugin install @oh-my-pi/exa[search]
-  pi plugin list --json
-  pi plugin features my-plugin --enable search,web
-  pi plugin config set my-plugin apiKey sk-xxx
-  pi plugin doctor --fix
+  ${APP_NAME} plugin install @oh-my-pi/exa[search]
+  ${APP_NAME} plugin list --json
+  ${APP_NAME} plugin features my-plugin --enable search,web
+  ${APP_NAME} plugin config set my-plugin apiKey sk-xxx
+  ${APP_NAME} plugin doctor --fix
 `);
 }

package/src/cli/update-cli.ts

@@ -1,7 +1,7 @@
 /**
  * Update CLI command handler.
  *
- * Handles `pi update` to check for and install updates.
+ * Handles `omp update` to check for and install updates.
  * Uses bun if available, otherwise downloads binary from GitHub releases.
  */
 
@@ -11,7 +11,7 @@ import { dirname } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import chalk from "chalk";
-import { VERSION } from "../config";
+import { APP_NAME, VERSION } from "../config";
 
 /**
  * Detect if we're running as a Bun compiled binary.
@@ -129,9 +129,9 @@ function getBinaryName(): string {
 	}
 
 	if (os === "windows") {
-		return `pi-${os}-${archName}.exe`;
+		return `${APP_NAME}-${os}-${archName}.exe`;
 	}
-	return `pi-${os}-${archName}`;
+	return `${APP_NAME}-${os}-${archName}`;
 }
 
 /**
@@ -193,7 +193,7 @@ async function updateViaBinary(release: ReleaseInfo): Promise<void> {
 		unlinkSync(backupPath);
 
 		console.log(chalk.green(`\n✓ Updated to ${release.version}`));
-		console.log(chalk.dim("Restart pi to use the new version"));
+		console.log(chalk.dim(`Restart ${APP_NAME} to use the new version`));
 	} catch (err) {
 		// Restore from backup if possible
 		if (existsSync(backupPath) && !existsSync(execPath)) {
@@ -256,18 +256,18 @@ export async function runUpdateCommand(opts: { force: boolean; check: boolean })
  * Print update command help.
  */
 export function printUpdateHelp(): void {
-	console.log(`${chalk.bold("pi update")} - Check for and install updates
+	console.log(`${chalk.bold(`${APP_NAME} update`)} - Check for and install updates
 
 ${chalk.bold("Usage:")}
-  pi update [options]
+  ${APP_NAME} update [options]
 
 ${chalk.bold("Options:")}
   -c, --check   Check for updates without installing
   -f, --force   Force reinstall even if up to date
 
 ${chalk.bold("Examples:")}
-  pi update           Update to latest version
-  pi update --check   Check if updates are available
-  pi update --force   Force reinstall
+  ${APP_NAME} update           Update to latest version
+  ${APP_NAME} update --check   Check if updates are available
+  ${APP_NAME} update --force   Force reinstall
 `);
 }