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

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

@@ -0,0 +1,4 @@
+/**
+ * Entry points for the omp commit command.
+ */
+export { runCommitCommand } from "./pipeline";

package/dist/types/commit/map-reduce/index.d.ts

@@ -0,0 +1,28 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { ConventionalAnalysis } from "../../commit/types";
+export interface MapReduceSettings {
+    enabled?: boolean;
+    minFiles?: number;
+    maxFileTokens?: number;
+    maxConcurrency?: number;
+    timeoutMs?: number;
+}
+export interface MapReduceInput {
+    model: Model<Api>;
+    apiKey: string;
+    thinkingLevel?: ThinkingLevel;
+    smolModel: Model<Api>;
+    smolApiKey: string;
+    smolThinkingLevel?: ThinkingLevel;
+    diff: string;
+    stat: string;
+    scopeCandidates: string;
+    typesDescription?: string;
+    settings?: MapReduceSettings;
+}
+export declare function shouldUseMapReduce(diff: string, settings?: MapReduceSettings): boolean;
+/**
+ * Run map-reduce analysis for large diffs using smol + primary models.
+ */
+export declare function runMapReduceAnalysis(input: MapReduceInput): Promise<ConventionalAnalysis>;

package/dist/types/commit/map-reduce/map-phase.d.ts

@@ -0,0 +1,17 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { FileDiff, FileObservation } from "../../commit/types";
+export interface MapPhaseInput {
+    model: Model<Api>;
+    apiKey: string;
+    thinkingLevel?: ThinkingLevel;
+    files: FileDiff[];
+    config?: {
+        maxFileTokens?: number;
+        maxConcurrency?: number;
+        timeoutMs?: number;
+        maxRetries?: number;
+        retryBackoffMs?: number;
+    };
+}
+export declare function runMapPhase({ model, apiKey, thinkingLevel, files, config }: MapPhaseInput): Promise<FileObservation[]>;

package/dist/types/commit/map-reduce/reduce-phase.d.ts

@@ -0,0 +1,13 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { ConventionalAnalysis, FileObservation } from "../../commit/types";
+export interface ReducePhaseInput {
+    model: Model<Api>;
+    apiKey: string;
+    thinkingLevel?: ThinkingLevel;
+    observations: FileObservation[];
+    stat: string;
+    scopeCandidates: string;
+    typesDescription?: string;
+}
+export declare function runReducePhase({ model, apiKey, thinkingLevel, observations, stat, scopeCandidates, typesDescription }: ReducePhaseInput): Promise<ConventionalAnalysis>;

package/dist/types/commit/map-reduce/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function estimateTokens(text: string): number;
+export declare function truncateToTokenLimit(text: string, maxTokens: number): string;

package/dist/types/commit/message.d.ts

@@ -0,0 +1,2 @@
+import type { ConventionalAnalysis } from "./types";
+export declare function formatCommitMessage(analysis: ConventionalAnalysis, summary: string): string;

package/dist/types/commit/model-selection.d.ts

@@ -0,0 +1,15 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { type ModelLookupRegistry } from "../config/model-resolver";
+import type { Settings } from "../config/settings";
+export interface ResolvedCommitModel {
+    model: Model<Api>;
+    apiKey: string;
+    thinkingLevel?: ThinkingLevel;
+}
+type CommitModelRegistry = ModelLookupRegistry & {
+    getApiKey: (model: Model<Api>) => Promise<string | undefined>;
+};
+export declare function resolvePrimaryModel(override: string | undefined, settings: Settings, modelRegistry: CommitModelRegistry): Promise<ResolvedCommitModel>;
+export declare function resolveSmolModel(settings: Settings, modelRegistry: CommitModelRegistry, fallbackModel: Model<Api>, fallbackApiKey: string): Promise<ResolvedCommitModel>;
+export {};

package/dist/types/commit/pipeline.d.ts

@@ -0,0 +1,5 @@
+import type { CommitCommandArgs } from "./types";
+/**
+ * Execute the omp commit pipeline for staged changes.
+ */
+export declare function runCommitCommand(args: CommitCommandArgs): Promise<void>;

package/dist/types/commit/shared-llm.d.ts

@@ -0,0 +1,54 @@
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import * as z from "zod/v4";
+import type { ConventionalAnalysis } from "./types";
+/**
+ * Shared Zod schema for the `create_conventional_analysis` tool used by
+ * both the single-pass analysis call and the map-reduce reduce phase. Schemas
+ * are identical across phases — only the surrounding tool `description`
+ * differs to reflect the input the phase is summarizing.
+ */
+export declare const conventionalAnalysisParameters: z.ZodObject<{
+    type: z.ZodEnum<{
+        build: "build";
+        chore: "chore";
+        ci: "ci";
+        docs: "docs";
+        feat: "feat";
+        fix: "fix";
+        perf: "perf";
+        refactor: "refactor";
+        revert: "revert";
+        style: "style";
+        test: "test";
+    }>;
+    scope: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    details: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        changelog_category: z.ZodOptional<z.ZodEnum<{
+            Added: "Added";
+            "Breaking Changes": "Breaking Changes";
+            Changed: "Changed";
+            Deprecated: "Deprecated";
+            Fixed: "Fixed";
+            Removed: "Removed";
+            Security: "Security";
+        }>>;
+        user_visible: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    issue_refs: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export interface ConventionalAnalysisTool {
+    name: "create_conventional_analysis";
+    description: string;
+    parameters: typeof conventionalAnalysisParameters;
+}
+/**
+ * Build a `create_conventional_analysis` tool descriptor. Phase-specific
+ * `description` text is the only thing that varies between callers.
+ */
+export declare function createConventionalAnalysisTool(description: string): ConventionalAnalysisTool;
+/**
+ * Extract a {@link ConventionalAnalysis} from an assistant response, preferring
+ * a structured tool call and falling back to JSON embedded in text content.
+ */
+export declare function parseConventionalAnalysisResponse(message: AssistantMessage, tool: ConventionalAnalysisTool): ConventionalAnalysis;

package/dist/types/commit/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Types for the omp commit pipeline.
+ */
+export type CommitType = "feat" | "fix" | "refactor" | "perf" | "docs" | "test" | "build" | "ci" | "chore" | "style" | "revert";
+export type ChangelogCategory = "Breaking Changes" | "Added" | "Changed" | "Deprecated" | "Removed" | "Fixed" | "Security";
+export declare const CHANGELOG_CATEGORIES: ChangelogCategory[];
+export interface CommitCommandArgs {
+    /** Push after commit */
+    push: boolean;
+    /** Preview without committing */
+    dryRun: boolean;
+    /** Skip changelog updates */
+    noChangelog: boolean;
+    /** Use legacy deterministic pipeline */
+    legacy?: boolean;
+    /** Additional user context for the model */
+    context?: string;
+    /** Override the model selection */
+    model?: string;
+}
+export interface NumstatEntry {
+    path: string;
+    additions: number;
+    deletions: number;
+}
+export interface ConventionalDetail {
+    text: string;
+    changelogCategory?: ChangelogCategory;
+    userVisible: boolean;
+}
+export interface ConventionalAnalysis {
+    type: CommitType;
+    scope: string | null;
+    details: ConventionalDetail[];
+    issueRefs: string[];
+}
+export interface CommitSummary {
+    summary: string;
+}
+export interface FileObservation {
+    file: string;
+    observations: string[];
+    additions: number;
+    deletions: number;
+}
+export interface FileDiff {
+    filename: string;
+    content: string;
+    additions: number;
+    deletions: number;
+    isBinary: boolean;
+}
+export interface DiffHunk {
+    index: number;
+    header: string;
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    content: string;
+}
+export interface FileHunks {
+    filename: string;
+    isBinary: boolean;
+    hunks: DiffHunk[];
+}
+export interface ChangelogBoundary {
+    changelogPath: string;
+    files: string[];
+}
+export interface UnreleasedSection {
+    startLine: number;
+    endLine: number;
+    entries: Record<string, string[]>;
+}
+export interface ChangelogGenerationResult {
+    entries: Record<string, string[]>;
+}

package/dist/types/commit/utils/exclusions.d.ts

@@ -0,0 +1,4 @@
+export declare function isExcludedFile(path: string): boolean;
+export declare function filterExcludedFiles<T extends {
+    filename: string;
+}>(files: T[]): T[];

package/dist/types/commit/utils.d.ts

@@ -0,0 +1,20 @@
+import type { AssistantMessage, ToolCall } from "@oh-my-pi/pi-ai";
+import type { ChangelogCategory, ConventionalAnalysis, ConventionalDetail } from "./types";
+export declare function extractToolCall(message: AssistantMessage, name: string): ToolCall | undefined;
+export declare function extractTextContent(message: AssistantMessage): string;
+export declare function parseJsonPayload(text: string): unknown;
+export declare function normalizeAnalysis(parsed: {
+    type: ConventionalAnalysis["type"];
+    scope: string | null;
+    details: Array<{
+        text: string;
+        changelog_category?: ChangelogCategory;
+        user_visible?: boolean;
+    }>;
+    issue_refs: string[];
+}): ConventionalAnalysis;
+export declare function normalizeDetails(details: Array<{
+    text: string;
+    changelog_category?: ConventionalDetail["changelogCategory"];
+    user_visible?: boolean;
+}>): ConventionalDetail[];

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

@@ -0,0 +1,58 @@
+import type { ZodType } from "zod/v4";
+/** Minimal subset of the AJV ConfigSchemaError shape this module actually relies on. */
+interface ConfigSchemaError {
+    instancePath: string;
+    message: string | undefined;
+}
+export interface IConfigFile<T> {
+    readonly id: string;
+    readonly schema: ZodType<T>;
+    path?(): string;
+    load(): T | null;
+    invalidate?(): void;
+}
+export declare class ConfigError extends Error {
+    #private;
+    readonly id: string;
+    readonly schemaErrors: ConfigSchemaError[] | null | undefined;
+    readonly other?: {
+        err: unknown;
+        stage: string;
+    } | undefined;
+    constructor(id: string, schemaErrors: ConfigSchemaError[] | null | undefined, other?: {
+        err: unknown;
+        stage: string;
+    } | undefined);
+    get message(): string;
+    toString(): string;
+}
+export type LoadStatus = "ok" | "error" | "not-found";
+export type LoadResult<T> = {
+    value?: null;
+    error: ConfigError;
+    status: "error";
+} | {
+    value: T;
+    error?: undefined;
+    status: "ok";
+} | {
+    value?: null;
+    error?: unknown;
+    status: "not-found";
+};
+export declare class ConfigFile<T> implements IConfigFile<T> {
+    #private;
+    readonly id: string;
+    readonly schema: ZodType<T>;
+    constructor(id: string, schema: ZodType<T>, configPath?: string);
+    relocate(configPath?: string): ConfigFile<T>;
+    getMtimeMs(): number | null;
+    withValidation(name: string, validate: (value: T) => void): this;
+    createDefault(): T;
+    tryLoad(): LoadResult<T>;
+    load(): T | null;
+    loadOrDefault(): T;
+    path(): string;
+    invalidate(): void;
+}
+export {};

package/dist/types/config/file-lock.d.ts

@@ -0,0 +1,6 @@
+export interface FileLockOptions {
+    staleMs?: number;
+    retries?: number;
+    retryDelayMs?: number;
+}
+export declare function withFileLock<T>(filePath: string, fn: () => Promise<T>, options?: FileLockOptions): Promise<T>;

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

@@ -0,0 +1,334 @@
+import { type Keybinding, type KeybindingsConfig, type KeyId, KeybindingsManager as TuiKeybindingsManager } from "@oh-my-pi/pi-tui";
+/**
+ * Application-level keybindings (coding agent specific).
+ * Values are always `true` — used for declaration merging.
+ */
+interface AppKeybindings {
+    "app.interrupt": true;
+    "app.clear": true;
+    "app.exit": true;
+    "app.suspend": true;
+    "app.thinking.cycle": true;
+    "app.thinking.toggle": true;
+    "app.model.cycleForward": true;
+    "app.model.cycleBackward": true;
+    "app.model.select": true;
+    "app.model.selectTemporary": true;
+    "app.tools.expand": true;
+    "app.editor.external": true;
+    "app.message.followUp": true;
+    "app.message.dequeue": true;
+    "app.clipboard.pasteImage": true;
+    "app.clipboard.copyLine": true;
+    "app.clipboard.copyPrompt": true;
+    "app.session.new": true;
+    "app.session.tree": true;
+    "app.session.fork": true;
+    "app.session.resume": true;
+    "app.session.observe": true;
+    "app.session.togglePath": true;
+    "app.session.toggleSort": true;
+    "app.session.rename": true;
+    "app.session.delete": true;
+    "app.session.deleteNoninvasive": true;
+    "app.tree.foldOrUp": true;
+    "app.tree.unfoldOrDown": true;
+    "app.plan.toggle": true;
+    "app.history.search": true;
+    "app.stt.toggle": true;
+}
+export type AppKeybinding = keyof AppKeybindings;
+declare module "@oh-my-pi/pi-tui" {
+    interface Keybindings extends AppKeybindings {
+    }
+}
+/**
+ * All keybindings definitions: TUI + app-specific.
+ */
+export declare const KEYBINDINGS: {
+    readonly "tui.editor.cursorUp": {
+        readonly defaultKeys: "up";
+        readonly description: "Move cursor up";
+    };
+    readonly "tui.editor.cursorDown": {
+        readonly defaultKeys: "down";
+        readonly description: "Move cursor down";
+    };
+    readonly "tui.editor.cursorLeft": {
+        readonly defaultKeys: ["left", "ctrl+b"];
+        readonly description: "Move cursor left";
+    };
+    readonly "tui.editor.cursorRight": {
+        readonly defaultKeys: ["right", "ctrl+f"];
+        readonly description: "Move cursor right";
+    };
+    readonly "tui.editor.cursorWordLeft": {
+        readonly defaultKeys: ["alt+left", "ctrl+left", "alt+b"];
+        readonly description: "Move cursor word left";
+    };
+    readonly "tui.editor.cursorWordRight": {
+        readonly defaultKeys: ["alt+right", "ctrl+right", "alt+f"];
+        readonly description: "Move cursor word right";
+    };
+    readonly "tui.editor.cursorLineStart": {
+        readonly defaultKeys: ["home", "ctrl+a"];
+        readonly description: "Move to line start";
+    };
+    readonly "tui.editor.cursorLineEnd": {
+        readonly defaultKeys: ["end", "ctrl+e"];
+        readonly description: "Move to line end";
+    };
+    readonly "tui.editor.jumpForward": {
+        readonly defaultKeys: "ctrl+]";
+        readonly description: "Jump forward to character";
+    };
+    readonly "tui.editor.jumpBackward": {
+        readonly defaultKeys: "ctrl+alt+]";
+        readonly description: "Jump backward to character";
+    };
+    readonly "tui.editor.pageUp": {
+        readonly defaultKeys: "pageUp";
+        readonly description: "Page up";
+    };
+    readonly "tui.editor.pageDown": {
+        readonly defaultKeys: "pageDown";
+        readonly description: "Page down";
+    };
+    readonly "tui.editor.deleteCharBackward": {
+        readonly defaultKeys: "backspace";
+        readonly description: "Delete character backward";
+    };
+    readonly "tui.editor.deleteCharForward": {
+        readonly defaultKeys: ["delete", "ctrl+d"];
+        readonly description: "Delete character forward";
+    };
+    readonly "tui.editor.deleteWordBackward": {
+        readonly defaultKeys: ["ctrl+w", "alt+backspace", "ctrl+backspace"];
+        readonly description: "Delete word backward";
+    };
+    readonly "tui.editor.deleteWordForward": {
+        readonly defaultKeys: ["alt+delete", "alt+d"];
+        readonly description: "Delete word forward";
+    };
+    readonly "tui.editor.deleteToLineStart": {
+        readonly defaultKeys: "ctrl+u";
+        readonly description: "Delete to line start";
+    };
+    readonly "tui.editor.deleteToLineEnd": {
+        readonly defaultKeys: "ctrl+k";
+        readonly description: "Delete to line end";
+    };
+    readonly "tui.editor.yank": {
+        readonly defaultKeys: "ctrl+y";
+        readonly description: "Yank";
+    };
+    readonly "tui.editor.yankPop": {
+        readonly defaultKeys: "alt+y";
+        readonly description: "Yank pop";
+    };
+    readonly "tui.editor.undo": {
+        readonly defaultKeys: ["ctrl+-", "ctrl+_"];
+        readonly description: "Undo";
+    };
+    readonly "tui.input.newLine": {
+        readonly defaultKeys: "shift+enter";
+        readonly description: "Insert newline";
+    };
+    readonly "tui.input.submit": {
+        readonly defaultKeys: "enter";
+        readonly description: "Submit input";
+    };
+    readonly "tui.input.tab": {
+        readonly defaultKeys: "tab";
+        readonly description: "Tab / autocomplete";
+    };
+    readonly "tui.input.copy": {
+        readonly defaultKeys: "ctrl+c";
+        readonly description: "Copy selection";
+    };
+    readonly "tui.select.up": {
+        readonly defaultKeys: "up";
+        readonly description: "Move selection up";
+    };
+    readonly "tui.select.down": {
+        readonly defaultKeys: "down";
+        readonly description: "Move selection down";
+    };
+    readonly "tui.select.pageUp": {
+        readonly defaultKeys: "pageUp";
+        readonly description: "Selection page up";
+    };
+    readonly "tui.select.pageDown": {
+        readonly defaultKeys: "pageDown";
+        readonly description: "Selection page down";
+    };
+    readonly "tui.select.confirm": {
+        readonly defaultKeys: "enter";
+        readonly description: "Confirm selection";
+    };
+    readonly "tui.select.cancel": {
+        readonly defaultKeys: ["escape", "ctrl+c"];
+        readonly description: "Cancel selection";
+    };
+    readonly "app.interrupt": {
+        readonly defaultKeys: "escape";
+        readonly description: "Interrupt current operation";
+    };
+    readonly "app.clear": {
+        readonly defaultKeys: "ctrl+c";
+        readonly description: "Clear screen or cancel";
+    };
+    readonly "app.exit": {
+        readonly defaultKeys: "ctrl+d";
+        readonly description: "Exit application";
+    };
+    readonly "app.suspend": {
+        readonly defaultKeys: "ctrl+z";
+        readonly description: "Suspend application";
+    };
+    readonly "app.thinking.cycle": {
+        readonly defaultKeys: "shift+tab";
+        readonly description: "Cycle thinking level";
+    };
+    readonly "app.thinking.toggle": {
+        readonly defaultKeys: "ctrl+t";
+        readonly description: "Toggle thinking mode";
+    };
+    readonly "app.model.cycleForward": {
+        readonly defaultKeys: "ctrl+p";
+        readonly description: "Cycle to next model";
+    };
+    readonly "app.model.cycleBackward": {
+        readonly defaultKeys: "shift+ctrl+p";
+        readonly description: "Cycle to previous model";
+    };
+    readonly "app.model.select": {
+        readonly defaultKeys: "ctrl+l";
+        readonly description: "Select model";
+    };
+    readonly "app.model.selectTemporary": {
+        readonly defaultKeys: "alt+p";
+        readonly description: "Select temporary model for current session";
+    };
+    readonly "app.tools.expand": {
+        readonly defaultKeys: "ctrl+o";
+        readonly description: "Expand tools";
+    };
+    readonly "app.editor.external": {
+        readonly defaultKeys: "ctrl+g";
+        readonly description: "Open external editor";
+    };
+    readonly "app.message.followUp": {
+        readonly defaultKeys: "ctrl+enter";
+        readonly description: "Send follow-up message";
+    };
+    readonly "app.message.dequeue": {
+        readonly defaultKeys: "alt+up";
+        readonly description: "Dequeue message";
+    };
+    readonly "app.clipboard.pasteImage": {
+        readonly defaultKeys: "alt+v" | "ctrl+v";
+        readonly description: "Paste image from clipboard";
+    };
+    readonly "app.clipboard.copyLine": {
+        readonly defaultKeys: "alt+shift+l";
+        readonly description: "Copy current line";
+    };
+    readonly "app.clipboard.copyPrompt": {
+        readonly defaultKeys: "alt+shift+c";
+        readonly description: "Copy prompt";
+    };
+    readonly "app.session.new": {
+        readonly defaultKeys: [];
+        readonly description: "Create new session";
+    };
+    readonly "app.session.tree": {
+        readonly defaultKeys: [];
+        readonly description: "Show session tree";
+    };
+    readonly "app.session.fork": {
+        readonly defaultKeys: [];
+        readonly description: "Fork session";
+    };
+    readonly "app.session.resume": {
+        readonly defaultKeys: [];
+        readonly description: "Resume session";
+    };
+    readonly "app.session.observe": {
+        readonly defaultKeys: "ctrl+s";
+        readonly description: "Observe subagent sessions";
+    };
+    readonly "app.session.togglePath": {
+        readonly defaultKeys: "ctrl+p";
+        readonly description: "Toggle session path display";
+    };
+    readonly "app.session.toggleSort": {
+        readonly defaultKeys: "ctrl+s";
+        readonly description: "Toggle session sort order";
+    };
+    readonly "app.session.rename": {
+        readonly defaultKeys: "ctrl+r";
+        readonly description: "Rename session";
+    };
+    readonly "app.session.delete": {
+        readonly defaultKeys: "ctrl+d";
+        readonly description: "Delete session";
+    };
+    readonly "app.session.deleteNoninvasive": {
+        readonly defaultKeys: "ctrl+backspace";
+        readonly description: "Delete session (non-invasive)";
+    };
+    readonly "app.tree.foldOrUp": {
+        readonly defaultKeys: ["ctrl+left", "alt+left"];
+        readonly description: "Fold or move up";
+    };
+    readonly "app.tree.unfoldOrDown": {
+        readonly defaultKeys: ["ctrl+right", "alt+right"];
+        readonly description: "Unfold or move down";
+    };
+    readonly "app.plan.toggle": {
+        readonly defaultKeys: "alt+shift+p";
+        readonly description: "Toggle plan mode";
+    };
+    readonly "app.history.search": {
+        readonly defaultKeys: "ctrl+r";
+        readonly description: "Search history";
+    };
+    readonly "app.stt.toggle": {
+        readonly defaultKeys: "alt+h";
+        readonly description: "Toggle speech-to-text";
+    };
+};
+declare function migrateKeybindingsConfigFile(agentDir: string): void;
+/**
+ * Manages all keybindings (app + TUI).
+ * Extends the TUI KeybindingsManager with app-specific functionality.
+ */
+export declare class KeybindingsManager extends TuiKeybindingsManager {
+    #private;
+    constructor(userBindings?: KeybindingsConfig, configPath?: string);
+    /**
+     * Create from config file at agentDir/keybindings.json.
+     */
+    static create(agentDir?: string): KeybindingsManager;
+    /**
+     * Create an in-memory keybindings manager without file persistence.
+     */
+    static inMemory(userBindings?: KeybindingsConfig): KeybindingsManager;
+    /**
+     * Reload keybindings from the config file.
+     */
+    reload(): void;
+    /**
+     * Get the effective resolved bindings (defaults + user overrides).
+     */
+    getEffectiveConfig(): KeybindingsConfig;
+    /**
+     * Get display string for a keybinding (e.g., "ctrl+c/escape").
+     */
+    getDisplayString(keybinding: Keybinding): string;
+}
+export declare function formatKeyHint(key: KeyId): string;
+export declare function formatKeyHints(keys: KeyId | KeyId[]): string;
+export type { Keybinding, KeybindingsConfig, KeyId };
+export { migrateKeybindingsConfigFile };