import type { ProjectContext } from "./memory.js";
import type { WorkflowDefinition } from "./workflow.js";
export interface PluginInstructionRequest {
    pluginName: string;
    workflowName: string;
    stepId: string;
    title: string;
    instruction: string;
    suggestedTools: string[];
    expectedOutput?: string;
    input: Record<string, unknown>;
}
export interface PluginWorkflowStepContext {
    sessionId: string;
    projectRoot: string;
    executeInstruction?(request: PluginInstructionRequest): Promise<Record<string, unknown>>;
}
export interface PluginWorkflowStepHandler {
    id: string;
    run(input: Record<string, unknown>, context: PluginWorkflowStepContext): Promise<Record<string, unknown>>;
    inputSchema?: Record<string, unknown>;
    outputSchema?: Record<string, unknown>;
}
export interface KnowledgeSource {
    name: string;
    urls: string[];
    pluginName: string;
    version: string;
    renderJs?: boolean;
}
export interface KnowledgeEntry {
    id: string;
    source: string;
    title: string;
    content: string;
    url?: string;
    version?: string;
    embedding: number[];
    score?: number;
    excerpt?: string;
    matchingTerms?: string[];
    applicability?: string[];
    scoreDetails?: import('./knowledge.js').KnowledgeScoreDetails;
}
export interface McpToolDef {
    name: string;
    description: string;
    inputSchema: Record<string, unknown>;
    outputSchema?: Record<string, unknown>;
    annotations?: {
        readOnlyHint?: boolean;
        destructiveHint?: boolean;
        idempotentHint?: boolean;
        openWorldHint?: boolean;
    };
    handler: (input: Record<string, unknown>) => Promise<unknown>;
}
export interface PluginContext {
    projectRoot: string;
    memory: {
        getAll(): Promise<unknown>;
        upsertGlobal(entries: unknown[]): Promise<void>;
    };
    knowledge: {
        registerSource(source: KnowledgeSource): Promise<void>;
    };
    workflow: {
        registerStepHandler(id: string, handler: unknown): void;
    };
}
export interface DevFlowPlugin {
    meta: {
        name: string;
        version: string;
        description: string;
        icon?: string;
        tags: string[];
    };
    knowledge: {
        sources: KnowledgeSource[];
        embeddings?: string;
    };
    memory?: {
        /** Optional suggestions. They must never be persisted without explicit user selection. */
        project?: Partial<ProjectContext>;
        global?: KnowledgeEntry[];
    };
    workflow?: {
        steps: PluginWorkflowStepHandler[];
        templates?: WorkflowDefinition[];
    };
    prompt?: {
        system?: string;
        rules?: string[];
        /** Tool names required by this plugin's projected Skill contract. */
        requiredTools?: string[];
    };
    tools?: McpToolDef[];
    onInstall?(ctx: PluginContext): Promise<void>;
    onUninstall?(ctx: PluginContext): Promise<void>;
    onUpdate?(ctx: PluginContext, prevVersion: string): Promise<void>;
}
export type PluginRecommendation = 'install' | 'optimize' | 'remove';
export interface PluginEffectivenessSummary {
    name: string;
    installCount: number;
    usageCount: number;
    activeRate: number;
    successRate: number;
    lastUsedAt?: string;
    compatibleStacks?: string[];
    recommendation: PluginRecommendation;
}
export interface PluginInstallRecord {
    pluginName: string;
    projectRoot: string;
    installedAt: number;
    uninstalledAt?: number;
}
//# sourceMappingURL=plugin.d.ts.map