/**
 * Living Docs Orchestrator
 *
 * Main coordinator that manages the entire analysis pipeline with caching and change detection.
 *
 * Architecture:
 * Phase 1: Discovery (repo scanning)
 * Phase 2: Analysis (patterns, modules, tech debt)
 * Phase 3: Synthesis (ADR generation with LLM)
 */
import { Logger } from '../../../utils/logger.js';
import type { RepoAnalysis, LLMProvider } from './types.js';
export interface OrchestratorOptions {
    projectRoot: string;
    logger?: Logger;
    llmProvider?: LLMProvider;
}
export interface UpdateOptions {
    incremental?: boolean;
    full?: boolean;
    adrOnly?: boolean;
    techDebtOnly?: boolean;
    modulesOnly?: boolean;
    dryRun?: boolean;
}
export interface DiscoveryResult {
    repos: Array<{
        name: string;
        path: string;
    }>;
    totalFiles: number;
    duration: number;
}
export interface AnalysisResult {
    repoAnalyses: Map<string, RepoAnalysis>;
    duration: number;
    filesCreated?: string[];
}
export interface SynthesisResult {
    adrsGenerated: number;
    teamsClustered: number;
    duration: number;
    filesCreated?: string[];
}
export interface PhaseResult {
    success: boolean;
    duration: number;
    message: string;
}
export interface UpdateResult {
    success: boolean;
    duration: number;
    phases: {
        discovery: PhaseResult;
        analysis: PhaseResult;
        synthesis: PhaseResult;
    };
    filesCreated: string[];
    filesUpdated: string[];
    errors: string[];
}
export interface ChangedFiles {
    path: string;
    status: 'added' | 'modified' | 'deleted';
}
/**
 * Main orchestrator for living docs intelligent analysis.
 *
 * Coordinates all analysis phases with caching and Git-based change detection.
 */
export declare class LivingDocsOrchestrator {
    private projectRoot;
    private logger;
    private llmProvider?;
    private cacheDir;
    constructor(options: OrchestratorOptions);
    /**
     * Main entry point - orchestrates full update or incremental update.
     */
    update(options?: UpdateOptions): Promise<UpdateResult>;
    /**
     * Phase 1: Discovery
     * Scans all repos (umbrella or single) and creates file inventory.
     */
    private executePhase1Discovery;
    /**
     * Phase 2: Analysis
     * Pattern detection, module graph, tech debt detection.
     */
    private executePhase2Analysis;
    /**
     * Phase 3: Synthesis
     * LLM-powered ADR synthesis, team clustering, architecture docs.
     */
    private executePhase3Synthesis;
    /**
     * Detect changes since last update using Git diff.
     */
    detectChanges(): Promise<ChangedFiles[]>;
    /**
     * Load data from cache.
     */
    loadFromCache<T>(key: string): Promise<T | null>;
    /**
     * Save data to cache.
     */
    saveToCache(key: string, data: any): Promise<void>;
    /**
     * Clear all cache and checkpoint data.
     * Used when --full flag is set to force complete rebuild.
     */
    clearCache(): Promise<void>;
    /**
     * Discover all repos (umbrella or single).
     */
    private discoverRepos;
    /**
     * Get current Git commit hash.
     */
    private getCurrentCommit;
    /**
     * Count files in a directory (excluding node_modules, .git, etc.).
     */
    private countFiles;
}
//# sourceMappingURL=orchestrator.d.ts.map