monomind 1.10.56 → 1.11.0

package/packages/@monomind/cli/dist/src/monovector/index.js

@@ -0,0 +1,67 @@
+/**
+ * MonoVector Integration Module for Monomind CLI (lean)
+ *
+ * After the SONA / native / WASM teardown this module provides only the
+ * lightweight surface:
+ * - Capability probing: getCapabilities() — stubbed, always reports JS-only
+ * - Initialization state: createInitState()
+ * - Keyword-based task routing: createKeywordRouter()
+ * - Route recommendation→outcome records: recordRoute(), joinOutcome(), accuracy
+ * - AST diff classification: DiffClassifier
+ *
+ * @module @monomind/cli/monovector
+ */
+import { getCapabilities } from './capabilities.js';
+export { getCapabilities, getCachedCapabilities, resetCapabilitiesCache, refreshCapabilities } from './capabilities.js';
+export { createInitState } from './init-state.js';
+export { recordRoute, joinOutcome, joinLatestUnresolved, readOutcomes, computeRoutingAccuracy, computeAdherence, } from './route-outcomes.js';
+export { DiffClassifier, createDiffClassifier, analyzeDiff, analyzeDiffSync, assessFileRisk, assessOverallRisk, classifyDiff, suggestReviewers, getGitDiffNumstat, getGitDiffNumstatAsync, clearDiffCache, clearAllDiffCaches, } from './diff-classifier.js';
+export function createKeywordRouter(_config) {
+    const agentTypes = ['coder', 'tester', 'reviewer', 'architect', 'researcher', 'optimizer', 'debugger', 'documenter'];
+    return {
+        async route(task) {
+            const lower = task.toLowerCase();
+            let agentType = 'coder';
+            if (lower.includes('test'))
+                agentType = 'tester';
+            else if (lower.includes('review') || lower.includes('security'))
+                agentType = 'reviewer';
+            else if (lower.includes('design') || lower.includes('architect'))
+                agentType = 'architect';
+            else if (lower.includes('research') || lower.includes('analyz'))
+                agentType = 'researcher';
+            else if (lower.includes('optim') || lower.includes('perform'))
+                agentType = 'optimizer';
+            else if (lower.includes('debug') || lower.includes('fix') || lower.includes('bug'))
+                agentType = 'debugger';
+            else if (lower.includes('doc'))
+                agentType = 'documenter';
+            return {
+                agentType,
+                confidence: 0.75,
+                reasoning: 'keyword-based routing',
+                route: agentType,
+                qValues: [],
+                explored: false,
+                alternatives: agentTypes.filter(a => a !== agentType).slice(0, 3).map(a => ({ route: a, score: 0 })),
+            };
+        },
+        async initialize() { },
+        getStats() {
+            return { updateCount: 0, qTableSize: 0, stepCount: 0, epsilon: 0, avgTDError: 0, useNative: 0 };
+        },
+        update() { return 0; },
+        reset() { },
+        export() { return {}; },
+        import() { },
+    };
+}
+/** @deprecated Use (await getCapabilities()).sona */
+export async function isMonovectorAvailable() {
+    return (await getCapabilities()).sona;
+}
+/** @deprecated Use (await getCapabilities()).learningWasm */
+export async function isWasmBackendAvailable() {
+    return (await getCapabilities()).learningWasm;
+}
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/monovector/init-state.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reusable init-state tracker with a counter-with-max pattern.
+ *
+ * - Allows transient failures (returns NOT_READY) without permanently disabling
+ * - Permanently disables after maxAttempts consecutive failures
+ * - Thread-safe for single-threaded JS (no concurrent writes)
+ *
+ * Usage:
+ *   const state = createInitState({ maxAttempts: 3 });
+ *   if (state.canTry()) {
+ *     try { ... state.markReady(); }
+ *     catch { state.markFailed(); }
+ *   }
+ */
+export type InitStatus = 'pending' | 'ready' | 'failed';
+export interface InitState {
+    /** True if another init attempt should be made */
+    canTry(): boolean;
+    /** Mark initialization as permanently successful */
+    markReady(): void;
+    /** Mark this attempt as failed; permanently fails after maxAttempts */
+    markFailed(): void;
+    /** Immediately mark as permanently failed without consuming retry budget */
+    markPermanentlyFailed(): void;
+    /** True if init succeeded */
+    isReady(): boolean;
+    /** True if permanently failed (exhausted retries) */
+    isFailed(): boolean;
+    /** Number of failed attempts so far */
+    attempts(): number;
+}
+export declare function createInitState(opts?: {
+    maxAttempts?: number;
+}): InitState;
+//# sourceMappingURL=init-state.d.ts.map

package/packages/@monomind/cli/dist/src/monovector/init-state.js

@@ -0,0 +1,36 @@
+/**
+ * Reusable init-state tracker with a counter-with-max pattern.
+ *
+ * - Allows transient failures (returns NOT_READY) without permanently disabling
+ * - Permanently disables after maxAttempts consecutive failures
+ * - Thread-safe for single-threaded JS (no concurrent writes)
+ *
+ * Usage:
+ *   const state = createInitState({ maxAttempts: 3 });
+ *   if (state.canTry()) {
+ *     try { ... state.markReady(); }
+ *     catch { state.markFailed(); }
+ *   }
+ */
+export function createInitState(opts = {}) {
+    const max = opts.maxAttempts ?? 3;
+    let status = 'pending';
+    let count = 0;
+    return {
+        canTry() { return status === 'pending' && count < max; },
+        markReady() { status = 'ready'; },
+        markFailed() {
+            count++;
+            if (count >= max)
+                status = 'failed';
+        },
+        markPermanentlyFailed() {
+            count = max;
+            status = 'failed';
+        },
+        isReady() { return status === 'ready'; },
+        isFailed() { return status === 'failed'; },
+        attempts() { return count; },
+    };
+}
+//# sourceMappingURL=init-state.js.map

package/packages/@monomind/cli/dist/src/monovector/route-outcomes.d.ts

@@ -0,0 +1,55 @@
+export interface RouteOutcomeRecord {
+    routeId: string;
+    ts: number;
+    task: string;
+    recommendedAgent: string;
+    routingMethod: string;
+    confidence: number;
+    learningMode: 'native' | 'js';
+    agentActuallyUsed?: string;
+    measuredSuccess?: boolean;
+    quality?: number;
+}
+/** Append a route recommendation (pre-outcome). */
+export declare function recordRoute(baseDir: string, rec: RouteOutcomeRecord): Promise<void>;
+/** Join outcome data onto the most recent matching route record by routeId. */
+export declare function joinOutcome(baseDir: string, routeId: string, outcome: {
+    agentActuallyUsed?: string;
+    measuredSuccess?: boolean;
+    quality?: number;
+}): Promise<void>;
+/**
+ * Join an outcome to the most recent route record that has no measured outcome yet.
+ * Used when the caller does not thread an explicit routeId — auto-correlates the
+ * latest recommendation to the next task completion. Returns the joined routeId or null.
+ */
+export declare function joinLatestUnresolved(baseDir: string, outcome: {
+    agentActuallyUsed?: string;
+    measuredSuccess?: boolean;
+    quality?: number;
+}, maxAgeMs?: number): Promise<string | null>;
+/** Read all outcome records (for metrics). */
+export declare function readOutcomes(baseDir: string): Promise<RouteOutcomeRecord[]>;
+export interface RoutingAccuracy {
+    window: number;
+    totalWithOutcome: number;
+    accuracy: number | null;
+    byMode: {
+        native: number | null;
+        js: number | null;
+    };
+    recentVsPrior: number | null;
+}
+/**
+ * Compute routing accuracy over the most recent N records that have a joined outcome.
+ * accuracy = fraction of records whose joined outcome reports measuredSuccess === true.
+ * (agentActuallyUsed is recorded per row but not required to match the recommendation;
+ * the success label already reflects whether the chosen routing worked out.)
+ */
+export declare function computeRoutingAccuracy(baseDir: string, window?: number): Promise<RoutingAccuracy>;
+/** Fraction of joined routes where the agent actually used matched the recommendation. */
+export declare function computeAdherence(baseDir: string, window?: number): Promise<{
+    adherence: number | null;
+    sample: number;
+}>;
+//# sourceMappingURL=route-outcomes.d.ts.map

package/packages/@monomind/cli/dist/src/monovector/route-outcomes.js

@@ -0,0 +1,137 @@
+/**
+ * Per-route outcome records — the join between a routing recommendation and
+ * what actually happened. This is the foundation for routing-accuracy metrics
+ * and for giving SONA a real training label.
+ */
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+function storePath(baseDir) {
+    return join(baseDir, 'route-outcomes.jsonl');
+}
+/** Append a route recommendation (pre-outcome). */
+export async function recordRoute(baseDir, rec) {
+    try {
+        await fs.mkdir(baseDir, { recursive: true });
+        await fs.appendFile(storePath(baseDir), JSON.stringify(rec) + '\n', 'utf8');
+    }
+    catch {
+        // Non-fatal — telemetry must never break routing
+    }
+}
+/** Join outcome data onto the most recent matching route record by routeId. */
+export async function joinOutcome(baseDir, routeId, outcome) {
+    try {
+        const path = storePath(baseDir);
+        const content = await fs.readFile(path, 'utf8').catch(() => '');
+        if (!content)
+            return;
+        const lines = content.trim().split('\n');
+        // Find the last record with this routeId and merge outcome
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const rec = JSON.parse(lines[i]);
+                if (rec.routeId === routeId) {
+                    lines[i] = JSON.stringify({ ...rec, ...outcome });
+                    break;
+                }
+            }
+            catch { /* skip malformed line */ }
+        }
+        await fs.writeFile(path, lines.join('\n') + '\n', 'utf8');
+    }
+    catch {
+        // Non-fatal
+    }
+}
+/**
+ * Join an outcome to the most recent route record that has no measured outcome yet.
+ * Used when the caller does not thread an explicit routeId — auto-correlates the
+ * latest recommendation to the next task completion. Returns the joined routeId or null.
+ */
+export async function joinLatestUnresolved(baseDir, outcome, maxAgeMs = 600_000 // only correlate within 10 minutes to avoid stale joins
+) {
+    try {
+        const path = storePath(baseDir);
+        const content = await fs.readFile(path, 'utf8').catch(() => '');
+        if (!content)
+            return null;
+        const lines = content.trim().split('\n');
+        const now = Date.now();
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const rec = JSON.parse(lines[i]);
+                // Skip already-joined records
+                if (typeof rec.measuredSuccess === 'boolean')
+                    continue;
+                // Skip stale records beyond the correlation window
+                if (now - rec.ts > maxAgeMs)
+                    return null;
+                lines[i] = JSON.stringify({ ...rec, ...outcome });
+                await fs.writeFile(path, lines.join('\n') + '\n', 'utf8');
+                return rec.routeId;
+            }
+            catch { /* skip malformed */ }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Read all outcome records (for metrics). */
+export async function readOutcomes(baseDir) {
+    try {
+        const content = await fs.readFile(storePath(baseDir), 'utf8').catch(() => '');
+        if (!content)
+            return [];
+        return content.trim().split('\n').map(l => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        }).filter((r) => r !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Compute routing accuracy over the most recent N records that have a joined outcome.
+ * accuracy = fraction of records whose joined outcome reports measuredSuccess === true.
+ * (agentActuallyUsed is recorded per row but not required to match the recommendation;
+ * the success label already reflects whether the chosen routing worked out.)
+ */
+export async function computeRoutingAccuracy(baseDir, window = 100) {
+    const all = await readOutcomes(baseDir);
+    // Only records with a measured outcome count
+    const withOutcome = all.filter(r => typeof r.measuredSuccess === 'boolean').slice(-window);
+    const n = withOutcome.length;
+    if (n === 0) {
+        return { window, totalWithOutcome: 0, accuracy: null, byMode: { native: null, js: null }, recentVsPrior: null };
+    }
+    const succ = (recs) => recs.length ? recs.filter(r => r.measuredSuccess).length / recs.length : null;
+    const native = withOutcome.filter(r => r.learningMode === 'native');
+    const js = withOutcome.filter(r => r.learningMode === 'js');
+    const mid = Math.floor(n / 2);
+    const prior = succ(withOutcome.slice(0, mid));
+    const recent = succ(withOutcome.slice(mid));
+    return {
+        window,
+        totalWithOutcome: n,
+        accuracy: succ(withOutcome),
+        byMode: { native: succ(native), js: succ(js) },
+        recentVsPrior: (recent !== null && prior !== null) ? recent - prior : null,
+    };
+}
+/** Fraction of joined routes where the agent actually used matched the recommendation. */
+export async function computeAdherence(baseDir, window = 100) {
+    const all = await readOutcomes(baseDir);
+    const joined = all.filter(r => r.agentActuallyUsed && r.recommendedAgent).slice(-window);
+    if (joined.length === 0)
+        return { adherence: null, sample: 0 };
+    const matches = joined.filter(r => r.agentActuallyUsed === r.recommendedAgent).length;
+    return { adherence: matches / joined.length, sample: joined.length };
+}
+//# sourceMappingURL=route-outcomes.js.map

package/packages/@monomind/cli/dist/src/parser.js

@@ -61,10 +61,10 @@ export class CommandParser {
                 choices: ['text', 'json', 'table']
             },
             {
-                name: 'no-color',
-                description: 'Disable colored output',
+                name: 'color',
+                description: 'Enable colored output (use --no-color to disable)',
                 type: 'boolean',
-                default: false
+                default: true
             },
             {
                 name: 'interactive',

package/packages/@monomind/cli/dist/src/plugins/store/discovery.js

@@ -204,7 +204,6 @@ export class PluginDiscoveryService {
             newest: ['@monomind/plugin-agentic-qe', '@monomind/plugin-prime-radiant'],
             official: ['@monomind/plugin-agentic-qe', '@monomind/plugin-prime-radiant', '@monomind/security', '@monomind/claims'],
             compatibilityMatrix: [
-                { pluginId: '@monomind/neural', pluginVersion: '3.0.0', monomindVersions: ['3.x'], tested: true },
                 { pluginId: '@monomind/security', pluginVersion: '3.0.0', monomindVersions: ['3.x'], tested: true },
             ],
         };
@@ -243,35 +242,6 @@ export class PluginDiscoveryService {
             reputation: 85,
         };
         return [
-            {
-                id: '@monomind/neural',
-                name: '@monomind/neural',
-                displayName: 'Neural Patterns',
-                description: 'Neural pattern training and inference with WASM SIMD acceleration, MoE routing, and Flash Attention optimization',
-                version: '3.0.0',
-                cid: 'bafybeineuralpatternplugin',
-                size: 245000,
-                checksum: 'sha256:abc123neural',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['ai-ml'],
-                tags: ['neural', 'training', 'inference', 'wasm', 'simd'],
-                keywords: ['neural', 'patterns', 'ml'],
-                downloads: 15000,
-                rating: 4.9,
-                ratingCount: 245,
-                lastUpdated: baseTime,
-                createdAt: '2024-01-01T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [{ name: '@monomind/core', version: '^3.0.0' }],
-                type: 'core',
-                hooks: ['neural:train', 'neural:inference', 'pattern:learn'],
-                commands: ['neural train', 'neural predict', 'neural patterns'],
-                permissions: ['memory', 'network'],
-                exports: ['NeuralTrainer', 'PatternRecognizer', 'FlashAttention'],
-                verified: true,
-                trustLevel: 'official',
-            },
             {
                 id: '@monomind/security',
                 name: '@monomind/security',
@@ -743,7 +713,6 @@ export class PluginDiscoveryService {
             '@monomind/security',
             '@monomind/plugins',
             '@monomind/embeddings',
-            '@monomind/neural',
             '@monomind/performance',
             '@monomind/teammate-plugin',
             // Gas Town Bridge

package/packages/@monomind/cli/dist/src/production/circuit-breaker.d.ts

@@ -6,20 +6,40 @@
  * - Open: Failing fast, not calling service
  * - Half-Open: Testing if service recovered
  *
- * @module @monoes/cli/production/circuit-breaker
+ * @module @monomind/cli/production/circuit-breaker
+ */
+/**
+ * Circuit breaker states.
+ * - `closed`: Normal operation, requests pass through.
+ * - `open`: Failing fast, requests are rejected immediately.
+ * - `half-open`: Testing recovery, a percentage of requests pass through.
  */
 export type CircuitState = 'closed' | 'open' | 'half-open';
+/**
+ * Circuit breaker configuration options.
+ */
 export interface CircuitBreakerConfig {
+    /** Number of failures within the window before opening the circuit. */
     failureThreshold: number;
+    /** Time (ms) to wait in the open state before transitioning to half-open. */
     resetTimeoutMs: number;
+    /** Number of consecutive successes in half-open before closing. */
     successThreshold: number;
+    /** Sliding window (ms) over which failures are counted. */
     failureWindowMs: number;
+    /** Fraction of requests (0-1) allowed through while half-open. */
     halfOpenRequestPercentage: number;
-    onStateChange?: (from: CircuitState, to: CircuitState) => void;
-    onOpen?: (failures: number) => void;
+    /** Called when the circuit transitions to the open state. */
+    onOpen?: (failureCount: number) => void;
+    /** Called when the circuit transitions to the closed state. */
     onClose?: () => void;
+    /** Called on any state transition. */
+    onStateChange?: (oldState: CircuitState, newState: CircuitState) => void;
 }
-export interface CircuitStats {
+/**
+ * Snapshot of circuit breaker statistics.
+ */
+export interface CircuitBreakerStats {
     state: CircuitState;
     failures: number;
     successes: number;
@@ -77,7 +97,7 @@ export declare class CircuitBreaker {
     /**
      * Get circuit statistics
      */
-    getStats(): CircuitStats;
+    getStats(): CircuitBreakerStats;
     /**
      * Get failure rate
      */
@@ -92,7 +112,7 @@ export declare function getCircuitBreaker(name: string, config?: Partial<Circuit
 /**
  * Get all circuit breaker stats
  */
-export declare function getAllCircuitStats(): Record<string, CircuitStats>;
+export declare function getAllCircuitStats(): Record<string, CircuitBreakerStats>;
 /**
  * Reset all circuit breakers
  */

package/packages/@monomind/cli/dist/src/production/error-handler.d.ts

@@ -9,36 +9,66 @@
  *
  * @module @monomind/cli/production/error-handler
  */
-export interface ErrorContext {
-    operation: string;
-    tool?: string;
-    input?: Record<string, unknown>;
-    userId?: string;
-    agentId?: string;
-    requestId?: string;
-    timestamp: string;
-}
+/**
+ * Error category derived from message-pattern classification.
+ */
+export type ErrorCategory = 'validation' | 'authentication' | 'authorization' | 'not_found' | 'rate_limit' | 'timeout' | 'circuit_open' | 'external_service' | 'internal' | 'unknown';
+/**
+ * Configuration for the {@link ErrorHandler}.
+ */
 export interface ErrorHandlerConfig {
+    /** Include stack traces in structured errors (default: off in production). */
     includeStack: boolean;
+    /** Redact sensitive keys/values from context and messages. */
     sanitize: boolean;
+    /** Whether errors should be forwarded to monitoring. */
     reportToMonitoring: boolean;
+    /** Per-category cap before responses are rate-limited. */
     maxErrorsPerMinute: number;
-    errorCategories: Record<string, string[]>;
+    /** Optional per-category overrides. */
+    errorCategories: Record<string, unknown>;
 }
-export type ErrorCategory = 'validation' | 'authentication' | 'authorization' | 'not_found' | 'rate_limit' | 'timeout' | 'circuit_open' | 'external_service' | 'internal' | 'unknown';
+/**
+ * Contextual metadata attached to a handled error.
+ */
+export interface ErrorContext {
+    /** The input that triggered the error (sanitized when handled). */
+    input?: unknown;
+    /** Arbitrary additional context fields. */
+    [key: string]: unknown;
+}
+/**
+ * The error payload embedded in a structured error response.
+ */
+export interface StructuredErrorPayload {
+    code: string;
+    message: string;
+    category: ErrorCategory;
+    retryable: boolean;
+    retryAfterMs?: number;
+    details?: {
+        stack: string;
+    };
+}
+/**
+ * A standardized, structured error response.
+ */
 export interface StructuredError {
     success: false;
-    error: {
-        code: string;
-        message: string;
-        category: ErrorCategory;
-        retryable: boolean;
-        retryAfterMs?: number;
-        details?: Record<string, unknown>;
-    };
-    context?: Partial<ErrorContext>;
+    error: StructuredErrorPayload;
+    context: ErrorContext;
     timestamp: string;
 }
+/**
+ * Aggregated error statistics returned by {@link ErrorHandler.getStats}.
+ */
+export interface ErrorStats {
+    totalErrors: number;
+    byCategory: Record<string, number>;
+    recentErrors: StructuredError[];
+    /** Errors per minute over the last 5 minutes. */
+    errorRate: number;
+}
 export declare class ErrorHandler {
     private config;
     private errorCounts;
@@ -58,24 +88,19 @@ export declare class ErrorHandler {
      * Cycle-safe and depth-bounded — circular references and deeply nested objects
      * will not cause stack overflow.
      */
-    sanitize(input: Record<string, unknown>, _seen?: WeakSet<object>, _depth?: number): Record<string, unknown>;
+    sanitize(input: unknown, _seen?: WeakSet<object>, _depth?: number): unknown;
     /**
      * Handle an error and return a structured response
      */
-    handle(error: Error | string, context?: Partial<ErrorContext>): StructuredError;
+    handle(error: Error | string, context?: ErrorContext): StructuredError;
     /**
      * Wrap a handler with error handling
      */
-    wrap<T extends (...args: unknown[]) => Promise<unknown>>(handler: T, context: Partial<ErrorContext>): T;
+    wrap<TArgs extends unknown[], TResult>(handler: (...args: TArgs) => Promise<TResult>, context?: ErrorContext): (...args: TArgs) => Promise<TResult | StructuredError>;
     /**
      * Get error statistics
      */
-    getStats(): {
-        totalErrors: number;
-        byCategory: Record<string, number>;
-        recentErrors: StructuredError[];
-        errorRate: number;
-    };
+    getStats(): ErrorStats;
     /**
      * Clear error log
      */
@@ -89,6 +114,6 @@ export declare class ErrorHandler {
 /**
  * Wrap a handler with error handling (convenience function)
  */
-export declare function withErrorHandling<T extends (...args: unknown[]) => Promise<unknown>>(handler: T, context?: Partial<ErrorContext>): T;
+export declare function withErrorHandling<TArgs extends unknown[], TResult>(handler: (...args: TArgs) => Promise<TResult>, context?: ErrorContext): (...args: TArgs) => Promise<TResult | StructuredError>;
 export default ErrorHandler;
 //# sourceMappingURL=error-handler.d.ts.map

package/packages/@monomind/cli/dist/src/production/index.d.ts

@@ -1,23 +1,6 @@
-/**
- * V1 Production Hardening Module
- *
- * Provides production-grade utilities:
- * - Error handling middleware
- * - Rate limiting
- * - Retry mechanisms with exponential backoff
- * - Circuit breaker pattern
- * - Monitoring and observability hooks
- *
- * @module @monoes/cli/production
- */
 export { ErrorHandler, withErrorHandling } from './error-handler.js';
-export type { ErrorContext, ErrorHandlerConfig } from './error-handler.js';
 export { RateLimiter, createRateLimiter } from './rate-limiter.js';
-export type { RateLimiterConfig, RateLimitResult } from './rate-limiter.js';
-export { withRetry } from './retry.js';
-export type { RetryConfig, RetryResult, RetryStrategy } from './retry.js';
-export { CircuitBreaker } from './circuit-breaker.js';
-export type { CircuitBreakerConfig, CircuitState } from './circuit-breaker.js';
-export { MonitoringHooks, createMonitor } from './monitoring.js';
-export type { MonitorConfig, MetricEvent } from './monitoring.js';
+export { withRetry, makeRetryable, Retryable } from './retry.js';
+export { CircuitBreaker, getCircuitBreaker, getAllCircuitStats, resetAllCircuits } from './circuit-breaker.js';
+export { MonitoringHooks, createMonitor, getMonitor } from './monitoring.js';
 //# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/production/index.js

@@ -1,18 +1,6 @@
-/**
- * V1 Production Hardening Module
- *
- * Provides production-grade utilities:
- * - Error handling middleware
- * - Rate limiting
- * - Retry mechanisms with exponential backoff
- * - Circuit breaker pattern
- * - Monitoring and observability hooks
- *
- * @module @monoes/cli/production
- */
 export { ErrorHandler, withErrorHandling } from './error-handler.js';
 export { RateLimiter, createRateLimiter } from './rate-limiter.js';
-export { withRetry } from './retry.js';
-export { CircuitBreaker } from './circuit-breaker.js';
-export { MonitoringHooks, createMonitor } from './monitoring.js';
+export { withRetry, makeRetryable, Retryable } from './retry.js';
+export { CircuitBreaker, getCircuitBreaker, getAllCircuitStats, resetAllCircuits } from './circuit-breaker.js';
+export { MonitoringHooks, createMonitor, getMonitor } from './monitoring.js';
 //# sourceMappingURL=index.js.map