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

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

@@ -0,0 +1,126 @@
+/**
+ * Settings singleton with sync get/set and background persistence.
+ *
+ * Usage:
+ *   import { settings } from "./settings";
+ *
+ *   const enabled = settings.get("compaction.enabled");  // sync read
+ *   settings.set("theme.dark", "titanium");               // sync write, saves in background
+ *
+ * For tests:
+ *   const isolated = Settings.isolated({ "compaction.enabled": false });
+ */
+import { procmgr } from "@oh-my-pi/pi-utils";
+import type { ModelRole } from "../config/model-registry";
+import { AgentStorage } from "../session/agent-storage";
+import { type EditMode } from "../utils/edit-mode";
+import { type BashInterceptorRule, type GroupPrefix, type GroupTypeMap, type SettingPath, type SettingValue } from "./settings-schema";
+export type * from "./settings-schema";
+export * from "./settings-schema";
+/** Raw settings object as stored in YAML */
+export interface RawSettings {
+    [key: string]: unknown;
+}
+export interface SettingsOptions {
+    /** Current working directory for project settings discovery */
+    cwd?: string;
+    /** Agent directory for config.yml storage */
+    agentDir?: string;
+    /** Don't persist to disk (for tests) */
+    inMemory?: boolean;
+    /** Initial overrides */
+    overrides?: Partial<Record<SettingPath, unknown>>;
+}
+export declare class Settings {
+    #private;
+    private constructor();
+    /**
+     * Initialize the global singleton.
+     * Call once at startup before accessing `settings`.
+     */
+    static init(options?: SettingsOptions): Promise<Settings>;
+    /**
+     * Create an isolated instance for testing.
+     * Does not affect the global singleton.
+     */
+    static isolated(overrides?: Partial<Record<SettingPath, unknown>>): Settings;
+    /**
+     * Get the global singleton.
+     * Throws if not initialized.
+     */
+    static get instance(): Settings;
+    /**
+     * Get a setting value (sync).
+     * Returns the merged value from global + project + overrides, or the default.
+     */
+    get<P extends SettingPath>(path: P): SettingValue<P>;
+    /**
+     * Set a setting value (sync).
+     * Updates global settings and queues a background save.
+     * Triggers hooks for settings that have side effects.
+     */
+    set<P extends SettingPath>(path: P, value: SettingValue<P>): void;
+    /**
+     * Apply runtime overrides (not persisted).
+     */
+    override<P extends SettingPath>(path: P, value: SettingValue<P>): void;
+    /**
+     * Clear a runtime override.
+     */
+    clearOverride(path: SettingPath): void;
+    /**
+     * Flush any pending saves to disk.
+     * Call before exit to ensure all changes are persisted.
+     */
+    flush(): Promise<void>;
+    cloneForCwd(cwd: string): Promise<Settings>;
+    getStorage(): AgentStorage | null;
+    getCwd(): string;
+    getAgentDir(): string;
+    getPlansDirectory(): string;
+    /**
+     * Get shell configuration based on settings.
+     */
+    getShellConfig(): procmgr.ShellConfig;
+    /**
+     * Get all settings in a group with full type safety.
+     */
+    getGroup<G extends GroupPrefix>(prefix: G): GroupTypeMap[G];
+    /**
+     * Get the edit variant for a specific model.
+     * Returns "patch", "replace", "hashline", "vim", "apply_patch", or null (use global default).
+     */
+    getEditVariantForModel(model: string | undefined): EditMode | null;
+    /**
+     * Get bash interceptor rules (typed accessor for complex array config).
+     */
+    getBashInterceptorRules(): BashInterceptorRule[];
+    /**
+     * Set a model role (helper for modelRoles record).
+     */
+    setModelRole(role: ModelRole | string, modelId: string): void;
+    /**
+     * Get a model role (helper for modelRoles record).
+     */
+    getModelRole(role: ModelRole | string): string | undefined;
+    /**
+     * Get all model roles (helper for modelRoles record).
+     */
+    getModelRoles(): ReadOnlyDict<string>;
+    overrideModelRoles(roles: ReadOnlyDict<string>): void;
+    /**
+     * Set disabled providers (for compatibility with discovery system).
+     */
+    setDisabledProviders(ids: string[]): void;
+}
+export declare function isSettingsInitialized(): boolean;
+/**
+ * Reset the global singleton for testing.
+ * @internal
+ */
+export declare function resetSettingsForTest(): void;
+/**
+ * The global settings singleton.
+ * Must call `Settings.init()` before using.
+ */
+export declare const settings: Settings;

package/dist/types/config.d.ts

@@ -0,0 +1,66 @@
+export * from "./config/config-file";
+/**
+ * Get the base directory for resolving optional package assets (docs, examples).
+ * Walk up from import.meta.dir until we find package.json, or fall back to cwd.
+ */
+export declare function getPackageDir(): string;
+/** Get path to CHANGELOG.md (optional, may not exist in binary) */
+export declare function getChangelogPath(): string;
+export interface ConfigDirEntry {
+    path: string;
+    source: string;
+    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: getProjectDir() */
+    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 declare function getConfigDirs(subpath: string, options?: GetConfigDirsOptions): ConfigDirEntry[];
+/**
+ * Get all config directory paths for a subpath (convenience wrapper).
+ * Returns just the paths, highest priority first.
+ */
+export declare function getConfigDirPaths(subpath: string, options?: GetConfigDirsOptions): string[];
+export interface ConfigFileResult<T> {
+    path: string;
+    source: string;
+    level: "user" | "project";
+    content: T;
+}
+/**
+ * Find the first existing config file (for non-JSON files like SYSTEM.md).
+ * Returns just the path, or undefined if not found.
+ */
+export declare function findConfigFile(subpath: string, options?: GetConfigDirsOptions): string | undefined;
+/**
+ * Find the first existing config file with metadata.
+ */
+export declare function findConfigFileWithMeta(subpath: string, options?: GetConfigDirsOptions): Omit<ConfigFileResult<never>, "content"> | undefined;
+/**
+ * Find all nearest config directories by walking up from cwd.
+ * Returns one entry per config base (.omp, .claude) - the nearest one found.
+ * Results are in priority order (highest first).
+ */
+export declare function findAllNearestProjectConfigDirs(subpath: string, cwd?: string): ConfigDirEntry[];

package/dist/types/cursor.d.ts

@@ -0,0 +1,22 @@
+import type { AgentEvent, AgentTool, AgentToolContext } from "@oh-my-pi/pi-agent-core";
+import type { CursorMcpCall, CursorShellStreamCallbacks, CursorExecHandlers as ICursorExecHandlers, ToolResultMessage } from "@oh-my-pi/pi-ai";
+interface CursorExecBridgeOptions {
+    cwd: string;
+    tools: Map<string, AgentTool>;
+    getToolContext?: () => AgentToolContext | undefined;
+    emitEvent?: (event: AgentEvent) => void;
+}
+export declare class CursorExecHandlers implements ICursorExecHandlers {
+    private options;
+    constructor(options: CursorExecBridgeOptions);
+    read(args: Parameters<NonNullable<ICursorExecHandlers["read"]>>[0]): Promise<ToolResultMessage<any>>;
+    ls(args: Parameters<NonNullable<ICursorExecHandlers["ls"]>>[0]): Promise<ToolResultMessage<any>>;
+    grep(args: Parameters<NonNullable<ICursorExecHandlers["grep"]>>[0]): Promise<ToolResultMessage<any>>;
+    write(args: Parameters<NonNullable<ICursorExecHandlers["write"]>>[0]): Promise<ToolResultMessage<any>>;
+    delete(args: Parameters<NonNullable<ICursorExecHandlers["delete"]>>[0]): Promise<ToolResultMessage<any>>;
+    shell(args: Parameters<NonNullable<ICursorExecHandlers["shell"]>>[0]): Promise<ToolResultMessage<any>>;
+    shellStream(args: Parameters<NonNullable<ICursorExecHandlers["shellStream"]>>[0], callbacks: CursorShellStreamCallbacks): Promise<ToolResultMessage<any>>;
+    diagnostics(args: Parameters<NonNullable<ICursorExecHandlers["diagnostics"]>>[0]): Promise<ToolResultMessage<any>>;
+    mcp(call: CursorMcpCall): Promise<ToolResultMessage<any>>;
+}
+export {};

package/dist/types/dap/client.d.ts

@@ -0,0 +1,38 @@
+import type { DapCapabilities, DapClientState, DapEventMessage, DapInitializeArguments, DapRequestMessage, DapResolvedAdapter } from "./types";
+interface DapSpawnOptions {
+    adapter: DapResolvedAdapter;
+    cwd: string;
+}
+/** Minimal write interface shared by Bun.FileSink and Bun TCP sockets. */
+interface DapWriteSink {
+    write(data: string | Uint8Array): number | Promise<number>;
+    flush(): number | Promise<number> | undefined;
+}
+type DapEventHandler = (body: unknown, event: DapEventMessage) => void | Promise<void>;
+type DapReverseRequestHandler = (args: unknown) => unknown | Promise<unknown>;
+export declare class DapClient {
+    #private;
+    readonly adapter: DapResolvedAdapter;
+    readonly cwd: string;
+    readonly proc: DapClientState["proc"];
+    constructor(adapter: DapResolvedAdapter, cwd: string, proc: DapClientState["proc"], options?: {
+        readable?: ReadableStream<Uint8Array>;
+        writeSink?: DapWriteSink;
+        socket?: {
+            end(): void;
+        };
+    });
+    static spawn({ adapter, cwd }: DapSpawnOptions): Promise<DapClient>;
+    get capabilities(): DapCapabilities | undefined;
+    get lastActivity(): number;
+    isAlive(): boolean;
+    initialize(args: DapInitializeArguments, signal?: AbortSignal, timeoutMs?: number): Promise<DapCapabilities>;
+    onEvent(event: string, handler: DapEventHandler): () => void;
+    onAnyEvent(handler: DapEventHandler): () => void;
+    onReverseRequest(command: string, handler: DapReverseRequestHandler): () => void;
+    waitForEvent<TBody>(event: string, predicate?: (body: TBody) => boolean, signal?: AbortSignal, timeoutMs?: number): Promise<TBody>;
+    sendRequest<TBody = unknown>(command: string, args?: unknown, signal?: AbortSignal, timeoutMs?: number): Promise<TBody>;
+    sendResponse(request: DapRequestMessage, success: boolean, body?: unknown, message?: string): Promise<void>;
+    dispose(): Promise<void>;
+}
+export {};

package/dist/types/dap/config.d.ts

@@ -0,0 +1,6 @@
+import type { DapAdapterConfig, DapResolvedAdapter } from "./types";
+export declare function getAdapterConfigs(): Record<string, DapAdapterConfig>;
+export declare function resolveAdapter(adapterName: string, cwd: string): DapResolvedAdapter | null;
+export declare function getAvailableAdapters(cwd: string): DapResolvedAdapter[];
+export declare function selectLaunchAdapter(program: string, cwd: string, adapterName?: string): DapResolvedAdapter | null;
+export declare function selectAttachAdapter(cwd: string, adapterName?: string, port?: number): DapResolvedAdapter | null;

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

@@ -0,0 +1,4 @@
+export * from "./client";
+export * from "./config";
+export * from "./session";
+export * from "./types";

package/dist/types/dap/session.d.ts

@@ -0,0 +1,108 @@
+import type { DapAttachSessionOptions, DapBreakpointRecord, DapCapabilities, DapContinueOutcome, DapDataBreakpointInfoResponse, DapDataBreakpointRecord, DapDisassembledInstruction, DapEvaluateArguments, DapEvaluateResponse, DapFunctionBreakpointRecord, DapInstructionBreakpointRecord, DapLaunchSessionOptions, DapModule, DapSessionSummary, DapSource, DapStackFrame, DapThread } from "./types";
+export interface DapOutputSnapshot {
+    snapshot: DapSessionSummary;
+    output: string;
+}
+export declare class DapSessionManager {
+    #private;
+    constructor();
+    getActiveSession(): DapSessionSummary | null;
+    listSessions(): DapSessionSummary[];
+    getCapabilities(): DapCapabilities | null;
+    launch(options: DapLaunchSessionOptions, signal?: AbortSignal, timeoutMs?: number): Promise<DapSessionSummary>;
+    attach(options: DapAttachSessionOptions, signal?: AbortSignal, timeoutMs?: number): Promise<DapSessionSummary>;
+    setBreakpoint(file: string, line: number, condition?: string, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        breakpoints: DapBreakpointRecord[];
+        sourcePath: string;
+    }>;
+    removeBreakpoint(file: string, line: number, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        breakpoints: DapBreakpointRecord[];
+        sourcePath: string;
+    }>;
+    setFunctionBreakpoint(name: string, condition?: string, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        breakpoints: DapFunctionBreakpointRecord[];
+    }>;
+    removeFunctionBreakpoint(name: string, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        breakpoints: DapFunctionBreakpointRecord[];
+    }>;
+    setInstructionBreakpoint(instructionReference: string, offset?: number, condition?: string, hitCondition?: string, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        breakpoints: DapInstructionBreakpointRecord[];
+    }>;
+    removeInstructionBreakpoint(instructionReference: string, offset?: number, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        breakpoints: DapInstructionBreakpointRecord[];
+    }>;
+    dataBreakpointInfo(name: string, variablesReference?: number, frameId?: number, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        info: DapDataBreakpointInfoResponse;
+    }>;
+    setDataBreakpoint(dataId: string, accessType?: "read" | "write" | "readWrite", condition?: string, hitCondition?: string, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        breakpoints: DapDataBreakpointRecord[];
+    }>;
+    removeDataBreakpoint(dataId: string, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        breakpoints: DapDataBreakpointRecord[];
+    }>;
+    disassemble(memoryReference: string, instructionCount: number, offset?: number, instructionOffset?: number, resolveSymbols?: boolean, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        instructions: DapDisassembledInstruction[];
+    }>;
+    readMemory(memoryReference: string, count: number, offset?: number, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        address: string;
+        data?: string;
+        unreadableBytes?: number;
+    }>;
+    writeMemory(memoryReference: string, data: string, offset?: number, allowPartial?: boolean, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        offset?: number;
+        bytesWritten?: number;
+    }>;
+    modules(startModule?: number, moduleCount?: number, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        modules: DapModule[];
+    }>;
+    loadedSources(signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        sources: DapSource[];
+    }>;
+    customRequest(command: string, args?: Record<string, unknown>, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        body: unknown;
+    }>;
+    continue(signal?: AbortSignal, timeoutMs?: number): Promise<DapContinueOutcome>;
+    pause(signal?: AbortSignal, timeoutMs?: number): Promise<DapSessionSummary>;
+    stepIn(signal?: AbortSignal, timeoutMs?: number): Promise<DapContinueOutcome>;
+    stepOut(signal?: AbortSignal, timeoutMs?: number): Promise<DapContinueOutcome>;
+    stepOver(signal?: AbortSignal, timeoutMs?: number): Promise<DapContinueOutcome>;
+    threads(signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        threads: DapThread[];
+    }>;
+    stackTrace(frameCount: number | undefined, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        stackFrames: DapStackFrame[];
+        totalFrames?: number;
+    }>;
+    scopes(frameId: number | undefined, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        scopes: import("./types").DapScope[];
+    }>;
+    variables(variableReference: number, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        variables: import("./types").DapVariable[];
+    }>;
+    evaluate(expression: string, context: DapEvaluateArguments["context"], frameId: number | undefined, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        snapshot: DapSessionSummary;
+        evaluation: DapEvaluateResponse;
+    }>;
+    getOutput(limitBytes?: number): DapOutputSnapshot;
+    terminate(signal?: AbortSignal, timeoutMs?: number): Promise<DapSessionSummary | null>;
+}
+export declare const dapSessionManager: DapSessionManager;