qraft/dist/core/conflictResolution.d.ts

A powerful CLI tool to qraft structured project setups from GitHub template repositories

import { ChangeAnalysisResult, FileChangeAnalysis } from './changeAnalysis';
import { DirectoryComparison, ManifestConflictInfo } from './contentComparison';
import { DiffSummary, FileDiff } from './diffGenerator';
import { ManifestComparisonResult, ManifestManager } from './manifestManager';
export interface ConflictResolutionChoice {
    action: 'keep_existing' | 'use_new' | 'merge' | 'skip' | 'backup_and_replace';
    reason?: string;
    backupPath?: string;
}
export interface ManifestConflictResolutionChoice {
    action: 'keep_existing' | 'use_new' | 'backup_and_replace' | 'skip' | 'manual_merge';
    reason?: string;
    backupPath?: string;
    mergeStrategy?: 'field_by_field' | 'version_priority' | 'custom';
}
export interface ConflictResolutionPlan {
    file: string;
    choice: ConflictResolutionChoice;
    analysis: FileChangeAnalysis;
    diff?: FileDiff | undefined;
}
export interface ManifestConflictResolutionPlan {
    conflictInfo: ManifestConflictInfo;
    choice: ManifestConflictResolutionChoice;
    manifestComparison?: ManifestComparisonResult;
    priority: 'low' | 'medium' | 'high' | 'critical';
}
export interface ResolutionSession {
    id: string;
    timestamp: Date;
    totalConflicts: number;
    resolvedConflicts: number;
    plans: ConflictResolutionPlan[];
    autoResolved: ConflictResolutionPlan[];
    requiresManualReview: ConflictResolutionPlan[];
    manifestConflicts: ManifestConflictResolutionPlan[];
    manifestAutoResolved: ManifestConflictResolutionPlan[];
    manifestRequiresReview: ManifestConflictResolutionPlan[];
}
export interface ResolutionOptions {
    autoResolveLevel: 'none' | 'safe' | 'moderate' | 'aggressive';
    createBackups: boolean;
    backupDirectory: string;
    interactiveMode: boolean;
    dryRun: boolean;
}
export interface ExecutionOptions {
    createBackups: boolean;
    backupDirectory?: string;
    dryRun?: boolean;
}
export interface ExecutionResult {
    success: boolean;
    message: string;
    action: string;
    backupPath?: string;
    requiresManualIntervention?: boolean;
}
export declare class ConflictResolution {
    private manifestManager;
    constructor(manifestManager?: ManifestManager);
    createResolutionSession(analysis: ChangeAnalysisResult, comparison: DirectoryComparison, diffSummary: DiffSummary, options: ResolutionOptions): ResolutionSession;
    private createResolutionPlan;
    private determineDefaultChoice;
    /**
     * Create a resolution plan for manifest conflicts
     * @param conflictInfo Manifest conflict information
     * @param manifestComparison Optional manifest comparison result
     * @param options Resolution options
     * @returns ManifestConflictResolutionPlan
     */
    private createManifestResolutionPlan;
    /**
     * Get manifest manager instance for advanced operations
     * @returns ManifestManager instance
     */
    getManifestManager(): ManifestManager;
    /**
     * Determine default choice for manifest conflicts
     * @param conflictInfo Manifest conflict information
     * @param options Resolution options
     * @returns ManifestConflictResolutionChoice
     */
    private determineManifestDefaultChoice;
    /**
     * Get priority level for manifest conflicts
     * @param conflictInfo Manifest conflict information
     * @returns Priority level
     */
    private getManifestConflictPriority;
    /**
     * Check if manifest conflict can be auto-resolved
     * @param plan Manifest resolution plan
     * @param options Resolution options
     * @returns boolean
     */
    private canAutoResolveManifest;
    private canAutoResolve;
    resolveInteractively(session: ResolutionSession, onPrompt: (plan: ConflictResolutionPlan) => Promise<ConflictResolutionChoice>): Promise<ResolutionSession>;
    generateResolutionSummary(session: ResolutionSession): {
        text: string;
        actions: Record<string, number>;
        riskAssessment: string;
    };
    validateResolutionPlan(plan: ConflictResolutionPlan): {
        valid: boolean;
        warnings: string[];
        errors: string[];
    };
    generateBackupPath(originalPath: string, backupDir: string): string;
    applyResolutionPlan(plan: ConflictResolutionPlan, options: ResolutionOptions): Promise<{
        success: boolean;
        message: string;
        backupCreated?: string;
    }>;
    private generateSessionId;
    getSessionStats(session: ResolutionSession): {
        total: number;
        autoResolved: number;
        manualReview: number;
        byAction: Record<string, number>;
        byRisk: Record<string, number>;
        manifestStats: {
            total: number;
            autoResolved: number;
            manualReview: number;
            byPriority: Record<string, number>;
        };
    };
    /**
     * Execute manifest conflict resolution
     * @param plan Manifest resolution plan
     * @param targetDirectory Target directory for manifest operations
     * @param options Execution options
     * @returns Promise<ExecutionResult>
     */
    executeManifestResolution(plan: ManifestConflictResolutionPlan, targetDirectory: string): Promise<ExecutionResult>;
    /**
     * Validate manifest resolution plan
     * @param plan Manifest resolution plan
     * @returns Validation result
     */
    validateManifestResolutionPlan(plan: ManifestConflictResolutionPlan): {
        valid: boolean;
        warnings: string[];
        errors: string[];
    };
}
//# sourceMappingURL=conflictResolution.d.ts.map