@a-company/sentinel 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,434 @@
+import { S as SentinelStorage, a as SymbolicIncidentRecord, I as IncidentGroup, F as FlowTimeline, b as SentinelStats, c as SymbolHealth, E as EnrichedIncident, d as SymbolEnrichment, e as FailurePattern, P as PatternCandidate, f as PatternExport } from './sdk-B27_vK1g.js';
+export { B as BackupExport, C as ComponentContext, g as CreateGroupInput, h as CreateIncidentInput, i as CreatePatternInput, D as DayCount, j as Environment, k as ErrorDetails, l as FlowEvent, m as FlowEventType, n as FlowPosition, o as FlowTracker, p as IncidentNote, q as IncidentQueryOptions, r as IncidentStatus, M as MatchedCriteria, s as MatcherConfig, t as PatternConfidence, u as PatternCriteria, v as PatternEffectiveness, w as PatternMatch, x as PatternMatcher, y as PatternPriority, z as PatternQueryOptions, A as PatternRecurrence, G as PatternResolution, H as PatternSource, J as PatternSymbolCriteria, K as PatternTestResult, L as PracticeCategory, N as PracticeEvent, O as PracticeEventInput, Q as PracticeEventQuery, R as PracticeResult, T as Resolution, U as ResolutionQueryOptions, V as ResolutionRecord, W as ResolutionStrategy, X as Sentinel, Y as SentinelConfig, Z as SymbolHotspot, _ as SymbolIncidentCount, $ as SymbolResolutionTime, a0 as SymbolicContext } from './sdk-B27_vK1g.js';
+
+/**
+ * Sentinel Configuration
+ *
+ * Loads and writes .sentinel.yaml config files.
+ * Provides project-level configuration for the Sentinel SDK and CLI.
+ */
+interface SentinelYamlConfig {
+    version: string;
+    project: string;
+    environment?: string;
+    symbols?: {
+        components?: string[];
+        gates?: string[];
+        flows?: string[];
+        signals?: string[];
+    };
+    routes?: Record<string, string>;
+    scrub?: {
+        headers?: string[];
+        fields?: string[];
+    };
+}
+/**
+ * Load .sentinel.yaml from a project directory.
+ *
+ * @param projectDir - Project root directory
+ * @returns Parsed config or null if not found
+ */
+declare function loadConfig(projectDir: string): SentinelYamlConfig | null;
+/**
+ * Write .sentinel.yaml to a project directory.
+ *
+ * @param projectDir - Project root directory
+ * @param config - Config to write
+ */
+declare function writeConfig(projectDir: string, config: SentinelYamlConfig): void;
+
+/**
+ * Sentinel Auto-Symbol Detector
+ *
+ * Scans codebase structure to infer Paradigm symbols.
+ * Works for any project — doesn't require Paradigm.
+ */
+
+interface DetectionResult {
+    components: string[];
+    gates: string[];
+    flows: string[];
+    signals: string[];
+    routes: Record<string, string>;
+}
+/**
+ * Detect symbols from codebase structure.
+ *
+ * @param projectDir - Project root directory
+ * @returns Detected symbols and route mappings
+ */
+declare function detectSymbols(projectDir: string): DetectionResult;
+/**
+ * Generate a .sentinel.yaml config from detected symbols.
+ *
+ * @param projectDir - Project root directory
+ * @returns SentinelYamlConfig ready to write
+ */
+declare function generateConfig(projectDir: string): SentinelYamlConfig;
+
+/**
+ * Paradigm Sentinel - Incident Grouper
+ *
+ * Clusters similar incidents based on symbolic context and error patterns.
+ */
+
+declare class IncidentGrouper {
+    private storage;
+    constructor(storage: SentinelStorage);
+    /**
+     * Try to find or create a group for an incident
+     * Returns the group ID if grouped, null if no suitable group
+     */
+    group(incident: SymbolicIncidentRecord): string | null;
+    /**
+     * Find incidents similar to the given one
+     */
+    findSimilar(incident: SymbolicIncidentRecord, limit?: number): SymbolicIncidentRecord[];
+    /**
+     * Analyze ungrouped incidents and create groups automatically
+     */
+    analyzeAndGroup(options?: {
+        minSize?: number;
+    }): IncidentGroup[];
+    /**
+     * Calculate similarity between two incidents (0-1)
+     */
+    private calculateSimilarity;
+    /**
+     * Calculate string similarity using Levenshtein distance
+     */
+    private stringSimilarity;
+    /**
+     * Levenshtein distance for string comparison
+     */
+    private levenshteinDistance;
+    /**
+     * Check if incident should join existing group
+     */
+    private shouldJoinGroup;
+    /**
+     * Extract symbols common to all incidents
+     */
+    private extractCommonSymbols;
+    /**
+     * Extract common error patterns from incidents
+     */
+    private extractCommonErrorPatterns;
+    private getEarliestTimestamp;
+    private getLatestTimestamp;
+    private getUniqueEnvironments;
+}
+
+/**
+ * Paradigm Sentinel - Timeline Builder
+ *
+ * Builds and renders flow timelines for incidents with flow context.
+ */
+
+declare class TimelineBuilder {
+    /**
+     * Build a timeline from an incident with flow position
+     */
+    build(incident: SymbolicIncidentRecord): FlowTimeline | null;
+    /**
+     * Render timeline as ASCII art
+     */
+    renderAscii(timeline: FlowTimeline): string;
+    /**
+     * Render timeline as structured data (for MCP/JSON output)
+     */
+    renderStructured(timeline: FlowTimeline): object;
+    /**
+     * Infer event type from symbol prefix
+     */
+    private inferEventType;
+    /**
+     * Get icon for event type
+     */
+    private getEventIcon;
+    /**
+     * Get status text for event type
+     */
+    private getEventStatus;
+    /**
+     * Format timestamp for display
+     */
+    private formatTime;
+}
+
+/**
+ * Paradigm Sentinel - Statistics Calculator
+ *
+ * Calculates various statistics and metrics for incidents and patterns.
+ */
+
+declare class StatsCalculator {
+    private storage;
+    constructor(storage: SentinelStorage);
+    /**
+     * Get comprehensive statistics for a time period
+     */
+    getStats(periodDays?: number): SentinelStats;
+    /**
+     * Get health metrics for a specific symbol
+     */
+    getSymbolHealth(symbol: string): SymbolHealth;
+    /**
+     * Get trending issues (symbols with increasing incident rates)
+     */
+    getTrendingIssues(days?: number): {
+        symbol: string;
+        trend: number;
+    }[];
+    /**
+     * Get resolution metrics
+     */
+    getResolutionMetrics(): {
+        avgTimeToResolve: number;
+        resolvedWithPattern: number;
+        resolvedManually: number;
+        totalResolved: number;
+        resolutionRate: number;
+    };
+    /**
+     * Get pattern effectiveness metrics
+     */
+    getPatternEffectiveness(): {
+        patternId: string;
+        name: string;
+        matches: number;
+        resolutions: number;
+        recurrences: number;
+        effectiveness: number;
+    }[];
+    /**
+     * Get incident rate by hour of day
+     */
+    getIncidentsByHour(days?: number): {
+        hour: number;
+        count: number;
+    }[];
+    /**
+     * Get incident rate by environment
+     */
+    getIncidentsByEnvironment(): {
+        environment: string;
+        count: number;
+        percentage: number;
+    }[];
+    /**
+     * Get symbol correlation matrix (which symbols fail together)
+     */
+    getSymbolCorrelation(): {
+        symbol1: string;
+        symbol2: string;
+        correlation: number;
+    }[];
+    /**
+     * Generate a summary dashboard string
+     */
+    generateDashboard(periodDays?: number): string;
+    /**
+     * Helper: Count symbols across incidents
+     */
+    private countSymbols;
+    /**
+     * Helper: Get all symbols from incident
+     */
+    private getSymbolsFromIncident;
+}
+
+/**
+ * Paradigm Sentinel - Context Enricher
+ *
+ * Enriches incidents with symbol metadata from .purpose files and symbol index.
+ */
+
+declare class ContextEnricher {
+    private projectRoot;
+    private symbolCache;
+    private purposeCache;
+    constructor(projectRoot?: string);
+    /**
+     * Enrich an incident with symbol context
+     */
+    enrich(incident: SymbolicIncidentRecord): EnrichedIncident;
+    /**
+     * Get symbol metadata from index or .purpose files
+     */
+    getSymbolContext(symbol: string): SymbolEnrichment;
+    /**
+     * Find symbol in premise index
+     */
+    private findInSymbolIndex;
+    /**
+     * Find symbol in .purpose files
+     */
+    private findInPurposeFiles;
+    /**
+     * Get potential file paths for a symbol
+     */
+    private getSearchPathsForSymbol;
+    /**
+     * Parse a .purpose file
+     */
+    private parsePurposeFile;
+    /**
+     * Clear caches
+     */
+    clearCache(): void;
+    /**
+     * Batch enrich multiple incidents
+     */
+    enrichBatch(incidents: SymbolicIncidentRecord[]): EnrichedIncident[];
+}
+
+/**
+ * Paradigm Sentinel - Pattern Suggester
+ *
+ * Generates pattern suggestions from resolved incidents and incident groups.
+ */
+
+declare class PatternSuggester {
+    private storage;
+    constructor(storage: SentinelStorage);
+    /**
+     * Suggest a pattern from a resolved incident
+     */
+    suggestFromIncident(incident: SymbolicIncidentRecord): Partial<FailurePattern>;
+    /**
+     * Suggest a pattern from an incident group
+     */
+    suggestFromGroup(group: IncidentGroup): Partial<FailurePattern>;
+    /**
+     * Find incidents that could become patterns
+     */
+    findPatternCandidates(minOccurrences?: number): PatternCandidate[];
+    /**
+     * Generate pattern from multiple similar incidents
+     */
+    private suggestFromIncidents;
+    /**
+     * Build symbol criteria for pattern, adding wildcards where appropriate
+     */
+    private buildSymbolCriteria;
+    /**
+     * Extract keywords from error message
+     */
+    private extractErrorKeywords;
+    /**
+     * Extract common error keywords from multiple incidents
+     */
+    private extractCommonErrorKeywords;
+    /**
+     * Extract symbols common to all incidents
+     */
+    private extractCommonSymbols;
+    /**
+     * Extract missing signals common to multiple incidents
+     */
+    private extractCommonMissingSignals;
+    /**
+     * Generate a pattern ID from incident
+     */
+    private generatePatternId;
+    /**
+     * Generate a human-readable pattern name
+     */
+    private generatePatternName;
+    /**
+     * Generate tags from incident
+     */
+    private generateTags;
+    /**
+     * Generate tags from incident group
+     */
+    private generateTagsFromGroup;
+    /**
+     * Generate tags from multiple incidents
+     */
+    private generateTagsFromIncidents;
+    /**
+     * Get symbol signature for grouping
+     */
+    private getSymbolSignature;
+    /**
+     * Check if there's already a pattern matching this incident
+     */
+    private hasMatchingPattern;
+    /**
+     * Infer resolution strategy from incidents
+     */
+    private inferStrategy;
+    /**
+     * Get priority based on occurrence count
+     */
+    private getPriorityFromCount;
+}
+
+/**
+ * Paradigm Sentinel - Pattern Importer
+ *
+ * Validates and imports patterns from JSON files or URLs.
+ */
+
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+declare class PatternImporter {
+    /**
+     * Validate a pattern export file
+     */
+    validate(data: unknown): ValidationResult;
+    /**
+     * Validate a single pattern
+     */
+    validatePattern(pattern: Record<string, unknown>, index: number): {
+        errors: string[];
+        warnings: string[];
+    };
+    /**
+     * Load patterns from a JSON file
+     */
+    loadFromFile(filePath: string): PatternExport;
+    /**
+     * Load patterns from a URL
+     */
+    loadFromUrl(url: string): Promise<PatternExport>;
+    /**
+     * Normalize raw data to PatternExport
+     */
+    private normalizeExport;
+    /**
+     * Normalize a raw pattern object
+     */
+    private normalizePattern;
+    /**
+     * Merge patterns from multiple sources
+     */
+    mergePatterns(...exports: PatternExport[]): PatternExport;
+}
+
+/**
+ * Paradigm Sentinel - Seed Pattern Loader
+ *
+ * Loads built-in patterns from JSON files.
+ */
+
+/**
+ * Load universal patterns that apply to most projects
+ */
+declare function loadUniversalPatterns(): PatternExport;
+/**
+ * Load Paradigm-specific patterns
+ */
+declare function loadParadigmPatterns(): PatternExport;
+/**
+ * Load all seed patterns combined
+ */
+declare function loadAllSeedPatterns(): PatternExport;
+
+export { ContextEnricher, EnrichedIncident, FailurePattern, FlowTimeline, IncidentGroup, IncidentGrouper, PatternCandidate, PatternExport, PatternImporter, PatternSuggester, SentinelStats, SentinelStorage, type SentinelYamlConfig, StatsCalculator, SymbolEnrichment, SymbolHealth, SymbolicIncidentRecord, TimelineBuilder, detectSymbols, generateConfig, loadAllSeedPatterns, loadConfig, loadParadigmPatterns, loadUniversalPatterns, writeConfig };