@re-shell/cli/dist/core/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 { Command } from 'commander';
import { EventEmitter } from 'events';
import { PluginHookAPI } from '../utils/plugin-hooks';
export interface CommandDefinition {
    name: string;
    description: string;
    alias?: string[];
    options?: CommandOption[];
    arguments?: CommandArgument[];
    examples?: CommandExample[];
    keywords?: string[];
    category?: string;
    priority?: number;
    hidden?: boolean;
    experimental?: boolean;
    middleware?: CommandMiddleware[];
    handler: CommandHandler;
    plugin?: {
        name: string;
        version: string;
    };
}
export interface CommandOption {
    flag: string;
    description: string;
    defaultValue?: any;
    required?: boolean;
    choices?: string[];
    validator?: (value: any) => boolean | Promise<boolean>;
    transformer?: (value: any) => any;
}
export interface CommandArgument {
    name: string;
    description: string;
    required?: boolean;
    variadic?: boolean;
    defaultValue?: any;
    validator?: (value: any) => boolean | Promise<boolean>;
    transformer?: (value: any) => any;
}
export interface CommandExample {
    description: string;
    command: string;
}
export interface CommandContext {
    command: CommandDefinition;
    args: Record<string, any>;
    options: Record<string, any>;
    program: Command;
    logger: Logger;
    spinner: Spinner;
    analytics: Analytics;
    config: ConfigManager;
    plugins: PluginHookAPI;
}
export interface CommandMiddleware {
    name: string;
    phase: 'pre' | 'post';
    handler: (context: CommandContext) => Promise<void> | void;
}
export type CommandHandler = (context: CommandContext) => Promise<void> | void;
export interface Logger {
    debug(message: string, ...args: any[]): void;
    info(message: string, ...args: any[]): void;
    warn(message: string, ...args: any[]): void;
    error(message: string, ...args: any[]): void;
    success(message: string, ...args: any[]): void;
}
export interface Spinner {
    start(message: string): void;
    succeed(message?: string): void;
    fail(message?: string): void;
    info(message?: string): void;
    warn(message?: string): void;
    stop(): void;
    isSpinning: boolean;
}
export interface Analytics {
    track(event: string, properties?: Record<string, any>): void;
    timeStart(label: string): void;
    timeEnd(label: string): void;
    increment(metric: string, value?: number): void;
}
export interface ConfigManager {
    get<T = any>(key: string, defaultValue?: T): T;
    set(key: string, value: any): void;
    has(key: string): boolean;
    delete(key: string): void;
    getAll(): Record<string, any>;
}
export declare class CommandRegistry extends EventEmitter {
    private logger;
    private analytics;
    private config;
    private plugins;
    private commands;
    private aliases;
    private categories;
    private middleware;
    private commandHistory;
    constructor(logger: Logger, analytics: Analytics, config: ConfigManager, plugins: PluginHookAPI);
    /**
     * Register a new command
     */
    register(definition: CommandDefinition): Promise<void>;
    /**
     * Unregister a command
     */
    unregister(name: string): Promise<void>;
    /**
     * Get a command by name or alias
     */
    get(nameOrAlias: string): CommandDefinition | undefined;
    /**
     * Get all commands
     */
    getAll(): CommandDefinition[];
    /**
     * Get commands by category
     */
    getByCategory(category: string): CommandDefinition[];
    /**
     * Get all categories
     */
    getCategories(): string[];
    /**
     * Add global middleware
     */
    addMiddleware(middleware: CommandMiddleware): void;
    /**
     * Create commander command from definition
     */
    createCommand(program: Command, definition: CommandDefinition): Command;
    /**
     * Execute command with middleware
     */
    private executeCommand;
    /**
     * Run middleware for a phase
     */
    private runMiddleware;
    /**
     * Create command context
     */
    private createContext;
    /**
     * Create spinner instance
     */
    private createSpinner;
    /**
     * Validate command definition
     */
    private validateCommand;
    /**
     * Get command history
     */
    getHistory(): CommandExecution[];
    /**
     * Clear command history
     */
    clearHistory(): void;
    /**
     * Search commands
     */
    search(query: string): CommandDefinition[];
}
interface CommandExecution {
    command: string;
    args: Record<string, any>;
    options: Record<string, any>;
    startTime: number;
    endTime?: number;
    status: 'running' | 'success' | 'error';
    error?: any;
}
export {};