aether-react 0.1.0 → 1.0.0

package/dist/index.d.ts

@@ -1,6 +1,134 @@
+import { MemoryEvent, MemoryEventInput, RetrievalOptions, MemoryStats, Aether, Prediction, SimulationResult, Anomaly, AnomalySeverity, RetrievalType, Trajectory, Pattern, TransitionMatrix } from 'aether-core';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React from 'react';
-import { Aether, MemoryEvent, RetrievalOptions, RetrievalType, MemoryStats } from 'aether-core';
+
+/**
+ * Configuration for RemoteAether client.
+ */
+interface RemoteAetherConfig {
+    /** Base URL of the Aether server (e.g., 'http://localhost:3000') */
+    baseUrl: string;
+    /** Optional API key for authentication */
+    apiKey?: string;
+    /** WebSocket URL (defaults to ws(s)://baseUrl/ws) */
+    wsUrl?: string;
+    /** Auto-reconnect WebSocket on disconnect */
+    autoReconnect?: boolean;
+    /** Reconnect delay in ms */
+    reconnectDelay?: number;
+}
+/**
+ * Unsubscribe function type.
+ */
+type Unsubscribe = () => void;
+/**
+ * Event listener callback type.
+ */
+type EventListener = (event: MemoryEvent) => void;
+/**
+ * Connection state listener type.
+ */
+type ConnectionListener = (connected: boolean) => void;
+/**
+ * RemoteAether - A client that implements the Aether interface over REST/WebSocket.
+ *
+ * Use this to connect a React app to a remote Aether server.
+ *
+ * @example
+ * ```typescript
+ * import { RemoteAether, Dashboard } from 'aether-react';
+ *
+ * const client = new RemoteAether({ baseUrl: 'http://localhost:3000' });
+ * await client.initialize();
+ *
+ * // Use with Dashboard
+ * <Dashboard aether={client} />
+ * ```
+ */
+declare class RemoteAether {
+    private readonly config;
+    private ws;
+    private listeners;
+    private connectionListeners;
+    private connected;
+    private initialized;
+    private reconnectTimer;
+    constructor(config: RemoteAetherConfig | string);
+    /**
+     * Initialize the client and establish WebSocket connection.
+     * Verifies server connectivity before establishing WebSocket.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Add a memory event.
+     */
+    add(content: string, context?: Record<string, unknown>): Promise<MemoryEvent>;
+    add(event: MemoryEventInput): Promise<MemoryEvent>;
+    /**
+     * Add multiple memory events in a batch.
+     */
+    addBatch(events: MemoryEventInput[]): Promise<MemoryEvent[]>;
+    /**
+     * Retrieve relevant memories based on a query.
+     */
+    retrieve(query: string, options?: RetrievalOptions): Promise<MemoryEvent[]>;
+    /**
+     * Get all events.
+     */
+    getAll(limit?: number): Promise<MemoryEvent[]>;
+    /**
+     * Get the history of events for a specific actor.
+     */
+    getHistory(actor: string, limit?: number): Promise<MemoryEvent[]>;
+    /**
+     * Get a specific event by ID.
+     */
+    get(id: string): Promise<MemoryEvent | null>;
+    /**
+     * Delete a specific event by ID.
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Get statistics about the memory store.
+     */
+    stats(): Promise<MemoryStats>;
+    /**
+     * Subscribe to new memory events.
+     */
+    subscribe(callback: EventListener): Unsubscribe;
+    /**
+     * Subscribe to connection state changes.
+     */
+    onConnectionChange(callback: ConnectionListener): Unsubscribe;
+    /**
+     * Check if WebSocket is connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Close the client and disconnect WebSocket.
+     */
+    close(): Promise<void>;
+    /**
+     * Make an authenticated fetch request.
+     */
+    private fetch;
+    /**
+     * Establish WebSocket connection.
+     */
+    private connectWebSocket;
+    /**
+     * Schedule a WebSocket reconnection attempt.
+     */
+    private scheduleReconnect;
+    /**
+     * Notify all event listeners.
+     */
+    private notifyListeners;
+    /**
+     * Notify all connection listeners.
+     */
+    private notifyConnectionListeners;
+}
 
 interface AetherContextValue {
     aether: Aether | null;
@@ -48,16 +176,41 @@ interface UseMemoryStreamReturn {
 }
 declare function useMemoryStream(serverUrl: string, options?: UseMemoryStreamOptions): UseMemoryStreamReturn;
 
+type SelectionType = 'event' | 'actor' | 'link';
+interface GraphSelection {
+    type: SelectionType;
+    data: MemoryEvent | string | GraphLink;
+}
 interface MemoryGraphViewProps {
     events: MemoryEvent[];
-    width?: number;
-    height?: number;
-    onNodeClick?: (event: MemoryEvent) => void;
+    onNodeClick?: (event: MemoryEvent | null) => void;
+    onSelectionChange?: (selection: GraphSelection | null) => void;
+    selectedEvent?: MemoryEvent | null;
+    selection?: GraphSelection | null;
     highlightActor?: string;
     showRelations?: boolean;
+    showLegend?: boolean;
     className?: string;
 }
-declare function MemoryGraphView({ events, width, height, onNodeClick, highlightActor, showRelations, className, }: MemoryGraphViewProps): react_jsx_runtime.JSX.Element;
+interface GraphNode {
+    id: string;
+    type: 'event' | 'actor';
+    label: string;
+    event?: MemoryEvent;
+    x?: number;
+    y?: number;
+    fx?: number | null;
+    fy?: number | null;
+}
+interface GraphLink {
+    id: string;
+    source: string | GraphNode;
+    target: string | GraphNode;
+    type: 'actor' | 'temporal' | 'relation';
+    sourceLabel?: string;
+    targetLabel?: string;
+}
+declare function MemoryGraphView({ events, onNodeClick, onSelectionChange, selectedEvent, selection: controlledSelection, highlightActor, showRelations, showLegend, className, }: MemoryGraphViewProps): react_jsx_runtime.JSX.Element;
 
 interface TimelineViewProps {
     events: MemoryEvent[];
@@ -103,6 +256,155 @@ interface MemoryCardProps {
 }
 declare function MemoryCard({ event, onClick, selected, showContext, className, }: MemoryCardProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Trajectory data for display.
+ * Aligned with core Trajectory type for consistency.
+ */
+interface TrajectoryData {
+    id: string;
+    actor: string;
+    status: 'active' | 'completed' | 'abandoned';
+    outcome?: 'success' | 'failure' | 'partial';
+    /** Event IDs in chronological order */
+    events: string[];
+    /** ISO 8601 timestamp when trajectory started */
+    startTime: string;
+    /** ISO 8601 timestamp when trajectory ended */
+    endTime?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Props for TrajectoryView component.
+ */
+interface TrajectoryViewProps {
+    /** Memory events to display */
+    events: MemoryEvent[];
+    /** Optional trajectories data */
+    trajectories?: TrajectoryData[];
+    /** Callback when an event is clicked */
+    onEventClick?: (event: MemoryEvent) => void;
+    /** Callback when a trajectory is clicked */
+    onTrajectoryClick?: (trajectory: TrajectoryData) => void;
+    /** Currently selected event ID */
+    selectedEventId?: string;
+    /** Currently selected trajectory ID */
+    selectedTrajectoryId?: string;
+    /** Show trajectory boundaries */
+    showBoundaries?: boolean;
+    /** Maximum height */
+    maxHeight?: string;
+}
+/**
+ * TrajectoryView - Shows events grouped by trajectories with boundaries.
+ */
+declare function TrajectoryView({ events, trajectories, onEventClick, onTrajectoryClick, selectedEventId, selectedTrajectoryId, showBoundaries, maxHeight, }: TrajectoryViewProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Pattern data for display.
+ */
+interface PatternData {
+    id: string;
+    sequence: string[];
+    frequency: number;
+    confidence: number;
+    support: number;
+    examples: string[];
+    avgDurationMs?: number;
+}
+/**
+ * Anomaly data for display.
+ */
+interface AnomalyData {
+    eventId: string;
+    reason: string;
+    severity: 'low' | 'medium' | 'high';
+    deviationScore: number;
+    detectedAt: string;
+    expectedAction?: string;
+}
+/**
+ * Transition matrix data.
+ */
+interface TransitionMatrixData {
+    actions: string[];
+    probabilities: number[][];
+    counts: number[][];
+    totalTransitions: number;
+}
+/**
+ * Props for PatternDashboard component.
+ */
+interface PatternDashboardProps {
+    /** Detected patterns */
+    patterns?: PatternData[];
+    /** Detected anomalies */
+    anomalies?: AnomalyData[];
+    /** Transition matrix */
+    transitionMatrix?: TransitionMatrixData;
+    /** Loading state */
+    loading?: boolean;
+    /** Callback when a pattern is clicked */
+    onPatternClick?: (pattern: PatternData) => void;
+    /** Callback when an anomaly is clicked */
+    onAnomalyClick?: (anomaly: AnomalyData) => void;
+}
+/**
+ * PatternDashboard - Shows patterns, anomalies, and transition matrix.
+ */
+declare function PatternDashboard({ patterns, anomalies, transitionMatrix, loading, onPatternClick, onAnomalyClick, }: PatternDashboardProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Props for PredictionPanel component.
+ */
+interface PredictionPanelProps {
+    /** Current predictions */
+    predictions: Prediction[];
+    /** Loading state */
+    loading?: boolean;
+    /** Error message */
+    error?: string;
+    /** Callback to run simulation */
+    onSimulate?: (action: string, context?: Record<string, unknown>) => Promise<SimulationResult>;
+    /** Callback when a prediction is clicked */
+    onPredictionClick?: (prediction: Prediction) => void;
+    /** Whether simulation is available */
+    simulationEnabled?: boolean;
+    /** Maximum height */
+    maxHeight?: string;
+}
+/**
+ * PredictionPanel - Shows predictions and simulation sandbox.
+ */
+declare function PredictionPanel({ predictions, loading, error, onSimulate, onPredictionClick, simulationEnabled, maxHeight, }: PredictionPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Props for AnomalyAlerts component.
+ */
+interface AnomalyAlertsProps {
+    /** List of anomalies */
+    anomalies: Anomaly[];
+    /** Loading state */
+    loading?: boolean;
+    /** Error message */
+    error?: string;
+    /** Callback when an anomaly is clicked */
+    onAnomalyClick?: (anomaly: Anomaly) => void;
+    /** Callback to dismiss an anomaly */
+    onDismiss?: (anomalyId: string) => void;
+    /** Whether to show dismissed anomalies */
+    showDismissed?: boolean;
+    /** Minimum severity to display */
+    minSeverity?: AnomalySeverity;
+    /** Maximum height */
+    maxHeight?: string;
+    /** Show as compact notification list */
+    compact?: boolean;
+}
+/**
+ * AnomalyAlerts - Real-time anomaly notification panel.
+ */
+declare function AnomalyAlerts({ anomalies, loading, error, onAnomalyClick, onDismiss, minSeverity, maxHeight, compact, }: AnomalyAlertsProps): react_jsx_runtime.JSX.Element;
+
 interface AddMemoryFormProps {
     onAdd: (content: string, actor: string, context?: Record<string, unknown>) => Promise<void>;
     loading?: boolean;
@@ -143,17 +445,52 @@ declare function ActorSelector({ actors, selectedActor, onSelect, loading, class
 
 interface ConnectionStatusProps {
     connected: boolean;
-    error?: Error | null;
+    error?: string | null;
     onReconnect?: () => void;
     className?: string;
 }
 declare function ConnectionStatus({ connected, error, onReconnect, className, }: ConnectionStatusProps): react_jsx_runtime.JSX.Element;
 
+interface ConnectionScreenProps {
+    onConnect: (url: string, apiKey?: string) => void;
+    defaultUrl?: string;
+    isConnecting?: boolean;
+    error?: string | null;
+}
+declare function ConnectionScreen({ onConnect, defaultUrl, isConnecting, error, }: ConnectionScreenProps): react_jsx_runtime.JSX.Element;
+
+interface AetherClient {
+    add(content: string, context?: Record<string, unknown>): Promise<MemoryEvent>;
+    add(event: MemoryEventInput): Promise<MemoryEvent>;
+    retrieve(query: string, options?: RetrievalOptions): Promise<MemoryEvent[]>;
+    getAll?(limit?: number): Promise<MemoryEvent[]>;
+    getHistory(actor: string, limit?: number): Promise<MemoryEvent[]>;
+    stats(): Promise<MemoryStats>;
+    subscribe(callback: (event: MemoryEvent) => void): () => void;
+    getTrajectories?(actor: string): Promise<Trajectory[]>;
+    getTrajectory?(id: string): Promise<Trajectory | null>;
+    detectPatterns?(actor: string): Promise<Pattern[]>;
+    findAnomalies?(actor: string): Promise<Anomaly[]>;
+    getTransitionProbabilities?(actor: string): Promise<TransitionMatrix>;
+    predictNext?(eventId: string): Promise<Prediction[]>;
+    simulate?(actor: string, action: string, context?: Record<string, unknown>): Promise<SimulationResult>;
+}
+interface ConnectionState {
+    connected: boolean;
+    error?: string | null;
+    onReconnect?: () => void;
+}
 interface DashboardProps {
-    aether: Aether;
+    aether: AetherClient;
     title?: string;
+    subtitle?: string;
     className?: string;
+    connection?: ConnectionState;
+    previewMode?: boolean;
+    previewMemories?: MemoryEvent[];
+    onPreviewToggle?: (enabled: boolean) => void;
+    onDisconnect?: () => void;
 }
-declare function Dashboard({ aether, title, className }: DashboardProps): react_jsx_runtime.JSX.Element;
+declare function Dashboard({ aether, title, subtitle, className, connection, previewMode, previewMemories, onPreviewToggle, onDisconnect, }: DashboardProps): react_jsx_runtime.JSX.Element;
 
-export { ActorSelector, type ActorSelectorProps, AddMemoryForm, type AddMemoryFormProps, AetherProvider, ClusterMap, type ClusterMapProps, ConnectionStatus, type ConnectionStatusProps, Dashboard, type DashboardProps, MemoryCard, type MemoryCardProps, MemoryExplorer, type MemoryExplorerProps, MemoryGraphView, type MemoryGraphViewProps, SearchBar, type SearchBarProps, type SearchOptions, StatsPanel, type StatsPanelProps, TimelineView, type TimelineViewProps, useAether, useMemoryStream };
+export { ActorSelector, type ActorSelectorProps, AddMemoryForm, type AddMemoryFormProps, type AetherClient, AetherProvider, AnomalyAlerts, type AnomalyAlertsProps, ClusterMap, type ClusterMapProps, type ConnectionListener, ConnectionScreen, type ConnectionScreenProps, type ConnectionState, ConnectionStatus, type ConnectionStatusProps, Dashboard, type DashboardProps, type EventListener, type GraphSelection, MemoryCard, type MemoryCardProps, MemoryExplorer, type MemoryExplorerProps, MemoryGraphView, type MemoryGraphViewProps, PatternDashboard, type PatternDashboardProps, PredictionPanel, type PredictionPanelProps, RemoteAether, type RemoteAetherConfig, SearchBar, type SearchBarProps, type SearchOptions, type SelectionType, StatsPanel, type StatsPanelProps, TimelineView, type TimelineViewProps, type TrajectoryData, TrajectoryView, type TrajectoryViewProps, type Unsubscribe, useAether, useMemoryStream };