@re-shell/cli/dist/utils/plugin-command-conflicts.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 { EventEmitter } from 'events';
import { RegisteredCommand } from './plugin-command-registry';
export declare enum ConflictResolutionStrategy {
    FIRST_WINS = "first-wins",
    LAST_WINS = "last-wins",
    PRIORITY = "priority",
    NAMESPACE = "namespace",
    INTERACTIVE = "interactive",
    AUTO_MERGE = "auto-merge",
    DISABLE_ALL = "disable-all"
}
export declare enum ConflictType {
    COMMAND_NAME = "command-name",
    ALIAS = "alias",
    SUBCOMMAND = "subcommand",
    OPTION = "option",
    DESCRIPTION = "description"
}
export declare enum ConflictSeverity {
    LOW = "low",
    MEDIUM = "medium",
    HIGH = "high",
    CRITICAL = "critical"
}
export interface CommandConflict {
    id: string;
    type: ConflictType;
    severity: ConflictSeverity;
    conflictingCommands: string[];
    conflictingPlugins: string[];
    conflictValue: string;
    description: string;
    suggestions: ConflictSuggestion[];
    autoResolvable: boolean;
    priority: number;
    detectedAt: number;
    resolved: boolean;
    resolution?: ConflictResolution;
}
export interface ConflictSuggestion {
    type: 'rename' | 'namespace' | 'disable' | 'merge' | 'priority';
    description: string;
    action: string;
    impact: 'low' | 'medium' | 'high';
    autoApplicable: boolean;
    confidence: number;
}
export interface ConflictResolution {
    strategy: ConflictResolutionStrategy;
    appliedAt: number;
    appliedBy: 'user' | 'auto';
    actions: ConflictResolutionAction[];
    success: boolean;
    errors: string[];
    reversible: boolean;
}
export interface ConflictResolutionAction {
    type: 'rename' | 'disable' | 'namespace' | 'priority' | 'merge';
    target: string;
    details: Record<string, any>;
    applied: boolean;
    error?: string;
}
export interface PriorityConfig {
    pluginPriorities: Map<string, number>;
    categoryPriorities: Map<string, number>;
    defaultPriority: number;
    userOverrides: Map<string, number>;
    systemCommands: Set<string>;
}
export interface ConflictResolutionPolicy {
    defaultStrategy: ConflictResolutionStrategy;
    strategyByType: Map<ConflictType, ConflictResolutionStrategy>;
    allowAutoResolution: boolean;
    requireConfirmation: boolean;
    maxAutoResolutions: number;
    preserveSystemCommands: boolean;
    namespacePrefix?: string;
}
export declare class CommandConflictResolver extends EventEmitter {
    private conflicts;
    private commands;
    private priorityConfig;
    private resolutionPolicy;
    private resolutionHistory;
    private autoResolutionCount;
    constructor(priorityConfig?: Partial<PriorityConfig>, resolutionPolicy?: Partial<ConflictResolutionPolicy>);
    registerCommands(commands: RegisteredCommand[]): void;
    detectConflicts(): CommandConflict[];
    private detectCommandNameConflicts;
    private detectAliasConflicts;
    private detectOptionConflicts;
    private createCommandNameConflict;
    private createAliasConflict;
    private createOptionConflict;
    private generateConflictSuggestions;
    private calculateCommandPriority;
    private calculateConflictPriority;
    resolveConflict(conflictId: string, strategy?: ConflictResolutionStrategy, options?: {
        userConfirmed?: boolean;
        dryRun?: boolean;
    }): Promise<ConflictResolution>;
    private resolveBypriority;
    private resolveByNamespace;
    private resolveByFirstWins;
    private resolveByLastWins;
    private resolveByDisableAll;
    autoResolveConflicts(): Promise<ConflictResolution[]>;
    private normalizeFlag;
    getConflicts(): CommandConflict[];
    getUnresolvedConflicts(): CommandConflict[];
    getConflictsByType(type: ConflictType): CommandConflict[];
    getConflictsBySeverity(severity: ConflictSeverity): CommandConflict[];
    getResolutionHistory(): ConflictResolution[];
    setUserPriorityOverride(commandId: string, priority: number): void;
    removeUserPriorityOverride(commandId: string): void;
    getStats(): any;
}
export declare function createConflictResolver(priorityConfig?: Partial<PriorityConfig>, resolutionPolicy?: Partial<ConflictResolutionPolicy>): CommandConflictResolver;
export declare function getConflictSeverityColor(severity: ConflictSeverity): string;
export declare function formatConflictType(type: ConflictType): string;