genesis-ai-cli 7.4.5

package/dist/src/world-model/digital-twin.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Genesis 6.0 - Digital Twin
+ *
+ * Digital twin implementation for creating synchronized virtual
+ * representations of real systems.
+ *
+ * Capabilities:
+ * - Real-time synchronization with source system
+ * - Drift detection and correction
+ * - Predictive maintenance through simulation
+ * - What-if scenario analysis
+ *
+ * A digital twin maintains a latent representation that mirrors
+ * the real system, enabling prediction without affecting the original.
+ *
+ * Industrial applications:
+ * - Process monitoring
+ * - Anomaly detection
+ * - Optimization planning
+ * - Failure prediction
+ *
+ * References:
+ * - Grieves (2014). Digital Twin: Manufacturing Excellence through Virtual Factory Replication
+ * - Tao et al. (2019). Digital Twin in Industry
+ *
+ * Usage:
+ * ```typescript
+ * import { createDigitalTwin, DigitalTwinManager } from './world-model/digital-twin.js';
+ *
+ * const twin = createDigitalTwin('server-1', 'Production Server');
+ *
+ * // Start synchronization
+ * twin.startSync(() => fetchRealState());
+ *
+ * // Run what-if scenario
+ * const prediction = twin.whatIf([upgradeAction, restartAction]);
+ *
+ * // Check health
+ * const health = twin.getHealth();
+ * ```
+ */
+import { LatentState, Action, DigitalTwin, DigitalTwinConfig, TwinStatus, Trajectory, ConsistencyCheck } from './types.js';
+export interface TwinMetrics {
+    syncCount: number;
+    driftEvents: number;
+    avgDrift: number;
+    maxDrift: number;
+    uptime: number;
+    lastSync: Date | null;
+    predictions: number;
+}
+export interface TwinHealth {
+    status: TwinStatus;
+    syncHealth: number;
+    predictionAccuracy: number;
+    driftTrend: 'stable' | 'increasing' | 'decreasing';
+    issues: string[];
+    recommendations: string[];
+}
+export interface WhatIfResult {
+    scenario: Action[];
+    trajectory: Trajectory;
+    expectedOutcome: LatentState;
+    riskScore: number;
+    confidence: number;
+    warnings: string[];
+}
+export interface TwinSnapshot {
+    id: string;
+    twinId: string;
+    state: LatentState;
+    realState: LatentState | null;
+    drift: number;
+    timestamp: Date;
+    metadata: Record<string, unknown>;
+}
+export type TwinEventType = 'synced' | 'drift_detected' | 'drift_corrected' | 'prediction_made' | 'what_if_complete' | 'status_changed' | 'error';
+export type TwinEventHandler = (event: {
+    type: TwinEventType;
+    data?: unknown;
+}) => void;
+export declare class DigitalTwinInstance implements DigitalTwin {
+    id: string;
+    name: string;
+    realSystemId: string;
+    currentState: LatentState;
+    lastSync: Date;
+    syncDrift: number;
+    stateHistory: LatentState[];
+    historyLimit: number;
+    config: DigitalTwinConfig;
+    status: TwinStatus;
+    private encoder;
+    private predictor;
+    private syncTimer;
+    private stateFetcher;
+    private metrics;
+    private eventHandlers;
+    private predictionHistory;
+    constructor(realSystemId: string, name: string, config?: Partial<DigitalTwinConfig>);
+    /**
+     * Start synchronization with real system
+     */
+    startSync(fetcher: () => Promise<Record<string, unknown>>): void;
+    /**
+     * Stop synchronization
+     */
+    stopSync(): void;
+    /**
+     * Force immediate synchronization
+     */
+    syncNow(): Promise<void>;
+    /**
+     * Predict future state
+     */
+    predict(actions: Action[], horizon?: number): Trajectory;
+    /**
+     * Run what-if scenario
+     */
+    whatIf(scenario: Action[]): WhatIfResult;
+    /**
+     * Calculate risk score for scenario
+     */
+    private calculateRisk;
+    private getActionRisk;
+    /**
+     * Generate warnings for trajectory
+     */
+    private generateWarnings;
+    /**
+     * Get twin health status
+     */
+    getHealth(): TwinHealth;
+    /**
+     * Get prediction accuracy
+     */
+    private getPredictionAccuracy;
+    /**
+     * Analyze drift trend
+     */
+    private analyzeDriftTrend;
+    /**
+     * Check consistency of twin state
+     */
+    checkConsistency(): ConsistencyCheck;
+    private checkStateConsistency;
+    private checkTemporalConsistency;
+    private checkCausalConsistency;
+    /**
+     * Take a snapshot of current twin state
+     */
+    takeSnapshot(metadata?: Record<string, unknown>): TwinSnapshot;
+    /**
+     * Restore from snapshot
+     */
+    restoreSnapshot(snapshot: TwinSnapshot): void;
+    /**
+     * Calculate drift between two states
+     */
+    private calculateDrift;
+    /**
+     * Calculate similarity between two states
+     */
+    private calculateSimilarity;
+    /**
+     * Blend two states
+     */
+    private blendStates;
+    /**
+     * Correct drift by updating state
+     */
+    private correctDrift;
+    /**
+     * Add state to history
+     */
+    private addToHistory;
+    /**
+     * Update prediction accuracy with new actual state
+     */
+    private updatePredictionAccuracy;
+    /**
+     * Create initial latent state
+     */
+    private createInitialState;
+    on(handler: TwinEventHandler): () => void;
+    private emit;
+    getMetrics(): TwinMetrics;
+}
+export declare class DigitalTwinManager {
+    private twins;
+    /**
+     * Create a new digital twin
+     */
+    createTwin(realSystemId: string, name: string, config?: Partial<DigitalTwinConfig>): DigitalTwinInstance;
+    /**
+     * Get twin by ID
+     */
+    getTwin(id: string): DigitalTwinInstance | undefined;
+    /**
+     * Get all twins
+     */
+    getAllTwins(): DigitalTwinInstance[];
+    /**
+     * Remove twin
+     */
+    removeTwin(id: string): boolean;
+    /**
+     * Get overall health
+     */
+    getOverallHealth(): {
+        totalTwins: number;
+        synced: number;
+        drifting: number;
+        disconnected: number;
+        avgSyncHealth: number;
+    };
+}
+export declare function createDigitalTwin(realSystemId: string, name: string, config?: Partial<DigitalTwinConfig>): DigitalTwinInstance;
+export declare function createDigitalTwinManager(): DigitalTwinManager;