claritykit-svelte/dist/components/bms/LoopDiagnosticPanel/types.d.ts

A comprehensive Svelte component library focused on accessibility, ADHD-optimized design, developer experience, and full SSR compatibility

import type { HTMLAttributes } from 'svelte/elements';
export type LoopStatus = 'completed' | 'optimized' | 'in-progress' | 'incomplete' | 'abandoned';
export type EnergyType = 'emotional' | 'physical' | 'cognitive' | 'social';
export interface BehavioralLoop {
    id: string;
    name: string;
    description?: string;
    status: LoopStatus;
    activationEnergy: number;
    environmentalSupport: number;
    toolAlignment: number;
    energyData?: {
        perceivedEnergy: number;
        actualEnergy: number;
        energyType: EnergyType;
        mismatch?: number;
        calibrationNeeded?: boolean;
    };
    identityAlignment?: {
        congruence: number;
        identityFactors: string[];
        misalignmentReasons?: string[];
    };
    timePatterns?: {
        preferredTimeOfDay: string;
        durationPattern: 'short-burst' | 'sustained' | 'flexible';
        seasonalFactors?: string[];
    };
    completionRate: number;
    abandonmentRate: number;
    optimizationScore: number;
    createdAt: Date;
    lastActive: Date;
    category?: string;
    tags?: string[];
}
export interface SystemFactor {
    id: string;
    category: 'activation-energy' | 'environmental-support' | 'tool-alignment' | 'identity-task' | 'energy-perception';
    name: string;
    description: string;
    impact: number;
    frequency: number;
    solutions: string[];
    isAddressable: boolean;
}
export interface LoopAnalysis {
    id: string;
    loopId: string;
    timestamp: Date;
    systemFactors: SystemFactor[];
    environmentalBarriers: string[];
    toolFrictionPoints: string[];
    energyMismatches: Array<{
        type: EnergyType;
        severity: number;
        pattern: string;
    }>;
    recommendations: Array<{
        type: 'reduce-activation-energy' | 'improve-environment' | 'upgrade-tools' | 'calibrate-energy' | 'align-identity';
        priority: number;
        description: string;
        actionSteps: string[];
        estimatedImpact: number;
    }>;
    agentInsights: Array<{
        targetAgent: 'architect' | 'scholar' | 'activities' | 'researcher';
        insight: string;
        relevance: number;
        actionable: boolean;
    }>;
}
export interface EnergyCalibration {
    loopId: string;
    perceivedEnergy: number;
    actualEnergy: number;
    energyType: EnergyType;
    context?: {
        timeOfDay: string;
        activity: string;
        environment: string;
        mood?: string;
    };
    timestamp: Date;
    calibrationMethod?: 'self-report' | 'measured' | 'inferred';
    notes?: string;
}
export interface FallbackMethod {
    id: string;
    loopId: string;
    name: string;
    description: string;
    usageFrequency: number;
    successRate: number;
    shouldPromote: boolean;
    promotionReasons: string[];
    promotionBarriers?: string[];
    primaryMethodComparison: {
        speed: number;
        quality: number;
        satisfaction: number;
        accessibility: number;
    };
}
export interface MoodTrajectory {
    id: string;
    loopId: string;
    timeline: Array<{
        timestamp: Date;
        mood: number;
        context: string;
        expectations: number;
        reality: number;
        alignment: number;
    }>;
    patterns: Array<{
        type: 'time-of-day' | 'environment' | 'tool-usage' | 'identity-match';
        pattern: string;
        correlation: number;
        insight: string;
    }>;
}
export interface LoopDiagnosticPanelProps extends HTMLAttributes<HTMLDivElement> {
    /**
     * List of behavioral loops to analyze
     */
    loops: BehavioralLoop[];
    /**
     * Historical loop analyses
     */
    analyses?: LoopAnalysis[];
    /**
     * Show system factors analysis
     * @default true
     */
    showSystemFactors?: boolean;
    /**
     * Show energy calibration tools
     * @default true
     */
    showEnergyCalibration?: boolean;
    /**
     * Show mood trajectory tracking
     * @default true
     */
    showMoodTracking?: boolean;
    /**
     * Enable compassionate framing (focus on system, not personal failure)
     * @default true
     */
    enableCompassionateFraming?: boolean;
    /**
     * Show recommendations for loop optimization
     * @default true
     */
    showRecommendations?: boolean;
    /**
     * Callback when loop analysis is requested
     */
    onLoopAnalyze?: (loop: BehavioralLoop) => void;
    /**
     * Callback when system factors are updated
     */
    onSystemFactorUpdate?: (loopId: string, factors: SystemFactor[]) => void;
    /**
     * Callback when energy calibration is performed
     */
    onEnergyCalibrate?: (calibration: EnergyCalibration) => void;
    /**
     * Callback when recommendation is applied
     */
    onRecommendationApply?: (loopId: string, recommendation: string) => void;
}
export interface LoopDiagnosticIntegration {
    /**
     * Share insights with Architect for planning improvements
     */
    shareWithArchitect: (insights: string[]) => Promise<void>;
    /**
     * Share patterns with Scholar for semantic analysis
     */
    shareWithScholar: (patterns: string[]) => Promise<void>;
    /**
     * Share interest insights with Activities agent
     */
    shareWithActivities: (interests: string[]) => Promise<void>;
    /**
     * Request environmental analysis from external systems
     */
    analyzeEnvironment: (context: any) => Promise<EnvironmentAnalysis>;
}
export interface EnvironmentAnalysis {
    factors: Array<{
        type: string;
        impact: number;
        modifiable: boolean;
        suggestions: string[];
    }>;
    supportLevel: number;
    optimizationOpportunities: string[];
}
export interface CompassionateFraming {
    /**
     * Reframe personal failure as system factors
     */
    reframeAsSystemFactor: (issue: string) => string;
    /**
     * Generate non-judgmental analysis
     */
    generateCompassionateAnalysis: (loop: BehavioralLoop) => string;
    /**
     * Focus on environmental and tool improvements
     */
    suggestSystemOptimizations: (loop: BehavioralLoop) => string[];
}
//# sourceMappingURL=types.d.ts.map