@oh-my-pi/pi-coding-agent 15.1.0 → 15.1.2

package/dist/types/capability/hook.d.ts

@@ -0,0 +1,19 @@
+import type { SourceMeta } from "./types";
+/**
+ * A hook script.
+ */
+export interface Hook {
+    /** Hook name (filename without extension) */
+    name: string;
+    /** Absolute path to hook file */
+    path: string;
+    /** Hook type (pre/post) and associated tool */
+    type: "pre" | "post";
+    /** Tool this hook applies to, or "*" for all */
+    tool: string;
+    /** Source level */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const hookCapability: import("./types").Capability<Hook>;

package/dist/types/capability/index.d.ts

@@ -0,0 +1,80 @@
+import type { Settings } from "../config/settings";
+import type { Capability, CapabilityInfo, CapabilityResult, LoadOptions, Provider, ProviderInfo } from "./types";
+/**
+ * Define a new capability.
+ */
+export declare function defineCapability<T>(def: Omit<Capability<T>, "providers">): Capability<T>;
+/**
+ * Register a provider for a capability.
+ */
+export declare function registerProvider<T>(capabilityId: string, provider: Provider<T>): void;
+/**
+ * Load a capability by ID.
+ */
+export declare function loadCapability<T>(capabilityId: string, options?: LoadOptions): Promise<CapabilityResult<T>>;
+/**
+ * Initialize capability system with settings manager for persistence.
+ * Call this once on startup to enable persistent provider state.
+ */
+export declare function initializeWithSettings(activeSettings: Settings): void;
+/**
+ * Disable a provider globally (across all capabilities).
+ */
+export declare function disableProvider(providerId: string): void;
+/**
+ * Enable a previously disabled provider.
+ */
+export declare function enableProvider(providerId: string): void;
+/**
+ * Check if a provider is enabled.
+ */
+export declare function isProviderEnabled(providerId: string): boolean;
+/**
+ * Get list of all disabled provider IDs.
+ */
+export declare function getDisabledProviders(): string[];
+/**
+ * Set disabled providers from a list (replaces current set).
+ */
+export declare function setDisabledProviders(providerIds: string[]): void;
+/**
+ * Get a capability definition (for introspection).
+ */
+export declare function getCapability<T>(id: string): Capability<T> | undefined;
+/**
+ * List all registered capability IDs.
+ */
+export declare function listCapabilities(): string[];
+/**
+ * Get capability info for UI display.
+ */
+export declare function getCapabilityInfo(capabilityId: string): CapabilityInfo | undefined;
+/**
+ * Get all capabilities info for UI display.
+ */
+export declare function getAllCapabilitiesInfo(): CapabilityInfo[];
+/**
+ * Get provider info for UI display.
+ */
+export declare function getProviderInfo(providerId: string): ProviderInfo | undefined;
+/**
+ * Get all providers info for UI display (deduplicated across capabilities).
+ */
+export declare function getAllProvidersInfo(): ProviderInfo[];
+/**
+ * Reset all caches. Call after chdir or filesystem changes.
+ */
+export declare function reset(): void;
+/**
+ * Invalidate cache for a specific path.
+ * @param filePath - Absolute or relative path to invalidate
+ */
+export declare function invalidate(filePath: string, cwd?: string): void;
+/**
+ * Get cache stats for diagnostics.
+ */
+export declare function cacheStats(): {
+    content: number;
+    dir: number;
+};
+export type * from "./types";

package/dist/types/capability/instruction.d.ts

@@ -0,0 +1,17 @@
+import type { SourceMeta } from "./types";
+/**
+ * An instruction with optional file pattern matching.
+ */
+export interface Instruction {
+    /** Instruction name (derived from filename) */
+    name: string;
+    /** Absolute path to instruction file */
+    path: string;
+    /** Instruction content (markdown) */
+    content: string;
+    /** Glob pattern for files this applies to */
+    applyTo?: string;
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const instructionCapability: import("./types").Capability<Instruction>;

package/dist/types/capability/mcp.d.ts

@@ -0,0 +1,45 @@
+import type { SourceMeta } from "./types";
+/**
+ * Canonical MCP server configuration.
+ */
+export interface MCPServer {
+    /** Server name (unique key) */
+    name: string;
+    /** Whether this server is enabled (default: true) */
+    enabled?: boolean;
+    /** Connection timeout in milliseconds */
+    timeout?: number;
+    /** Command to run (for stdio transport) */
+    command?: string;
+    /** Command arguments */
+    args?: string[];
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Working directory for stdio transport */
+    cwd?: string;
+    /** URL (for HTTP/SSE transport) */
+    url?: string;
+    /** HTTP headers (for HTTP transport) */
+    headers?: Record<string, string>;
+    /** Authentication configuration */
+    auth?: {
+        type: "oauth" | "apikey";
+        credentialId?: string;
+        tokenUrl?: string;
+        clientId?: string;
+        clientSecret?: string;
+    };
+    /** OAuth configuration (clientId, clientSecret, redirectUri, callbackPort, callbackPath) for servers requiring explicit client credentials */
+    oauth?: {
+        clientId?: string;
+        clientSecret?: string;
+        redirectUri?: string;
+        callbackPort?: number;
+        callbackPath?: string;
+    };
+    /** Transport type */
+    transport?: "stdio" | "sse" | "http";
+    /** Source metadata (added by loader) */
+    _source: SourceMeta;
+}
+export declare const mcpCapability: import("./types").Capability<MCPServer>;

package/dist/types/capability/prompt.d.ts

@@ -0,0 +1,15 @@
+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 declare const promptCapability: import("./types").Capability<Prompt>;

package/dist/types/capability/rule.d.ts

@@ -0,0 +1,61 @@
+import type { SourceMeta } from "./types";
+/**
+ * Parsed frontmatter from rule files.
+ */
+export interface RuleFrontmatter {
+    description?: string;
+    globs?: string[];
+    alwaysApply?: boolean;
+    /** New key for TTSR match conditions. */
+    condition?: string | string[];
+    /** New key for TTSR stream scope. */
+    scope?: string | string[];
+    /** Per-rule TTSR interrupt mode override. */
+    interruptMode?: "never" | "prose-only" | "tool-only" | "always";
+    [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;
+    /** Regex condition(s) that can trigger TTSR interruption. */
+    condition?: string[];
+    /** Optional stream scope tokens (for example: text, thinking, tool:edit(*.ts)). */
+    scope?: string[];
+    /** Per-rule TTSR interrupt mode override (falls back to global ttsr.interruptMode). */
+    interruptMode?: "never" | "prose-only" | "tool-only" | "always";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+/**
+ * Parse `condition` + `scope` from rule frontmatter.
+ *
+ * - `condition` accepts string or string[]
+ * - `scope` accepts string or string[]
+ * - legacy `ttsr_trigger` / `ttsrTrigger` are accepted as a `condition` fallback
+ * - condition tokens that look like file globs become scope shorthands:
+ *   `*.rs` => `tool:edit(*.rs)`, `tool:write(*.rs)` and a catch-all condition `.*`
+ */
+export declare function parseRuleConditionAndScope(frontmatter: RuleFrontmatter): Pick<Rule, "condition" | "scope">;
+/**
+ * Process-global snapshot of rules the active session loaded.
+ * Read by internal URL protocol handlers (rule://).
+ */
+export declare function getActiveRules(): readonly Rule[];
+/** Replace the active rule snapshot. Called once per top-level session. */
+export declare function setActiveRules(value: readonly Rule[]): void;
+/** Reset the active rule snapshot. Test-only. */
+export declare function resetActiveRulesForTests(): void;
+export declare const ruleCapability: import("./types").Capability<Rule>;

package/dist/types/capability/settings.d.ts

@@ -0,0 +1,15 @@
+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 declare const settingsCapability: import("./types").Capability<Settings>;

package/dist/types/capability/skill.d.ts

@@ -0,0 +1,36 @@
+import type { SourceMeta } from "./types";
+/**
+ * Parsed frontmatter from a skill file.
+ */
+export interface SkillFrontmatter {
+    name?: string;
+    description?: string;
+    globs?: string[];
+    alwaysApply?: boolean;
+    /**
+     * When `true`, the skill is loaded and accessible via `skill://<name>` (and
+     * `/skill:<name>` slash commands), but is omitted from the rendered system
+     * prompt's skill listing. Use for skills the user opts into explicitly
+     * rather than ones the model should auto-discover.
+     */
+    hide?: 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 declare const skillCapability: import("./types").Capability<Skill>;

package/dist/types/capability/slash-command.d.ts

@@ -0,0 +1,17 @@
+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 declare const slashCommandCapability: import("./types").Capability<SlashCommand>;

package/dist/types/capability/ssh.d.ts

@@ -0,0 +1,23 @@
+import type { SourceMeta } from "./types";
+/**
+ * Canonical SSH host entry.
+ */
+export interface SSHHost {
+    /** Host name (config key) */
+    name: string;
+    /** Host address or DNS name */
+    host: string;
+    /** Optional username override */
+    username?: string;
+    /** Optional port override */
+    port?: number;
+    /** Optional identity key path */
+    keyPath?: string;
+    /** Optional host description */
+    description?: string;
+    /** Optional compatibility mode flag */
+    compat?: boolean;
+    /** Source metadata (added by loader) */
+    _source: SourceMeta;
+}
+export declare const sshCapability: import("./types").Capability<SSHHost>;

package/dist/types/capability/system-prompt.d.ts

@@ -0,0 +1,15 @@
+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 declare const systemPromptCapability: import("./types").Capability<SystemPrompt>;

package/dist/types/capability/tool.d.ts

@@ -0,0 +1,19 @@
+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 declare const toolCapability: import("./types").Capability<CustomTool>;

package/dist/types/capability/types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * 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;
+    /** Git repository root (directory containing .git), or null if not in a repo */
+    repoRoot: 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): 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: getProjectDir() */
+    cwd?: string;
+    /** Include items even if they fail validation. Default: false */
+    includeInvalid?: boolean;
+    /** Include items disabled via settings. Default: false */
+    includeDisabled?: boolean;
+    /** Explicit disabled extension IDs to apply instead of settings. */
+    disabledExtensions?: string[];
+}
+/**
+ * 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;
+    /**
+     * Optional disabledExtensions ID for this item.
+     * When present, loadCapability() can hide items disabled via settings.
+     */
+    toExtensionId?(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/dist/types/cli/agents-cli.d.ts

@@ -0,0 +1,12 @@
+export type AgentsAction = "unpack";
+export interface AgentsCommandArgs {
+    action: AgentsAction;
+    flags: {
+        force?: boolean;
+        json?: boolean;
+        dir?: string;
+        user?: boolean;
+        project?: boolean;
+    };
+}
+export declare function runAgentsCommand(cmd: AgentsCommandArgs): Promise<void>;

package/dist/types/cli/args.d.ts

@@ -0,0 +1,52 @@
+/**
+ * CLI argument parsing and help display
+ */
+import { type Effort } from "@oh-my-pi/pi-ai";
+export type Mode = "text" | "json" | "rpc" | "acp" | "rpc-ui";
+export interface Args {
+    cwd?: string;
+    allowHome?: boolean;
+    provider?: string;
+    model?: string;
+    smol?: string;
+    slow?: string;
+    plan?: string;
+    apiKey?: string;
+    systemPrompt?: string;
+    appendSystemPrompt?: string;
+    thinking?: Effort;
+    continue?: boolean;
+    resume?: string | true;
+    help?: boolean;
+    version?: boolean;
+    mode?: Mode;
+    noSession?: boolean;
+    sessionDir?: string;
+    providerSessionId?: string;
+    fork?: string;
+    models?: string[];
+    tools?: string[];
+    noTools?: boolean;
+    noLsp?: boolean;
+    noPty?: boolean;
+    hooks?: string[];
+    extensions?: string[];
+    noExtensions?: boolean;
+    pluginDirs?: string[];
+    print?: boolean;
+    export?: string;
+    noSkills?: boolean;
+    skills?: string[];
+    noRules?: boolean;
+    listModels?: string | true;
+    noTitle?: boolean;
+    messages: string[];
+    fileArgs: string[];
+    /** Unknown flags (potentially extension flags) - map of flag name to value */
+    unknownFlags: Map<string, boolean | string>;
+}
+export declare function parseArgs(args: string[], extensionFlags?: Map<string, {
+    type: "boolean" | "string";
+}>): Args;
+export declare function getExtraHelpText(): string;
+export declare function printHelp(): void;

package/dist/types/cli/classify-install-target.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Classify an install spec as a marketplace plugin reference or a plain npm package.
+ *
+ * Rules (applied in order):
+ *  1. Starts with `@` (scoped npm) -> always npm.
+ *  2. Contains `@` after the first character -> split on the LAST `@`.
+ *     If the right-hand side is a known marketplace name, it's a marketplace ref.
+ *     Otherwise it's an npm spec (e.g. `pkg@1.2.3`).
+ *  3. No `@` -> npm.
+ */
+export declare function classifyInstallTarget(spec: string, knownMarketplaces: Set<string>): {
+    type: "marketplace";
+    name: string;
+    marketplace: string;
+} | {
+    type: "npm";
+    spec: string;
+};

package/dist/types/cli/commands/init-xdg.d.ts

@@ -0,0 +1 @@
+export declare function initXdg(): Promise<void>;

package/dist/types/cli/config-cli.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Config CLI command handlers.
+ *
+ * Handles `omp config <command>` subcommands for managing settings.
+ * Uses the settings schema as the source of truth for available settings.
+ */
+export type ConfigAction = "list" | "get" | "set" | "reset" | "path" | "init-xdg";
+export interface ConfigCommandArgs {
+    action: ConfigAction;
+    key?: string;
+    value?: string;
+    flags: {
+        json?: boolean;
+    };
+}
+/**
+ * Parse config subcommand arguments.
+ * Returns undefined if not a config command.
+ */
+export declare function parseConfigArgs(args: string[]): ConfigCommandArgs | undefined;
+export declare function runConfigCommand(cmd: ConfigCommandArgs): Promise<void>;
+export declare function printConfigHelp(): void;

package/dist/types/cli/file-processor.d.ts

@@ -0,0 +1,11 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+export interface ProcessedFiles {
+    text: string;
+    images: ImageContent[];
+}
+export interface ProcessFileOptions {
+    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    autoResizeImages?: boolean;
+}
+/** Process @file arguments into text content and image attachments */
+export declare function processFileArguments(fileArgs: string[], options?: ProcessFileOptions): Promise<ProcessedFiles>;

package/dist/types/cli/grep-cli.d.ts

@@ -0,0 +1,17 @@
+import { GrepOutputMode } from "@oh-my-pi/pi-natives";
+export interface GrepCommandArgs {
+    pattern: string;
+    path: string;
+    glob?: string;
+    limit: number;
+    context: number;
+    mode: GrepOutputMode;
+    gitignore: boolean;
+}
+/**
+ * Parse grep subcommand arguments.
+ * Returns undefined if not a grep command.
+ */
+export declare function parseGrepArgs(args: string[]): GrepCommandArgs | undefined;
+export declare function runGrepCommand(cmd: GrepCommandArgs): Promise<void>;
+export declare function printGrepHelp(): void;