@sayknow-cli/coding-agent 0.3.16 → 0.4.0

package/dist/types/extensibility/hooks/types.d.ts

@@ -1,431 +0,0 @@
-import type { ImageContent, Message, Model, TextContent } from "@sayknow-cli/ai";
-import type { Component, TUI } from "@sayknow-cli/tui";
-import type { ModelRegistry } from "../../config/model-registry";
-import type { EditToolDetails } from "../../edit";
-import type { ExecOptions, ExecResult } from "../../exec/exec";
-import type { Theme } from "../../modes/theme/theme";
-import type { HookMessage } from "../../session/messages";
-import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
-import type { BashToolDetails, FindToolDetails, ReadToolDetails, SearchToolDetails } from "../../tools";
-import type { AgentEndEvent, AgentStartEvent, AutoCompactionEndEvent, AutoCompactionStartEvent, AutoRetryEndEvent, AutoRetryStartEvent, ContextEvent, SessionBeforeBranchEvent, SessionBeforeBranchResult, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionBranchEvent, SessionCompactEvent, SessionCompactingEvent, SessionCompactingResult, SessionEvent, SessionShutdownEvent, SessionStartEvent, SessionSwitchEvent, SessionTreeEvent, TodoReminderEvent, ToolCallEventResult, ToolResultEventResult, TtsrTriggeredEvent, TurnEndEvent, TurnStartEvent } from "../shared-events";
-export type { ExecOptions, ExecResult } from "../../exec/exec";
-/**
- * UI context for hooks to request interactive UI from the harness.
- * Each mode (interactive, RPC, print) provides its own implementation.
- */
-export interface HookUIContext {
-    /**
-     * Show a selector and return the user's choice.
-     * @param title - Title to display
-     * @param options - Array of string options
-     * @returns Selected option string, or null if cancelled
-     */
-    select(title: string, options: string[]): Promise<string | undefined>;
-    /**
-     * Show a confirmation dialog.
-     * @returns true if confirmed, false if cancelled
-     */
-    confirm(title: string, message: string): Promise<boolean>;
-    /**
-     * Show a text input dialog.
-     * @returns User input, or undefined if cancelled
-     */
-    input(title: string, placeholder?: string): Promise<string | undefined>;
-    /**
-     * Show a notification to the user.
-     */
-    notify(message: string, type?: "info" | "warning" | "error"): void;
-    /**
-     * Set status text in the footer/status bar.
-     * Pass undefined as text to clear the status for this key.
-     * Text can include ANSI escape codes for styling.
-     * Note: Newlines, tabs, and carriage returns are replaced with spaces.
-     * The combined status line is truncated to terminal width.
-     * @param key - Unique key to identify this status (e.g., hook name)
-     * @param text - Status text to display, or undefined to clear
-     */
-    setStatus(key: string, text: string | undefined): void;
-    /**
-     * Show a custom component with keyboard focus.
-     * The factory receives TUI, theme, and a done() callback to close the component.
-     * Can be async for fire-and-forget work (don't await the work, just start it).
-     *
-     * @param factory - Function that creates the component. Call done() when finished.
-     * @returns Promise that resolves with the value passed to done()
-     *
-     * @example
-     * // Sync factory
-     * const result = await ctx.ui.custom((tui, theme, done) => {
-     *   const component = new MyComponent(tui, theme);
-     *   component.onFinish = (value) => done(value);
-     *   return component;
-     * });
-     *
-     * // Async factory with fire-and-forget work
-     * const result = await ctx.ui.custom(async (tui, theme, done) => {
-     *   const loader = new CancellableLoader(tui, theme.fg("accent"), theme.fg("muted"), "Working...");
-     *   loader.onAbort = () => done(null);
-     *   doWork(loader.signal).then(done);  // Don't await - fire and forget
-     *   return loader;
-     * });
-     */
-    custom<T>(factory: (tui: TUI, theme: Theme, done: (result: T) => void) => (Component & {
-        dispose?(): void;
-    }) | Promise<Component & {
-        dispose?(): void;
-    }>): Promise<T>;
-    /**
-     * Set the text in the core input editor.
-     * Use this to pre-fill the input box with generated content (e.g., prompt templates, extracted questions).
-     * @param text - Text to set in the editor
-     */
-    setEditorText(text: string): void;
-    /**
-     * Get the current text from the core input editor.
-     * @returns Current editor text
-     */
-    getEditorText(): string;
-    /**
-     * Show a multi-line editor for text editing.
-     * Supports Ctrl+G to open external editor ($VISUAL or $EDITOR).
-     * @param title - Title describing what is being edited
-     * @param prefill - Optional initial text
-     * @returns Edited text, or undefined if cancelled (Escape)
-     */
-    editor(title: string, prefill?: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<string | undefined>;
-    /**
-     * Get the current theme for styling text with ANSI codes.
-     * Use theme.fg() and theme.bg() to style status text.
-     *
-     * @example
-     * const theme = ctx.ui.theme;
-     * ctx.ui.setStatus("my-hook", theme.fg("success", theme.status.success) + " Ready");
-     */
-    readonly theme: Theme;
-}
-/**
- * Context passed to hook event handlers.
- * For command handlers, see HookCommandContext which extends this with session control methods.
- */
-export interface HookContext {
-    /** UI methods for user interaction */
-    ui: HookUIContext;
-    /** Whether UI is available (false in print mode) */
-    hasUI: boolean;
-    /** Current working directory */
-    cwd: string;
-    /** Session manager (read-only) - use pi.sendMessage()/pi.appendEntry() for writes */
-    sessionManager: ReadonlySessionManager;
-    /** Model registry - use for API key resolution and model retrieval */
-    modelRegistry: ModelRegistry;
-    /** Current model (may be undefined if no model is selected yet) */
-    model: Model | undefined;
-    /** Whether the agent is idle (not streaming) */
-    isIdle(): boolean;
-    /** Abort the current agent operation (fire-and-forget, does not wait) */
-    abort(): void;
-    /** Whether there are queued messages waiting to be processed */
-    hasQueuedMessages(): boolean;
-}
-/**
- * Extended context for slash command handlers.
- * Includes session control methods that are only safe in user-initiated commands.
- *
- * These methods are not available in event handlers because they can cause
- * deadlocks when called from within the agent loop (e.g., tool_call, context events).
- */
-export interface HookCommandContext extends HookContext {
-    /** Wait for the agent to finish streaming */
-    waitForIdle(): Promise<void>;
-    /**
-     * Start a new session, optionally with a setup callback to initialize it.
-     * The setup callback receives a writable SessionManager for the new session.
-     *
-     * @param options.parentSession - Path to parent session for lineage tracking
-     * @param options.setup - Async callback to initialize the new session (e.g., append messages)
-     * @returns Object with `cancelled: true` if a hook cancelled the new session
-     *
-     * @example
-     * // Handoff: summarize current session and start fresh with context
-     * await ctx.newSession({
-     *   parentSession: ctx.sessionManager.getSessionFile(),
-     *   setup: async (sm) => {
-     *     sm.appendMessage({ role: "user", content: [{ type: "text", text: summary }] });
-     *   }
-     * });
-     */
-    newSession(options?: {
-        parentSession?: string;
-        setup?: (sessionManager: SessionManager) => Promise<void>;
-    }): Promise<{
-        cancelled: boolean;
-    }>;
-    /**
-     * Branch from a specific entry, creating a new session file.
-     *
-     * @param entryId - ID of the entry to branch from
-     * @returns Object with `cancelled: true` if a hook cancelled the branch
-     */
-    branch(entryId: string): Promise<{
-        cancelled: boolean;
-    }>;
-    /**
-     * Navigate to a different point in the session tree (in-place).
-     *
-     * @param targetId - ID of the entry to navigate to
-     * @param options.summarize - Whether to summarize the abandoned branch
-     * @returns Object with `cancelled: true` if a hook cancelled the navigation
-     */
-    navigateTree(targetId: string, options?: {
-        summarize?: boolean;
-    }): Promise<{
-        cancelled: boolean;
-    }>;
-}
-export type { ContextEvent, SessionBeforeBranchEvent, SessionBeforeCompactEvent, SessionBeforeSwitchEvent, SessionBeforeTreeEvent, SessionBranchEvent, SessionCompactEvent, SessionCompactingEvent, SessionEvent, SessionShutdownEvent, SessionStartEvent, SessionSwitchEvent, SessionTreeEvent, TreePreparation, } from "../shared-events";
-/**
- * Event data for before_agent_start event.
- * Fired after user submits a prompt but before the agent loop starts.
- * Allows hooks to inject context that will be persisted and visible in TUI.
- */
-export interface BeforeAgentStartEvent {
-    type: "before_agent_start";
-    /** The user's prompt text */
-    prompt: string;
-    /** Any images attached to the prompt */
-    images?: ImageContent[];
-}
-export type { AgentEndEvent, AgentStartEvent, AutoCompactionEndEvent, AutoCompactionStartEvent, AutoRetryEndEvent, AutoRetryStartEvent, TodoReminderEvent, TtsrTriggeredEvent, TurnEndEvent, TurnStartEvent, } from "../shared-events";
-/**
- * Event data for tool_call event.
- * Fired before a tool is executed. Hooks can block execution.
- */
-export interface ToolCallEvent {
-    type: "tool_call";
-    /** Tool name (e.g., "bash", "edit", "write") */
-    toolName: string;
-    /** Tool call ID */
-    toolCallId: string;
-    /** Tool input parameters */
-    input: Record<string, unknown>;
-}
-/**
- * Base interface for tool_result events.
- */
-interface ToolResultEventBase {
-    type: "tool_result";
-    /** Tool call ID */
-    toolCallId: string;
-    /** Tool input parameters */
-    input: Record<string, unknown>;
-    /** Full content array (text and images) */
-    content: (TextContent | ImageContent)[];
-    /** Whether the tool execution was an error */
-    isError?: boolean;
-}
-/** Tool result event for bash tool */
-export interface BashToolResultEvent extends ToolResultEventBase {
-    toolName: "bash";
-    details: BashToolDetails | undefined;
-}
-/** Tool result event for read tool */
-export interface ReadToolResultEvent extends ToolResultEventBase {
-    toolName: "read";
-    details: ReadToolDetails | undefined;
-}
-/** Tool result event for edit tool */
-export interface EditToolResultEvent extends ToolResultEventBase {
-    toolName: "edit";
-    details: EditToolDetails | undefined;
-}
-/** Tool result event for write tool */
-export interface WriteToolResultEvent extends ToolResultEventBase {
-    toolName: "write";
-    details: undefined;
-}
-/** Tool result event for search tool */
-export interface SearchToolResultEvent extends ToolResultEventBase {
-    toolName: "search";
-    details: SearchToolDetails | undefined;
-}
-/** Tool result event for find tool */
-export interface FindToolResultEvent extends ToolResultEventBase {
-    toolName: "find";
-    details: FindToolDetails | undefined;
-}
-/** Tool result event for custom/unknown tools */
-export interface CustomToolResultEvent extends ToolResultEventBase {
-    toolName: string;
-    details: unknown;
-}
-/**
- * Event data for tool_result event.
- * Fired after a tool is executed. Hooks can modify the result.
- * Use toolName to discriminate and get typed details.
- */
-export type ToolResultEvent = BashToolResultEvent | ReadToolResultEvent | EditToolResultEvent | WriteToolResultEvent | SearchToolResultEvent | FindToolResultEvent | CustomToolResultEvent;
-/**
- * Union of all hook event types.
- */
-export type HookEvent = SessionEvent | ContextEvent | BeforeAgentStartEvent | AgentStartEvent | AgentEndEvent | TurnStartEvent | TurnEndEvent | AutoCompactionStartEvent | AutoCompactionEndEvent | AutoRetryStartEvent | AutoRetryEndEvent | TtsrTriggeredEvent | TodoReminderEvent | ToolCallEvent | ToolResultEvent;
-/**
- * Return type for context event handlers.
- * Allows hooks to modify messages before they're sent to the LLM.
- */
-export interface ContextEventResult {
-    /** Modified messages to send instead of the original */
-    messages?: Message[];
-}
-export type { ToolCallEventResult, ToolResultEventResult } from "../shared-events";
-/**
- * Return type for before_agent_start event handlers.
- * Allows hooks to inject context before the agent runs.
- */
-export interface BeforeAgentStartEventResult {
-    /** Message to inject into context (persisted to session, visible in TUI) */
-    message?: Pick<HookMessage, "customType" | "content" | "display" | "details" | "attribution">;
-}
-export type { SessionBeforeBranchResult, SessionBeforeCompactResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionCompactingResult, } from "../shared-events";
-/**
- * Handler function type for each event.
- * Handlers can return R, undefined, or void (bare return statements).
- */
-export type HookHandler<E, R = undefined> = (event: E, ctx: HookContext) => Promise<R | void> | R | void;
-export interface HookMessageRenderOptions {
-    /** Whether the view is expanded */
-    expanded: boolean;
-}
-/**
- * Renderer for hook messages.
- * Hooks register these to provide custom TUI rendering for their message types.
- */
-export type HookMessageRenderer<T = unknown> = (message: HookMessage<T>, options: HookMessageRenderOptions, theme: Theme) => Component | undefined;
-/**
- * Command registration options.
- */
-export interface RegisteredCommand {
-    name: string;
-    description?: string;
-    handler: (args: string, ctx: HookCommandContext) => Promise<void>;
-}
-/**
- * HookAPI passed to hook factory functions.
- * Hooks use pi.on() to subscribe to events and pi.sendMessage() to inject messages.
- */
-export interface HookAPI {
-    on(event: "session_start", handler: HookHandler<SessionStartEvent>): void;
-    on(event: "session_before_switch", handler: HookHandler<SessionBeforeSwitchEvent, SessionBeforeSwitchResult>): void;
-    on(event: "session_switch", handler: HookHandler<SessionSwitchEvent>): void;
-    on(event: "session_before_branch", handler: HookHandler<SessionBeforeBranchEvent, SessionBeforeBranchResult>): void;
-    on(event: "session_branch", handler: HookHandler<SessionBranchEvent>): void;
-    on(event: "session_before_compact", handler: HookHandler<SessionBeforeCompactEvent, SessionBeforeCompactResult>): void;
-    on(event: "session.compacting", handler: HookHandler<SessionCompactingEvent, SessionCompactingResult>): void;
-    on(event: "session_compact", handler: HookHandler<SessionCompactEvent>): void;
-    on(event: "session_shutdown", handler: HookHandler<SessionShutdownEvent>): void;
-    on(event: "session_before_tree", handler: HookHandler<SessionBeforeTreeEvent, SessionBeforeTreeResult>): void;
-    on(event: "session_tree", handler: HookHandler<SessionTreeEvent>): void;
-    on(event: "context", handler: HookHandler<ContextEvent, ContextEventResult>): void;
-    on(event: "before_agent_start", handler: HookHandler<BeforeAgentStartEvent, BeforeAgentStartEventResult>): void;
-    on(event: "agent_start", handler: HookHandler<AgentStartEvent>): void;
-    on(event: "agent_end", handler: HookHandler<AgentEndEvent>): void;
-    on(event: "turn_start", handler: HookHandler<TurnStartEvent>): void;
-    on(event: "turn_end", handler: HookHandler<TurnEndEvent>): void;
-    on(event: "auto_compaction_start", handler: HookHandler<AutoCompactionStartEvent>): void;
-    on(event: "auto_compaction_end", handler: HookHandler<AutoCompactionEndEvent>): void;
-    on(event: "auto_retry_start", handler: HookHandler<AutoRetryStartEvent>): void;
-    on(event: "auto_retry_end", handler: HookHandler<AutoRetryEndEvent>): void;
-    on(event: "ttsr_triggered", handler: HookHandler<TtsrTriggeredEvent>): void;
-    on(event: "todo_reminder", handler: HookHandler<TodoReminderEvent>): void;
-    on(event: "tool_call", handler: HookHandler<ToolCallEvent, ToolCallEventResult>): void;
-    on(event: "tool_result", handler: HookHandler<ToolResultEvent, ToolResultEventResult>): void;
-    /**
-     * Send a custom message to the session. Creates a CustomMessageEntry that
-     * participates in LLM context and can be displayed in the TUI.
-     *
-     * Use this when you want the LLM to see the message content.
-     * For hook state that should NOT be sent to the LLM, use appendEntry() instead.
-     *
-     * @param message - The message to send
-     * @param message.customType - Identifier for your hook (used for filtering on reload)
-     * @param message.content - Message content (string or TextContent/ImageContent array)
-     * @param message.display - Whether to show in TUI (true = styled display, false = hidden)
-     * @param message.details - Optional hook-specific metadata (not sent to LLM)
-     * @param message.attribution - Who initiated the message for billing/attribution semantics ("user" | "agent")
-     * @param options.triggerTurn - If true and agent is idle, triggers a new LLM turn. Default: false.
-     *                              If agent is streaming, message is queued and triggerTurn is ignored.
-     * @param options.deliverAs - How to deliver the message: "steer" or "followUp".
-     */
-    sendMessage<T = unknown>(message: Pick<HookMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: {
-        triggerTurn?: boolean;
-        deliverAs?: "steer" | "followUp";
-    }): void;
-    /**
-     * Append a custom entry to the session for hook state persistence.
-     * Creates a CustomEntry that does NOT participate in LLM context.
-     *
-     * Use this to store hook-specific data that should persist across session reloads
-     * but should NOT be sent to the LLM. On reload, scan session entries for your
-     * customType to reconstruct hook state.
-     *
-     * For messages that SHOULD be sent to the LLM, use sendMessage() instead.
-     *
-     * @param customType - Identifier for your hook (used for filtering on reload)
-     * @param data - Hook-specific data to persist (must be JSON-serializable)
-     *
-     * @example
-     * // Store permission state
-     * pi.appendEntry("permissions", { level: "full", grantedAt: Date.now() });
-     *
-     * // On reload, reconstruct state from entries
-     * pi.on("session", async (event, ctx) => {
-     *   if (event.reason === "start") {
-     *     const entries = event.sessionManager.getEntries();
-     *     const myEntries = entries.filter(e => e.type === "custom" && e.customType === "permissions");
-     *     // Reconstruct state from myEntries...
-     *   }
-     * });
-     */
-    appendEntry<T = unknown>(customType: string, data?: T): void;
-    /**
-     * Register a custom renderer for CustomMessageEntry with a specific customType.
-     * The renderer is called when rendering the entry in the TUI.
-     * Return nothing to use the default renderer.
-     */
-    registerMessageRenderer<T = unknown>(customType: string, renderer: HookMessageRenderer<T>): void;
-    /**
-     * Register a custom slash command.
-     * Handler receives HookCommandContext with session control methods.
-     */
-    registerCommand(name: string, options: {
-        description?: string;
-        handler: RegisteredCommand["handler"];
-    }): void;
-    /**
-     * Execute a shell command and return stdout/stderr/code.
-     * Supports timeout and abort signal.
-     */
-    exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
-    /** File logger for error/warning/debug messages */
-    logger: typeof import("@sayknow-cli/utils").logger;
-    /** Injected zod-backed typebox shim (legacy/compat — prefer `zod`). */
-    typebox: typeof import("../typebox");
-    /** Injected zod module for Zod-authored hooks. */
-    zod: typeof import("zod/v4");
-    /** Injected sayknow-cli exports */
-    pi: typeof import("../..");
-}
-/**
- * Hook factory function type.
- * Hooks export a default function that receives the HookAPI.
- */
-export type HookFactory = (pi: HookAPI) => void;
-/**
- * Error emitted when a hook fails.
- */
-export interface HookError {
-    hookPath: string;
-    event: string;
-    error: string;
-}

package/dist/types/extensibility/plugins/doctor.d.ts

@@ -1,3 +0,0 @@
-import type { DoctorCheck } from "./types";
-export declare function runDoctorChecks(): Promise<DoctorCheck[]>;
-export declare function formatDoctorResults(checks: DoctorCheck[]): string;

package/dist/types/extensibility/plugins/git-url.d.ts

@@ -1,34 +0,0 @@
-/**
- * Parsed git URL information.
- */
-export type GitSource = {
-    /** Always "git" for git sources */
-    type: "git";
-    /** Clone URL (always valid for git clone, without ref suffix) */
-    repo: string;
-    /** Git host domain (e.g., "github.com") */
-    host: string;
-    /** Repository path (e.g., "user/repo") */
-    path: string;
-    /** Git ref (branch, tag, commit) if specified */
-    ref?: string;
-    /** True if ref was specified (package won't be auto-updated) */
-    pinned: boolean;
-};
-/**
- * Parse git source into a GitSource.
- *
- * Rules:
- * - With `git:` prefix, accept shorthand forms.
- * - Without `git:` prefix, only accept explicit protocol URLs.
- *
- * Handles:
- * - `git:` prefixed URLs (`git:github.com/user/repo`)
- * - SSH SCP-like URLs (`git:git@github.com:user/repo`)
- * - HTTPS/HTTP/SSH/git protocol URLs
- * - Ref pinning via `@ref` suffix
- *
- * Recognizes GitHub, GitLab, Bitbucket, Sourcehut, and Codeberg natively.
- * Falls back to generic URL parsing for other hosts.
- */
-export declare function parseGitUrl(source: string): GitSource | null;

package/dist/types/extensibility/plugins/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./doctor";
-export * from "./git-url";
-export * from "./loader";
-export * from "./manager";
-export * from "./marketplace";
-export * from "./parser";
-export * from "./security-scanner";
-export type * from "./types";

package/dist/types/extensibility/plugins/installer.d.ts

@@ -1,5 +0,0 @@
-import type { InstalledPlugin } from "./types";
-export declare function installPlugin(packageName: string): Promise<InstalledPlugin>;
-export declare function uninstallPlugin(name: string): Promise<void>;
-export declare function listPlugins(): Promise<InstalledPlugin[]>;
-export declare function linkPlugin(localPath: string): Promise<void>;

package/dist/types/extensibility/plugins/legacy-pi-compat.d.ts

@@ -1,2 +0,0 @@
-export declare function loadLegacyPiModule(resolvedPath: string): Promise<unknown>;
-export declare function installLegacyPiSpecifierShim(): void;

package/dist/types/extensibility/plugins/loader.d.ts

@@ -1,31 +0,0 @@
-import type { InstalledPlugin } from "./types";
-/**
- * Get list of enabled plugins with their resolved configurations.
- * Respects both global runtime config and project overrides.
- */
-export declare function getEnabledPlugins(cwd: string): Promise<InstalledPlugin[]>;
-export declare function resolvePluginToolPaths(plugin: InstalledPlugin): string[];
-export declare function resolvePluginHookPaths(plugin: InstalledPlugin): string[];
-export declare function resolvePluginCommandPaths(plugin: InstalledPlugin): string[];
-export declare function resolvePluginExtensionPaths(plugin: InstalledPlugin): string[];
-/**
- * Get all tool paths from all enabled plugins.
- */
-export declare function getAllPluginToolPaths(cwd: string): Promise<string[]>;
-/**
- * Get all hook paths from all enabled plugins.
- */
-export declare function getAllPluginHookPaths(cwd: string): Promise<string[]>;
-/**
- * Get all command paths from all enabled plugins.
- */
-export declare function getAllPluginCommandPaths(cwd: string): Promise<string[]>;
-/**
- * Get all extension module paths from all enabled plugins.
- */
-export declare function getAllPluginExtensionPaths(cwd: string): Promise<string[]>;
-/**
- * Get plugin settings for use in tool/hook contexts.
- * Merges global settings with project overrides.
- */
-export declare function getPluginSettings(pluginName: string, cwd: string): Promise<Record<string, unknown>>;

package/dist/types/extensibility/plugins/manager.d.ts

@@ -1,65 +0,0 @@
-import type { DoctorCheck, DoctorOptions, InstalledPlugin, InstallOptions, PluginSettingSchema } from "./types";
-export declare class PluginManager {
-    #private;
-    constructor(cwd?: string);
-    /**
-     * Install a plugin from npm with optional feature selection.
-     *
-     * @param specString - Package specifier with optional features: "pkg", "pkg[feat]", "pkg[*]", "pkg[]"
-     * @param options - Install options
-     * @returns Installed plugin metadata
-     */
-    install(specString: string, options?: InstallOptions): Promise<InstalledPlugin>;
-    /**
-     * Uninstall a plugin.
-     */
-    uninstall(name: string): Promise<void>;
-    /**
-     * List all installed plugins.
-     */
-    list(): Promise<InstalledPlugin[]>;
-    /**
-     * Link a local plugin for development.
-     */
-    link(localPath: string): Promise<InstalledPlugin>;
-    /**
-     * Enable or disable a plugin globally.
-     */
-    setEnabled(name: string, enabled: boolean): Promise<void>;
-    /**
-     * Get enabled features for a plugin.
-     */
-    getEnabledFeatures(name: string): Promise<string[] | null>;
-    /**
-     * Set enabled features for a plugin.
-     */
-    setEnabledFeatures(name: string, features: string[] | null): Promise<void>;
-    /**
-     * Get all settings for a plugin.
-     */
-    getPluginSettings(name: string): Promise<Record<string, unknown>>;
-    /**
-     * Set a plugin setting value.
-     */
-    setPluginSetting(name: string, key: string, value: unknown): Promise<void>;
-    /**
-     * Delete a plugin setting.
-     */
-    deletePluginSetting(name: string, key: string): Promise<void>;
-    /**
-     * Run health checks on the plugin system.
-     */
-    doctor(options?: DoctorOptions): Promise<DoctorCheck[]>;
-}
-export interface ValidationResult {
-    valid: boolean;
-    error?: string;
-}
-/**
- * Validate a setting value against its schema.
- */
-export declare function validateSetting(value: unknown, schema: PluginSettingSchema): ValidationResult;
-/**
- * Parse a string value according to a setting schema's type.
- */
-export declare function parseSettingValue(valueStr: string, schema: PluginSettingSchema): unknown;

package/dist/types/extensibility/plugins/marketplace/cache.d.ts

@@ -1,41 +0,0 @@
-/**
- * Plugin cache management.
- *
- * Cache layout: `<cacheDir>/<marketplace>___<pluginName>___<version>/`
- *
- * All three components are validated before any filesystem operation:
- *   - marketplace / pluginName: isValidNameSegment (lowercase alnum + hyphens, max 64)
- *   - version: isValidVersionForCache (alnum + ._+-, max 128)
- *
- * This ensures cache paths cannot be crafted to escape the cache directory.
- */
-/** Return true when `version` is safe for use as a cache path component. */
-export declare function isValidVersionForCache(version: string): boolean;
-/**
- * Return the absolute path for a cached plugin directory.
- * Throws if any component fails validation.
- */
-export declare function getCachedPluginPath(cacheDir: string, marketplace: string, pluginName: string, version: string): string;
-/**
- * Copy `sourcePath` into the cache, returning the absolute cache path.
- *
- * Idempotent: if the target already exists it is removed before copying,
- * so a partial previous cache is never silently reused.
- */
-export declare function cachePlugin(sourcePath: string, cacheDir: string, marketplace: string, pluginName: string, version: string): Promise<string>;
-/**
- * Synchronous check — true when the cache directory exists on disk.
- * Uses `existsSync` because callers may need to run this check inline without async.
- */
-export declare function isCached(cacheDir: string, marketplace: string, pluginName: string, version: string): boolean;
-/** Remove a single cached plugin directory. No-op if it does not exist. */
-export declare function removeCachedPlugin(cacheDir: string, marketplace: string, pluginName: string, version: string): Promise<void>;
-/**
- * Remove all cache entries whose full path is not in `installedPaths`.
- *
- * Returns the count of removed directories. If `cacheDir` does not exist,
- * returns `{ removed: 0 }` rather than throwing.
- */
-export declare function cleanOrphanedCache(cacheDir: string, installedPaths: Set<string>): Promise<{
-    removed: number;
-}>;