@re-shell/cli/dist/utils/plugin-command-registry.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

import * as path from 'path';
import { EventEmitter } from 'events';
import chalk from 'chalk';
import { Command } from 'commander';
import { PluginRegistration } from './plugin-system';
import { CommandConflictResolver } from './plugin-command-conflicts';
export interface PluginCommandDefinition {
    name: string;
    description: string;
    aliases?: string[];
    arguments?: PluginCommandArgument[];
    options?: PluginCommandOption[];
    subcommands?: PluginCommandDefinition[];
    handler: PluginCommandHandler;
    middleware?: PluginCommandMiddleware[];
    priority?: number;
    category?: string;
    examples?: string[];
    hidden?: boolean;
    deprecated?: boolean;
    permission?: string;
}
export interface PluginCommandArgument {
    name: string;
    description: string;
    required: boolean;
    variadic?: boolean;
    type?: 'string' | 'number' | 'boolean';
    choices?: string[];
    defaultValue?: any;
    validation?: PluginArgumentValidator;
}
export interface PluginCommandOption {
    flag: string;
    description: string;
    type?: 'string' | 'number' | 'boolean';
    required?: boolean;
    choices?: string[];
    defaultValue?: any;
    validation?: PluginArgumentValidator;
    conflicts?: string[];
    implies?: string[];
}
export type PluginCommandHandler = (args: Record<string, any>, options: Record<string, any>, context: PluginCommandContext) => Promise<void> | void;
export type PluginCommandMiddleware = (args: Record<string, any>, options: Record<string, any>, context: PluginCommandContext, next: () => Promise<void>) => Promise<void>;
export type PluginArgumentValidator = (value: any) => boolean | string;
export interface PluginCommandContext {
    command: PluginCommandDefinition;
    plugin: PluginRegistration;
    cli: {
        program: Command;
        rootPath: string;
        configPath: string;
        version: string;
    };
    logger: {
        debug: (msg: string, ...args: any[]) => void;
        info: (msg: string, ...args: any[]) => void;
        warn: (msg: string, ...args: any[]) => void;
        error: (msg: string, ...args: any[]) => void;
    };
    utils: {
        path: typeof path;
        chalk: typeof chalk;
        spinner: any;
    };
}
export interface RegisteredCommand {
    id: string;
    pluginName: string;
    definition: PluginCommandDefinition;
    commanderCommand: Command;
    registeredAt: number;
    usageCount: number;
    lastUsed?: number;
    isActive: boolean;
    conflicts: string[];
}
export interface CommandRegistrationResult {
    success: boolean;
    commandId: string;
    conflicts: string[];
    warnings: string[];
    errors: string[];
}
export interface CommandRegistryConfig {
    allowConflicts: boolean;
    conflictResolution: 'first' | 'last' | 'priority' | 'manual';
    enableMiddleware: boolean;
    validatePermissions: boolean;
    trackUsage: boolean;
    logCommands: boolean;
}
export declare class PluginCommandRegistry extends EventEmitter {
    private commands;
    private aliases;
    private conflicts;
    private program;
    private config;
    private isInitialized;
    private middlewareManager;
    private conflictResolver;
    constructor(program: Command, config?: Partial<CommandRegistryConfig>);
    initialize(): Promise<void>;
    registerCommand(plugin: PluginRegistration, definition: PluginCommandDefinition): Promise<CommandRegistrationResult>;
    unregisterCommand(commandId: string): Promise<boolean>;
    unregisterPluginCommands(pluginName: string): Promise<number>;
    getCommand(commandId: string): RegisteredCommand | undefined;
    getCommands(): RegisteredCommand[];
    getPluginCommands(pluginName: string): RegisteredCommand[];
    findCommand(nameOrAlias: string): RegisteredCommand | undefined;
    getConflicts(): Map<string, string[]>;
    resolveConflicts(commandName: string, resolution: 'disable' | 'priority'): Promise<boolean>;
    private validateCommandDefinition;
    private checkForConflicts;
    private createCommanderCommand;
    private processArguments;
    private processOptions;
    private validateOptionRelationships;
    getMiddlewareManager(): import("./plugin-command-middleware").MiddlewareChainManager;
    getConflictResolver(): CommandConflictResolver;
    updateConflictResolver(): void;
    private createCommandContext;
    private createLogger;
    private extractOptionName;
    private generateCommandId;
    private setupUsageTracking;
    private trackCommandUsage;
    private updateConflictTracking;
    private removeFromConflictTracking;
    getStats(): any;
}
export declare function createPluginCommandRegistry(program: Command, config?: Partial<CommandRegistryConfig>): PluginCommandRegistry;
export declare function validateCommandName(name: string): boolean;
export declare function normalizeCommandName(name: string): string;