claude-buddy/dist/types/api.d.ts

Your friendly AI development companion for Claude Code - supercharge Claude Code with intelligent workflows and safety features

import { PersonaActivationResult, PersonaFeedback, SystemAnalytics, ActivePersona, GeneratedPrompt } from './personas.js';
import { InputContext, ParsedFlags, FlagValidationResult, LearningRecommendations } from './context.js';
export type { PersonaActivationResult, PersonaFeedback, SystemAnalytics, ActivePersona, GeneratedPrompt, InputContext, ParsedFlags, FlagValidationResult, LearningRecommendations };
export interface ProcessingResult {
    success: boolean;
    personas?: PersonaActivationResult;
    context: InputContext;
    prompt: GeneratedPrompt;
    flags: ParsedFlags;
    validation: FlagValidationResult;
    learning?: LearningRecommendations;
    error?: string;
    details?: string;
}
export interface PersonaSystemOptions {
    configDir?: string;
    enableLearning?: boolean;
    enableCaching?: boolean;
    logLevel?: 'debug' | 'info' | 'warn' | 'error';
}
export interface PersonaSystemError extends Error {
    code: string;
    context?: Record<string, unknown>;
    recoverable: boolean;
}
export type PersonaSystemEvent = 'persona_activated' | 'persona_deactivated' | 'collaboration_planned' | 'error_occurred' | 'learning_updated' | 'config_reloaded';
export interface PersonaSystemEventData {
    event: PersonaSystemEvent;
    timestamp: string;
    data: Record<string, unknown>;
}
export interface PersonaSystemHelp {
    flagHelp: string;
    availablePersonas: string[];
    commands: string[];
    examples: string[];
}
export interface PerformanceMetrics {
    processingTime: number;
    personaLoadTime: number;
    flagParsingTime: number;
    collaborationPlanningTime: number;
    memoryUsage: number;
    cacheHitRate?: number;
}
export interface DebugInfo {
    version: string;
    config: Record<string, unknown>;
    state: Record<string, unknown>;
    performance: PerformanceMetrics;
    errors: PersonaSystemError[];
}
export interface PersonaSystemExports {
    PersonaSystem: typeof import('../personas/index.js').PersonaSystem;
    PersonaManager: typeof import('../personas/persona-manager.js').default;
    PersonaFlagParser: typeof import('../personas/flag-parser.js').default;
    PersonaLearningEngine: typeof import('../personas/learning-engine.js').default;
    personaSystem: import('../personas/index.js').PersonaSystem;
    types: {
        ProcessingResult: ProcessingResult;
        PersonaActivationResult: PersonaActivationResult;
        InputContext: InputContext;
        ParsedFlags: ParsedFlags;
        ActivePersona: ActivePersona;
        PersonaFeedback: PersonaFeedback;
        SystemAnalytics: SystemAnalytics;
    };
}
export interface CommandRecommendation {
    command: string;
    description: string;
    suggestedFlags: string[];
    useCase: string;
    priority: 'low' | 'medium' | 'high';
}
export interface PersonaUsageStats {
    totalActivations: number;
    successfulActivations: number;
    averageConfidence: number;
    mostUsedPersonas: Array<{
        name: string;
        count: number;
    }>;
    collaborationPatterns: Array<{
        pattern: string;
        count: number;
    }>;
    timeRange: {
        start: string;
        end: string;
    };
}
export interface SystemStatus {
    initialized: boolean;
    healthy: boolean;
    version: string;
    uptime: number;
    personasLoaded: number;
    activePersonas: number;
    lastError?: PersonaSystemError;
    configValid: boolean;
}
export interface BatchProcessingRequest {
    inputs: Array<{
        id: string;
        userInput: string;
        context?: Partial<InputContext>;
    }>;
    options?: {
        parallel?: boolean;
        maxConcurrency?: number;
        failFast?: boolean;
    };
}
export interface BatchProcessingResult {
    results: Array<{
        id: string;
        success: boolean;
        result?: ProcessingResult;
        error?: PersonaSystemError;
    }>;
    summary: {
        total: number;
        successful: number;
        failed: number;
        totalTime: number;
        averageTime: number;
    };
}
//# sourceMappingURL=api.d.ts.map