signalk-parquet
Version:
SignalK plugin and webapp that archives SK data to Parquet files with a regimen control system, advanced querying, Claude integrated AI analysis, spatial capabilities, and REST API.
276 lines • 7.53 kB
TypeScript
import { ServerAPI } from '@signalk/server-api';
import { PluginState, ColumnInfo, Statistics, DataQualityMetrics } from './types';
import { VesselContextManager } from './vessel-context';
import { ClaudeModel } from './claude-models';
export interface ClaudeAnalyzerConfig {
apiKey: string;
model: ClaudeModel;
maxTokens: number;
temperature: number;
}
export interface AnalysisRequest {
dataPath: string;
analysisType: 'summary' | 'anomaly' | 'trend' | 'correlation' | 'custom';
timeRange?: {
start: Date;
end: Date;
};
customPrompt?: string;
context?: Record<string, any>;
aggregationMethod?: string;
resolution?: string;
useDatabaseAccess?: boolean;
}
export interface FollowUpRequest {
conversationId: string;
question: string;
}
export interface AnomalyDetection {
timestamp: string;
value: any;
expectedRange: {
min: number;
max: number;
};
severity: 'low' | 'medium' | 'high';
description: string;
confidence: number;
}
export interface AnalysisResponse {
id: string;
analysis: string;
insights: string[];
recommendations?: string[];
anomalies?: AnomalyDetection[];
confidence: number;
dataQuality: string;
timestamp: string;
usage?: {
input_tokens: number;
output_tokens: number;
};
metadata: {
dataPath: string;
analysisType: string;
recordCount: number;
timeRange?: {
start: Date;
end: Date;
};
useDatabaseAccess?: boolean;
};
}
export interface DataSummary {
rowCount: number;
timeRange: {
start: Date;
end: Date;
};
columns: ColumnInfo[];
statisticalSummary: Record<string, Statistics>;
dataQuality: DataQualityMetrics;
}
export interface AvailablePathsFilter {
vesselContext?: string;
pathPattern?: string;
source?: string;
hasValue?: boolean;
includeMetadata?: boolean;
maxDepth?: number;
}
export interface AvailablePathInfo {
path: string;
fullPath: string;
vesselId?: string;
currentValue?: any;
source?: string;
lastUpdate?: string;
}
export declare class ClaudeAnalyzer {
private client;
private config;
private app?;
private dataDirectory?;
private vesselContextManager;
private activeConversations;
private state?;
constructor(config: ClaudeAnalyzerConfig, app?: ServerAPI, dataDirectory?: string, state?: PluginState);
/**
* Main analysis method - analyzes data and returns structured insights
*/
analyzeData(request: AnalysisRequest): Promise<AnalysisResponse>;
/**
* Quick analysis using predefined templates
*/
quickAnalysis(dataPath: string, analysisType: string, timeRange?: {
start: Date;
end: Date;
}): Promise<AnalysisResponse>;
/**
* Detect anomalies in the data
*/
detectAnomalies(dataPath: string, timeRange?: {
start: Date;
end: Date;
}): Promise<AnomalyDetection[]>;
/**
* Prepare data for analysis - includes sampling and summarization
*/
private prepareDataForAnalysis;
/**
* Load data from parquet files based on path and time range
*/
private loadDataFromPath;
/**
* Generate statistical summary of the data
*/
private generateDataSummary;
/**
* Calculate data quality metrics
*/
private calculateDataQuality;
/**
* Calculate data timeliness based on timestamps
*/
private calculateTimeliness;
/**
* Sample data for analysis to respect Claude token limits
*/
private sampleDataForAnalysis;
/**
* Safely stringify data that may contain BigInt values
*/
private safeStringify;
/**
* Analyze data structure to guide Claude on how to interpret the data
*/
private analyzeDataStructure;
/**
* Build analysis prompt based on data and request type
*/
private buildAnalysisPrompt;
/**
* Parse Claude's analysis response into structured format
*/
private parseAnalysisResponse;
/**
* Extract bullet points from text for insights
*/
private extractBulletPoints;
/**
* Save analysis to history for later retrieval
*/
private saveAnalysisToHistory;
/**
* Get analysis history
*/
getAnalysisHistory(limit?: number): Promise<AnalysisResponse[]>;
/**
* Delete an analysis from history
*/
deleteAnalysis(analysisId: string): Promise<{
success: boolean;
error?: string;
}>;
/**
* Tony's approach: Direct database access analysis
* Claude can query the database interactively during analysis
*/
analyzeWithDatabaseAccess(request: AnalysisRequest): Promise<AnalysisResponse>;
/**
* Call Claude API with retry logic for rate limit and overload errors
*/
private callClaudeWithRetry;
/**
* Continue conversation with follow-up question
*/
askFollowUp(request: FollowUpRequest): Promise<AnalysisResponse>;
/**
* Get all available SignalK sources (for debugging)
*/
private getAvailableSignalKSources;
/**
* Recursively collect unique sources from SignalK data
*/
private collectSources;
/**
* Get available real-time SignalK paths with filtering options
*/
private getAvailableSignalKPaths;
/**
* Recursively traverse SignalK data structure to find available paths
*/
private traverseSignalKPaths;
/**
* Get current real-time SignalK data values
*/
private getCurrentSignalKData;
/**
* Get current data from specific vessel buffers
*/
private getCurrentDataFromBuffers;
/**
* Get current data from all vessel buffers
*/
private getAllVesselsCurrentDataFromBuffers;
/**
* Clean SignalK data by removing functions and circular references
*/
private cleanSignalKData;
/**
* Identify relevant regimens based on user query keywords
*/
private identifyRelevantRegimens;
/**
* Get paths associated with a regimen
*/
private getPathsForRegimen;
/**
* Check if user request contains real-time keywords
*/
private checkForRealTimeKeywords;
/**
* Process a single tool call and return the result
*/
private processToolCall;
/**
* Find episodes for a specific regimen using command state transitions
*/
private findRegimenEpisodes;
/**
* Determine the appropriate column to use based on SignalK path type
*/
private getValueColumn;
/**
* Auto-correct column usage in SQL queries based on SignalK path patterns
*/
private correctColumnUsage;
/**
* Execute SQL query safely against Parquet database
*/
private executeSQLQuery;
/**
* Scan a vessel directory for available SignalK paths
*/
private scanVesselPaths;
/**
* Generate enhanced schema information for Claude
*/
private getEnhancedSchemaForClaude;
/**
* Test Claude API connection
*/
testConnection(): Promise<{
success: boolean;
error?: string;
}>;
/**
* Get vessel context manager
*/
getVesselContextManager(): VesselContextManager;
/**
* Refresh vessel information from SignalK
*/
refreshVesselContext(): Promise<void>;
}
//# sourceMappingURL=claude-analyzer.d.ts.map