oh-my-opencode 4.10.0 → 4.11.0

package/dist/features/monitor/line-stream.d.ts

@@ -0,0 +1,29 @@
+export interface DecodedLine {
+    text: string;
+    rawText: string;
+    truncated?: boolean;
+    binary?: boolean;
+}
+export type LineStreamResult = {
+    lines: DecodedLine[];
+    binarySuppressedBytes: number;
+};
+export declare function stripAnsi(text: string): string;
+export declare class LineStream {
+    private readonly lineMaxBytes;
+    private readonly binaryThreshold;
+    private readonly decoder;
+    private pending;
+    private truncating;
+    constructor(opts: {
+        lineMaxBytes: number;
+        binaryThreshold?: number;
+    });
+    feed(chunk: Uint8Array): LineStreamResult;
+    flush(): LineStreamResult;
+    private isBinaryChunk;
+    private consumeChunk;
+    private consumeBytes;
+    private emitPendingLine;
+    private createLine;
+}

package/dist/features/monitor/manager-internals.d.ts

@@ -0,0 +1,65 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { MonitorConfig } from "../../config/schema/monitor";
+import { registerManagerForCleanup, unregisterManagerForCleanup } from "../background-agent/process-cleanup";
+import { log } from "../../shared";
+import type { InternalPromptDispatchArgs, PromptAsyncInput, PromptDispatchClient } from "../../shared/prompt-async-gate/types";
+import { MonitorBatcher, type SchedulerDeps } from "./batcher";
+import { createMonitorPipeline } from "./pipeline";
+import { spawnMonitoredProcess, type MonitoredProcess } from "./process";
+import { MonitorRingBuffer } from "./ring-buffer";
+import type { MonitorId, MonitorRecord, OutputBatch } from "./types";
+export type MonitorPipeline = ReturnType<typeof createMonitorPipeline>;
+export type MonitorPromptClient = PromptDispatchClient & InternalPromptDispatchArgs<PromptAsyncInput>["client"];
+export interface MonitorInjector {
+    queueBatch(record: MonitorRecord, batch: OutputBatch): void;
+    flushMonitor(monitorId: string): Promise<void>;
+}
+export interface InternalMonitorState {
+    record: MonitorRecord;
+    process: MonitoredProcess;
+    ring: MonitorRingBuffer;
+    batcher: MonitorBatcher;
+    pipeline: MonitorPipeline;
+    injector: MonitorInjector;
+    stopped: boolean;
+}
+export interface MonitorManagerDeps {
+    randomId?: () => MonitorId;
+    isBackgroundSession?: (sessionId: string) => boolean;
+    spawnMonitoredProcess?: typeof spawnMonitoredProcess;
+    createInjector?: (record: MonitorRecord, scheduleFlush: (monitorId: string, delayMs: number, operation: () => Promise<void>) => void) => MonitorInjector;
+    scheduler?: SchedulerDeps;
+    registerManagerForCleanup?: typeof registerManagerForCleanup;
+    unregisterManagerForCleanup?: typeof unregisterManagerForCleanup;
+    log?: typeof log;
+}
+export interface MonitorManagerOptions {
+    pluginContext: Pick<PluginInput, "client" | "directory">;
+    config?: Partial<MonitorConfig>;
+    deps?: MonitorManagerDeps;
+}
+export declare const DEFAULT_MONITOR_CONFIG: {
+    max_monitors_per_session: number;
+    max_runtime_ms: number;
+    batch_max_lines: number;
+    batch_max_bytes: number;
+    flush_interval_ms: number;
+    ring_max_lines: number;
+    line_max_bytes: number;
+    pattern_max_length: number;
+};
+export declare const MONITOR_OUTPUT_PENDING_RETRY_MS = 1000;
+export declare const MONITOR_OUTPUT_ACCEPTED_MESSAGE_SKEW_MS = 5000;
+export declare const MONITOR_OUTPUT_USER_MESSAGE_IN_PROGRESS_WINDOW_MS = 2000;
+export declare const MONITOR_OUTPUT_POST_DISPATCH_HOLD_MS = 250;
+export declare function createEmptyCounters(): {
+    totalLines: number;
+    matchedLines: number;
+    unmatchedLines: number;
+    droppedMatched: number;
+    droppedUnmatched: number;
+    bytesDropped: number;
+    lastSequence: number;
+};
+export declare function createRealScheduler(): SchedulerDeps;
+export declare function createMonitorId(): MonitorId;

package/dist/features/monitor/manager.d.ts

@@ -0,0 +1,35 @@
+import { type MonitorManagerDeps, type MonitorManagerOptions } from "./manager-internals";
+import type { MonitorId, MonitorManager as MonitorManagerContract, MonitorManagerEvent, MonitorOutputQuery, MonitorOutputResult, MonitorRecord, MonitorStartOpts } from "./types";
+export type { MonitorManagerDeps, MonitorManagerOptions };
+export declare class MonitorManager implements MonitorManagerContract {
+    private readonly options;
+    private readonly monitors;
+    private readonly monitorsByParentSession;
+    private readonly scheduledFlushTimers;
+    private readonly config;
+    private readonly scheduler;
+    private readonly registerCleanup;
+    private readonly unregisterCleanup;
+    private readonly logger;
+    private shutdownTriggered;
+    constructor(options: MonitorManagerOptions);
+    start(opts: MonitorStartOpts): Promise<MonitorRecord>;
+    stop(id: MonitorId): Promise<void>;
+    list(sessionId: string): MonitorRecord[];
+    get(id: MonitorId): MonitorRecord | undefined;
+    getOutput(id: MonitorId, opts: MonitorOutputQuery): MonitorOutputResult;
+    stopSessionMonitors(sessionId: string): Promise<void>;
+    handleEvent(event: MonitorManagerEvent): void;
+    shutdown(): Promise<void>;
+    private createId;
+    private scheduleFlush;
+    private clearScheduledFlush;
+    private addMonitor;
+    private assertSessionCapacity;
+    private isBackgroundSession;
+    private isTerminalStatus;
+    private removeMonitor;
+    private enforceTerminalRetention;
+    private flushSessionMonitors;
+}
+export declare function createMonitorManager(options: MonitorManagerOptions): MonitorManager;

package/dist/features/monitor/monitor-state-factory.d.ts

@@ -0,0 +1,24 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { log } from "../../shared";
+import type { MonitorBatcher } from "./batcher";
+import type { DEFAULT_MONITOR_CONFIG, InternalMonitorState, MonitorInjector, MonitorManagerDeps } from "./manager-internals";
+import { type MonitoredProcess } from "./process";
+import { MonitorRingBuffer } from "./ring-buffer";
+import type { MonitorRecord } from "./types";
+interface MonitorStateFactoryInput {
+    record: MonitorRecord;
+    monitoredProcess: MonitoredProcess;
+    filter: {
+        matches(text: string): boolean;
+    };
+    ring: MonitorRingBuffer;
+    batcher: MonitorBatcher;
+    injector: MonitorInjector;
+    config: typeof DEFAULT_MONITOR_CONFIG;
+    logger: typeof log;
+}
+export declare function createMonitorState(input: MonitorStateFactoryInput): InternalMonitorState;
+export declare function observeProcessExit(state: InternalMonitorState, logger: typeof log, onTerminal: (parentSessionId: string) => void): void;
+export declare function spawnMonitorProcess(deps: MonitorManagerDeps | undefined, command: string, maxRuntimeMs: number): MonitoredProcess;
+export declare function createMonitorInjector(deps: MonitorManagerDeps | undefined, pluginContext: Pick<PluginInput, "client" | "directory">, record: MonitorRecord, scheduleFlush: (monitorId: string, delayMs: number, operation: () => Promise<void>) => void): MonitorInjector;
+export {};

package/dist/features/monitor/output-injector-session-inspect.d.ts

@@ -0,0 +1,9 @@
+import type { DispatchedMonitorOutput, MonitorPromptClient, MonitorSessionMessage } from "./output-injector-types";
+export declare function loadMonitorSessionMessages(client: MonitorPromptClient, directory: string, sessionID: string): Promise<MonitorSessionMessage[]>;
+export declare function getMessageRole(message: MonitorSessionMessage): string | undefined;
+export declare function getMessageCreatedAt(message: MonitorSessionMessage): number | undefined;
+export declare function isUserMessageInProgress(client: MonitorPromptClient, directory: string, sessionID: string, now: number, userMessageInProgressWindowMs: number): Promise<boolean>;
+export declare function monitorMessageHasOutput(message: MonitorSessionMessage): boolean;
+export declare function monitorMessageContainsBatch(message: MonitorSessionMessage, output: DispatchedMonitorOutput): boolean;
+export declare function hasAcceptedMessageAfterDispatchedMonitorOutput(client: MonitorPromptClient, directory: string, sessionID: string, output: DispatchedMonitorOutput, acceptedMessageSkewMs: number): Promise<boolean>;
+export declare function latestAssistantTurnBlocksMonitorOutput(client: MonitorPromptClient, directory: string, sessionID: string): Promise<boolean>;

package/dist/features/monitor/output-injector-types.d.ts

@@ -0,0 +1,48 @@
+import type { InternalPromptDispatchArgs, InternalPromptDispatchResult, PromptAsyncInput, PromptDispatchClient } from "../../shared/prompt-async-gate/types";
+import type { MonitorRecord, OutputBatch } from "./types";
+export type MonitorPromptClient = PromptDispatchClient & InternalPromptDispatchArgs<PromptAsyncInput>["client"];
+export type MonitorOutputInjectorDeps = {
+    readonly client: MonitorPromptClient;
+    readonly directory: string;
+    readonly pendingRetryMs: number;
+    readonly acceptedMessageSkewMs: number;
+    readonly userMessageInProgressWindowMs: number;
+    readonly postDispatchHoldMs: number;
+    readonly dispatchInternalPrompt?: (args: InternalPromptDispatchArgs<PromptAsyncInput>) => Promise<InternalPromptDispatchResult>;
+    readonly now?: () => number;
+    readonly settleAfterSessionIdle?: () => Promise<void>;
+    readonly scheduleFlush?: (monitorId: string, delayMs: number, operation: () => Promise<void>) => void;
+};
+export type MonitorSessionMessage = {
+    info?: {
+        role?: string;
+        finish?: string;
+        time?: {
+            created?: unknown;
+        };
+    };
+    role?: string;
+    finish?: string;
+    time?: {
+        created?: unknown;
+    };
+    parts?: Array<{
+        type?: string;
+        text?: string;
+        synthetic?: boolean;
+        content?: unknown;
+        state?: {
+            status?: unknown;
+        };
+    }>;
+};
+export type PendingMonitorOutput = {
+    record: MonitorRecord;
+    batches: OutputBatch[];
+};
+export type DispatchedMonitorOutput = {
+    record: MonitorRecord;
+    batch: OutputBatch;
+    content: string;
+    dispatchedAt: number;
+};

package/dist/features/monitor/output-injector.d.ts

@@ -0,0 +1,21 @@
+import type { MonitorOutputInjectorDeps } from "./output-injector-types";
+import type { MonitorRecord, OutputBatch } from "./types";
+export declare class MonitorOutputInjector {
+    private readonly deps;
+    private readonly pendingOutputs;
+    private readonly dispatchedOutputs;
+    private readonly deliveredSources;
+    constructor(deps: MonitorOutputInjectorDeps);
+    queueBatch(record: MonitorRecord, batch: OutputBatch): void;
+    getPendingBatches(monitorId: string): OutputBatch[];
+    flushMonitor(monitorId: string): Promise<void>;
+    private dispatchBatch;
+    private requeueBatch;
+    private isSessionActive;
+    private settleAfterSessionIdle;
+    private dispatchInternalPrompt;
+    private scheduleFlush;
+    private now;
+    private trackDelivered;
+    private createSource;
+}

package/dist/features/monitor/permission.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Bash-permission feasibility spike, 2026-06-15:
+ * OpenCode exposes Bash permission enforcement to plugin tools through
+ * ToolContext.ask({ permission: "bash", patterns: [command], ... }). The
+ * plugin and SDK surfaces do not expose a pure dry-run evaluator that returns
+ * the exact Bash decision for an arbitrary command string: tool.execute.before
+ * hooks only see the active tool call and mutable args, permission.ask is a
+ * hook for an already-created permission request, and the SDK can only reply to
+ * existing permission requests. Therefore this gate uses an injected
+ * bashPermissionAsk callback when a caller has ToolContext.ask available; if
+ * that callback is absent, it fails closed to monitor.allowed_commands.
+ */
+import type { MonitorConfig as SchemaMonitorConfig } from "../../config/schema/monitor";
+export type MonitorConfig = Pick<SchemaMonitorConfig, "enabled" | "allowed_commands"> & Partial<SchemaMonitorConfig>;
+export type MonitorPermissionVia = "bash-equivalent" | "allowlist" | "feature-disabled";
+export type MonitorPermissionResult = {
+    allowed: boolean;
+    reason: string;
+    via: MonitorPermissionVia;
+};
+export type BashPermissionAskInput = {
+    permission: "bash";
+    patterns: string[];
+    always: string[];
+    metadata: {
+        command: string;
+    };
+};
+export type MonitorPermissionContext = {
+    config: MonitorConfig;
+    bashPermissionAsk?: (input: BashPermissionAskInput) => Promise<void>;
+};
+export declare function checkMonitorCommandPermission(command: string, ctx: MonitorPermissionContext): Promise<MonitorPermissionResult>;

package/dist/features/monitor/pipeline.d.ts

@@ -0,0 +1,26 @@
+import type { MonitorBatcher } from "./batcher";
+import type { LineStream } from "./line-stream";
+import type { MonitorRingBuffer } from "./ring-buffer";
+import type { MonitorCounters, OutputBatch, OutputStreamType } from "./types";
+interface MonitorFilter {
+    matches(text: string): boolean;
+}
+interface MonitorPipelineComponents {
+    lineStream: Record<OutputStreamType, LineStream>;
+    filter: MonitorFilter;
+    ring: MonitorRingBuffer;
+    batcher: MonitorBatcher;
+}
+interface MonitorPipelineDeps {
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    log(error: unknown): void;
+}
+interface MonitorPipeline {
+    onBatch(cb: (batch: OutputBatch) => void): void;
+    counters(): MonitorCounters;
+    isStopped(): boolean;
+    stop(): void;
+}
+export declare function createMonitorPipeline(components: MonitorPipelineComponents, deps: MonitorPipelineDeps): MonitorPipeline;
+export {};

package/dist/features/monitor/process.d.ts

@@ -0,0 +1,21 @@
+export type TimerHandle = ReturnType<typeof setTimeout> | number;
+export interface SpawnDeps {
+    spawn?: typeof Bun.spawn;
+    setTimer: (fn: () => void, ms: number) => TimerHandle;
+    clearTimer: (handle: TimerHandle) => void;
+}
+export interface MonitoredProcess {
+    kill(signal?: NodeJS.Signals): void;
+    exited: Promise<{
+        code: number | null;
+        signal: string | null;
+    }>;
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+}
+export declare function spawnMonitoredProcess(opts: {
+    command: string;
+    cwd?: string;
+    env?: Record<string, string>;
+    maxRuntimeMs: number;
+}, deps: SpawnDeps): MonitoredProcess;

package/dist/features/monitor/ring-buffer.d.ts

@@ -0,0 +1,25 @@
+import type { MonitorCounters, MonitorOutputResult, OutputLine } from "./types";
+type MonitorRingStream = "matched" | "unmatched" | "all";
+interface MonitorRingBufferOptions {
+    ringMaxLines: number;
+}
+interface MonitorRingQueryOptions {
+    stream: MonitorRingStream;
+    since_sequence?: number;
+    limit?: number;
+}
+export declare class MonitorRingBuffer {
+    private readonly ringMaxLines;
+    private readonly matchedLines;
+    private readonly unmatchedLines;
+    private counters;
+    constructor(opts: MonitorRingBufferOptions);
+    push(line: OutputLine, matched: boolean): void;
+    query(opts: MonitorRingQueryOptions): MonitorOutputResult;
+    getCounters(): MonitorCounters;
+    reset(): void;
+    private pushMatched;
+    private pushUnmatched;
+    private selectLines;
+}
+export {};

package/dist/features/monitor/types.d.ts

@@ -0,0 +1,83 @@
+export type MonitorId = string;
+export type MonitorMode = "idle" | "live_safe";
+export type MonitorStatus = "starting" | "running" | "exited" | "stopped" | "failed";
+export type OutputStreamType = "stdout" | "stderr";
+export interface MonitorCounters {
+    totalLines: number;
+    matchedLines: number;
+    unmatchedLines: number;
+    droppedMatched: number;
+    droppedUnmatched: number;
+    bytesDropped: number;
+    lastSequence: number;
+}
+export interface OutputLine {
+    stream: OutputStreamType;
+    seq: number;
+    text: string;
+    truncated?: boolean;
+}
+export interface OutputBatch {
+    monitorId: MonitorId;
+    batchSeq: number;
+    lines: OutputLine[];
+    stillRunning: boolean;
+}
+export interface MonitorRecord {
+    id: MonitorId;
+    command: string;
+    label: string;
+    mode: MonitorMode;
+    parentSessionId: string;
+    startedAt: Date;
+    status: MonitorStatus;
+    exitCode?: number;
+    signal?: string;
+    counters: MonitorCounters;
+}
+export interface MonitorManager {
+    start(opts: MonitorStartOpts): Promise<MonitorRecord>;
+    stop(id: MonitorId): Promise<void>;
+    list(sessionId: string): MonitorRecord[];
+    get(id: MonitorId): MonitorRecord | undefined;
+    getOutput(id: MonitorId, opts: MonitorOutputQuery): MonitorOutputResult;
+    stopSessionMonitors(sessionId: string): Promise<void>;
+    handleEvent(event: MonitorManagerEvent): void;
+    shutdown(): Promise<void>;
+}
+export interface MonitorStartOpts {
+    command: string;
+    label?: string;
+    mode?: MonitorMode;
+    matchPattern?: string;
+    parentSessionId: string;
+    parentMessageId?: string;
+}
+export interface MonitorOutputQuery {
+    stream?: "matched" | "unmatched" | "all";
+    since_sequence?: number;
+    limit?: number;
+}
+export interface MonitorOutputResult {
+    lines: OutputLine[];
+    counters: MonitorCounters;
+}
+export type MonitorManagerEvent = {
+    type: "session.idle";
+    sessionId: string;
+} | {
+    type: "session.deleted";
+    sessionId: string;
+};
+export interface MonitorStartArgs {
+    command: string;
+    label?: string;
+    mode?: MonitorMode;
+    match_pattern?: string;
+}
+export interface MonitorOutputArgs {
+    monitor_id: string;
+    stream?: "matched" | "unmatched" | "all";
+    since_sequence?: number;
+    limit?: number;
+}

package/dist/features/opencode-runtime-skills/index.d.ts

@@ -1,2 +1 @@
-export { applyRuntimeSkillSourceConfig, selectRuntimeSecuritySkills, type OpenCodeSkillHostConfig, type RuntimeSkillSourceEntry, } from "./runtime-skill-config";
-export { createRuntimeSkillSourceServer, type RuntimeSkillSourceServer } from "./source-server";
+export * from "@oh-my-opencode/skills-loader-core/opencode-runtime-skills/index";

package/dist/features/opencode-runtime-skills/runtime-skill-config.d.ts

@@ -1,17 +1 @@
-import type { OhMyOpenCodeConfig } from "../../config";
-import { type OpenCodeSkillMarkdown } from "./skill-markdown";
-export type RuntimeSkillSourceEntry = OpenCodeSkillMarkdown;
-export type OpenCodeSkillsHostConfig = {
-    readonly paths?: readonly string[];
-    readonly urls?: readonly string[];
-    readonly [key: string]: unknown;
-};
-export type OpenCodeSkillHostConfig = Record<string, unknown> & {
-    skills?: OpenCodeSkillsHostConfig;
-};
-export declare function selectRuntimeSecuritySkills(pluginConfig?: Pick<OhMyOpenCodeConfig, "disabled_skills">): RuntimeSkillSourceEntry[];
-export declare function applyRuntimeSkillSourceConfig(params: {
-    readonly config: OpenCodeSkillHostConfig;
-    readonly pluginConfig: Pick<OhMyOpenCodeConfig, "disabled_skills">;
-    readonly sourceUrl: string;
-}): void;
+export * from "@oh-my-opencode/skills-loader-core/opencode-runtime-skills/runtime-skill-config";

package/dist/features/opencode-runtime-skills/skill-markdown.d.ts

@@ -1,7 +1 @@
-import type { BuiltinSkill } from "../builtin-skills/types";
-export type OpenCodeSkillMarkdown = {
-    readonly name: string;
-    readonly description: string;
-    readonly markdown: string;
-};
-export declare function createOpenCodeSkillMarkdown(skill: BuiltinSkill): OpenCodeSkillMarkdown;
+export * from "@oh-my-opencode/skills-loader-core/opencode-runtime-skills/skill-markdown";

package/dist/features/opencode-runtime-skills/source-server.d.ts

@@ -1,24 +1 @@
-import type { RuntimeSkillSourceEntry } from "./runtime-skill-config";
-export type RuntimeSkillSourceServer = {
-    readonly url: string;
-    readonly fetch: (request: Request) => Response | Promise<Response>;
-    readonly stop: () => void;
-};
-type BunServeServer = {
-    readonly url: URL;
-    stop(closeActiveConnections?: boolean): void;
-};
-type BunServeRuntime = {
-    serve(options: {
-        readonly hostname: string;
-        readonly port: number;
-        readonly fetch: (request: Request) => Response | Promise<Response>;
-    }): BunServeServer;
-};
-type RuntimeSkillSourceRuntime = typeof globalThis & {
-    Bun?: BunServeRuntime;
-};
-export declare function createRuntimeSkillSourceServer(options: {
-    readonly skills: readonly RuntimeSkillSourceEntry[];
-}, runtimeEnv?: Pick<RuntimeSkillSourceRuntime, "Bun">): Promise<RuntimeSkillSourceServer>;
-export {};
+export * from "@oh-my-opencode/skills-loader-core/opencode-runtime-skills/source-server";

package/dist/features/opencode-skill-loader/allowed-tools-parser.d.ts

@@ -1 +1 @@
-export declare function parseAllowedTools(allowedTools: string | string[] | undefined): string[] | undefined;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/allowed-tools-parser";

package/dist/features/opencode-skill-loader/config-source-discovery.d.ts

@@ -1,7 +1 @@
-import type { SkillsConfig } from "../../config/schema";
-import type { LoadedSkill } from "./types";
-export declare function normalizePathForGlob(path: string): string;
-export declare function discoverConfigSourceSkills(options: {
-    config: SkillsConfig | undefined;
-    configDir: string;
-}): Promise<LoadedSkill[]>;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/config-source-discovery";

package/dist/features/opencode-skill-loader/git-master-template-injection.d.ts

@@ -1,20 +1 @@
-import { type GitMasterConfig } from "../../config/schema";
-import { type ShellType } from "../../shared/shell-env";
-/**
- * Parse a bash-format env prefix string ("VAR=value VAR2=value2") into a Record.
- * Only handles simple KEY=VALUE pairs (no quoting needed since assertValidGitEnvPrefix
- * already validates the format is shell-safe alphanumeric assignments).
- */
-export declare function parseBashEnvPrefix(prefix: string): Record<string, string>;
-/**
- * Build the shell-aware command prefix for git commands.
- * Uses the shared shell detection and env prefix builder to emit correct syntax
- * for PowerShell ($env:VAR='value';), cmd (set VAR="value" &&),
- * csh (setenv VAR value;), or unix (VAR=value).
- *
- * For unix shells, we use the inline VAR=value prefix style (not export) to match
- * the original behavior where the env var applies only to the immediately following command.
- * For csh/tcsh, we use setenv syntax since csh does not support inline VAR=value.
- */
-export declare function buildShellAwareGitPrefix(bashPrefix: string, shellType?: ShellType): string;
-export declare function injectGitMasterConfig(template: string, config?: GitMasterConfig): string;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/git-master-template-injection";

package/dist/features/opencode-skill-loader/index.d.ts

@@ -1,16 +1 @@
-export * from "./types";
-export * from "./loader";
-export * from "./merger";
-export * from "./skill-content";
-export * from "./skill-directory-loader";
-export * from "./loaded-skill-from-path";
-export * from "./skill-mcp-config";
-export * from "./skill-deduplication";
-export * from "./skill-definition-record";
-export * from "./git-master-template-injection";
-export * from "./skill-discovery";
-export * from "./skill-resolution-options";
-export * from "./loaded-skill-template-extractor";
-export * from "./skill-template-resolver";
-export * from "./config-source-discovery";
-export * from "./opencode-config-skills-reader";
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/index";

package/dist/features/opencode-skill-loader/loaded-skill-from-path.d.ts

@@ -1,9 +1 @@
-import type { SkillScope, LoadedSkill } from "./types";
-export declare function loadSkillFromPath(options: {
-    skillPath: string;
-    resolvedPath: string;
-    defaultName: string;
-    scope: SkillScope;
-    namePrefix?: string;
-}): Promise<LoadedSkill | null>;
-export declare function inferSkillNameFromFileName(filePath: string): string;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/loaded-skill-from-path";

package/dist/features/opencode-skill-loader/loaded-skill-template-extractor.d.ts

@@ -1,2 +1 @@
-import type { LoadedSkill } from "./types";
-export declare function extractSkillTemplate(skill: LoadedSkill): string;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/loaded-skill-template-extractor";

package/dist/features/opencode-skill-loader/loader.d.ts

@@ -1,21 +1 @@
-import type { CommandDefinition } from "../claude-code-command-loader/types";
-import type { LoadedSkill } from "./types";
-export declare function loadUserSkills(): Promise<Record<string, CommandDefinition>>;
-export declare function loadProjectSkills(directory?: string): Promise<Record<string, CommandDefinition>>;
-export declare function loadOpencodeGlobalSkills(): Promise<Record<string, CommandDefinition>>;
-export declare function loadOpencodeProjectSkills(directory?: string): Promise<Record<string, CommandDefinition>>;
-export declare function loadProjectAgentsSkills(directory?: string): Promise<Record<string, CommandDefinition>>;
-export declare function loadGlobalAgentsSkills(homeDirectory?: string): Promise<Record<string, CommandDefinition>>;
-export interface DiscoverSkillsOptions {
-    includeClaudeCodePaths?: boolean;
-    directory?: string;
-}
-export declare function discoverAllSkills(directory?: string): Promise<LoadedSkill[]>;
-export declare function discoverSkills(options?: DiscoverSkillsOptions): Promise<LoadedSkill[]>;
-export declare function getSkillByName(name: string, options?: DiscoverSkillsOptions): Promise<LoadedSkill | undefined>;
-export declare function discoverUserClaudeSkills(): Promise<LoadedSkill[]>;
-export declare function discoverProjectClaudeSkills(directory?: string): Promise<LoadedSkill[]>;
-export declare function discoverOpencodeGlobalSkills(): Promise<LoadedSkill[]>;
-export declare function discoverOpencodeProjectSkills(directory?: string): Promise<LoadedSkill[]>;
-export declare function discoverProjectAgentsSkills(directory?: string): Promise<LoadedSkill[]>;
-export declare function discoverGlobalAgentsSkills(homeDirectory?: string): Promise<LoadedSkill[]>;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/loader";

package/dist/features/opencode-skill-loader/merger/builtin-skill-converter.d.ts

@@ -1,3 +1 @@
-import type { BuiltinSkill } from "../../builtin-skills/types";
-import type { LoadedSkill } from "../types";
-export declare function builtinToLoadedSkill(builtin: BuiltinSkill): LoadedSkill;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/merger/builtin-skill-converter";

package/dist/features/opencode-skill-loader/merger/config-skill-entry-loader.d.ts

@@ -1,3 +1 @@
-import type { LoadedSkill } from "../types";
-import type { SkillDefinition } from "../../../config/schema";
-export declare function configEntryToLoadedSkill(name: string, entry: SkillDefinition, configDir?: string): LoadedSkill | null;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/merger/config-skill-entry-loader";

package/dist/features/opencode-skill-loader/merger/scope-priority.d.ts

@@ -1,2 +1 @@
-import type { SkillScope } from "../types";
-export declare const SCOPE_PRIORITY: Record<SkillScope, number>;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/merger/scope-priority";

package/dist/features/opencode-skill-loader/merger/skill-definition-merger.d.ts

@@ -1,3 +1 @@
-import type { LoadedSkill } from "../types";
-import type { SkillDefinition } from "../../../config/schema";
-export declare function mergeSkillDefinitions(base: LoadedSkill, patch: SkillDefinition): LoadedSkill;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/merger/skill-definition-merger";

package/dist/features/opencode-skill-loader/merger/skills-config-normalizer.d.ts

@@ -1,11 +1 @@
-import type { SkillsConfig, SkillDefinition } from "../../../config/schema";
-export declare function normalizeSkillsConfig(config: SkillsConfig | undefined): {
-    sources: Array<string | {
-        path: string;
-        recursive?: boolean;
-        glob?: string;
-    }>;
-    enable: string[];
-    disable: string[];
-    entries: Record<string, boolean | SkillDefinition>;
-};
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/merger/skills-config-normalizer";

package/dist/features/opencode-skill-loader/merger.d.ts

@@ -1,7 +1 @@
-import type { LoadedSkill } from "./types";
-import type { SkillsConfig } from "../../config/schema";
-import type { BuiltinSkill } from "../builtin-skills/types";
-export interface MergeSkillsOptions {
-    configDir?: string;
-}
-export declare function mergeSkills(builtinSkills: BuiltinSkill[], config: SkillsConfig | undefined, configSourceSkills: LoadedSkill[], userClaudeSkills: LoadedSkill[], userOpencodeSkills: LoadedSkill[], projectClaudeSkills: LoadedSkill[], projectOpencodeSkills: LoadedSkill[], options?: MergeSkillsOptions): LoadedSkill[];
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/merger";

package/dist/features/opencode-skill-loader/opencode-config-skills-reader.d.ts

@@ -1,5 +1 @@
-export interface HostSkillConfigShape {
-    paths?: string[];
-    urls?: string[];
-}
-export declare function readOpencodeConfigSkills(directory: string): HostSkillConfigShape | undefined;
+export * from "@oh-my-opencode/skills-loader-core/opencode-skill-loader/opencode-config-skills-reader";