@a-company/sentinel 0.2.0 → 3.5.0

package/dist/sdk-BTblv--p.d.ts

@@ -0,0 +1,180 @@
+import { S as SentinelStorage } from './storage-BqCJqZat.js';
+import { a as SymbolicIncidentRecord, K as MatcherConfig, X as PatternMatch, e as FailurePattern, a2 as PatternTestResult, ae as SentinelConfig, C as ComponentContext, al as SymbolicContext, u as FlowPosition } from './types-BmVoO1iF.js';
+
+/**
+ * Paradigm Sentinel - Pattern Matching Engine
+ *
+ * Matches incidents against failure patterns using symbolic context,
+ * error text, and missing signals.
+ */
+
+declare class PatternMatcher {
+    private storage;
+    constructor(storage: SentinelStorage);
+    /**
+     * Match an incident against all patterns and return ranked results
+     */
+    match(incident: SymbolicIncidentRecord, config?: Partial<MatcherConfig>): PatternMatch[];
+    /**
+     * Test a pattern against historical incidents
+     */
+    testPattern(pattern: FailurePattern, limit?: number): PatternTestResult;
+    /**
+     * Score how well a pattern matches an incident
+     */
+    private scoreMatch;
+    /**
+     * Match symbols between pattern and incident
+     */
+    private matchSymbols;
+    /**
+     * Match a single symbol value (supports wildcards)
+     */
+    private matchSingleSymbol;
+    /**
+     * Match error text keywords and regex
+     */
+    private matchErrorText;
+    /**
+     * Match missing signals from flow position
+     */
+    private matchMissingSignals;
+    /**
+     * Check if pattern's environment filter matches incident
+     */
+    private matchEnvironment;
+}
+
+/**
+ * Sentinel SDK
+ *
+ * The developer-facing API for capturing errors with symbolic context.
+ * Wraps the core storage and pattern matching engine.
+ *
+ * Usage:
+ *   import { Sentinel } from '@a-company/sentinel';
+ *   const sentinel = new Sentinel({ project: 'my-app' });
+ *   sentinel.capture(new Error('Payment failed'), { component: '#checkout' });
+ */
+
+/**
+ * Flow tracker for monitoring multi-step flows.
+ *
+ * Usage:
+ *   const flow = sentinel.flow('$checkout-flow');
+ *   flow.expect('!payment-authorized', '!order-created');
+ *   flow.gate('^authenticated', true);
+ *   flow.signal('!payment-authorized');
+ *   flow.complete();
+ */
+declare class FlowTracker {
+    private flowId;
+    private sentinel;
+    private actual;
+    private expected;
+    private completed;
+    constructor(flowId: string, sentinel: Sentinel);
+    /** Declare which signals/gates are expected in this flow */
+    expect(...symbols: string[]): this;
+    /** Record a generic step in the flow */
+    step(symbol: string): this;
+    /** Record a gate check result */
+    gate(id: string, passed: boolean): this;
+    /** Record a signal emission */
+    signal(id: string, _data?: object): this;
+    /** Mark the flow as successfully completed */
+    complete(): void;
+    /** Capture an error with full flow position context */
+    fail(error: Error): void;
+}
+/**
+ * The main Sentinel SDK class.
+ *
+ * Usage:
+ *   const sentinel = new Sentinel({ project: 'my-app', environment: 'production' });
+ *
+ *   // Capture errors with symbolic context
+ *   sentinel.capture(error, { component: '#checkout', gate: '^payment-validated' });
+ *
+ *   // Component context for scoped captures
+ *   const ctx = sentinel.component('#checkout');
+ *   ctx.capture(error);
+ *
+ *   // Flow tracking
+ *   const flow = sentinel.flow('$checkout-flow');
+ *   flow.gate('^authenticated', true);
+ *   flow.signal('!payment-authorized');
+ *   flow.complete();
+ */
+declare class Sentinel {
+    private storage;
+    private matcher;
+    private config;
+    private ready;
+    private readyPromise;
+    private seeded;
+    constructor(config: SentinelConfig);
+    /** Explicitly initialize storage. Optional — auto-called on first capture. */
+    init(): Promise<void>;
+    private doInit;
+    private ensureReady;
+    /**
+     * Create a component context for scoped error capture.
+     *
+     * @param id - Component symbol (e.g. '#checkout' or 'checkout')
+     * @returns ComponentContext with capture() and wrap() methods
+     */
+    component(id: string): ComponentContext;
+    /**
+     * Record a gate check result.
+     * If the gate fails, auto-captures an incident.
+     *
+     * @param id - Gate symbol (e.g. '^authenticated' or 'authenticated')
+     * @param passed - Whether the gate passed
+     */
+    gate(id: string, passed: boolean): void;
+    /**
+     * Record a signal emission. Primarily for flow tracking context.
+     *
+     * @param id - Signal symbol (e.g. '!payment-authorized' or 'payment-authorized')
+     */
+    signal(id: string, _data?: object): void;
+    /**
+     * Create a flow tracker for monitoring multi-step operations.
+     *
+     * @param id - Flow symbol (e.g. '$checkout-flow' or 'checkout-flow')
+     * @returns FlowTracker instance
+     */
+    flow(id: string): FlowTracker;
+    /**
+     * Capture an error with symbolic context.
+     *
+     * @param error - The error to capture
+     * @param context - Symbolic context (component, gate, flow, signal)
+     * @param flowPosition - Optional flow position data
+     * @returns Incident ID (e.g. 'INC-001')
+     */
+    capture(error: Error, context?: Partial<SymbolicContext>, flowPosition?: FlowPosition): string;
+    /**
+     * Get pattern matches for a captured incident.
+     *
+     * @param incidentId - The incident ID to match
+     * @returns Array of pattern matches sorted by confidence
+     */
+    match(incidentId: string): PatternMatch[];
+    /**
+     * Create Express error-handling middleware.
+     *
+     * Usage:
+     *   app.use(sentinel.express());
+     */
+    express(): any;
+    /** Close the database connection. Call when shutting down. */
+    close(): void;
+    /** Get the underlying storage instance (for advanced usage). */
+    getStorage(): SentinelStorage;
+    /** Get the underlying pattern matcher (for advanced usage). */
+    getMatcher(): PatternMatcher;
+}
+
+export { FlowTracker as F, PatternMatcher as P, Sentinel as S };

package/dist/server/index.d.ts

@@ -1,4 +1,6 @@
 import { Express } from 'express';
+import { S as SentinelStorage } from '../storage-BqCJqZat.js';
+import { S as SentinelServerConfig, L as LogEntry } from '../types-BmVoO1iF.js';
 
 /**
  * Symbol index loader for the server
@@ -62,20 +64,34 @@ declare function loadGitHistory(projectDir: string, options?: {
 declare function getSymbolsAtCommit(projectDir: string, commitHash: string): Promise<string[]>;
 
 /**
- * Sentinel Server - Express server for the visualizer UI
+ * Sentinel Server - Express server with WebSocket for real-time log streaming
  */
 
 interface ServerOptions {
     port: number;
     projectDir: string;
     open?: boolean;
+    dbPath?: string;
+    logPruneLimit?: number;
 }
 /**
  * Create the Express application with all routes configured
  */
-declare function createApp(options: ServerOptions): Express;
+declare function createApp(options: ServerOptions & {
+    storage?: SentinelStorage;
+    serverConfig?: SentinelServerConfig;
+    symbolIndex?: Array<{
+        symbol: string;
+        type: string;
+        filePath: string;
+    }>;
+    onLogReceived?: (entry: LogEntry, validation?: {
+        known: boolean;
+        suggestion?: string;
+    }) => void;
+}): Express;
 /**
- * Start the Sentinel server
+ * Start the Sentinel server with WebSocket support
  */
 declare function startServer(options: ServerOptions): Promise<void>;