@objectstack/spec 0.9.1 → 0.9.2

package/dist/ai/runtime-ops.zod.js

@@ -0,0 +1,578 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIOpsAgentConfigSchema = exports.PerformanceOptimizationSchema = exports.RootCauseAnalysisResultSchema = exports.RootCauseAnalysisRequestSchema = exports.AutoScalingPolicySchema = exports.SelfHealingConfigSchema = exports.SelfHealingActionSchema = exports.AnomalyDetectionConfigSchema = void 0;
+const zod_1 = require("zod");
+const plugin_lifecycle_advanced_zod_1 = require("../system/plugin-lifecycle-advanced.zod");
+/**
+ * # Runtime AI Operations (AIOps) Protocol
+ *
+ * Defines protocols for AI-powered runtime operations including:
+ * - Self-healing and automatic recovery
+ * - Intelligent auto-scaling
+ * - Anomaly detection and prediction
+ * - Performance optimization
+ * - Root cause analysis
+ */
+/**
+ * Anomaly Detection Configuration
+ * Configuration for detecting anomalies in plugin behavior
+ */
+exports.AnomalyDetectionConfigSchema = zod_1.z.object({
+    /**
+     * Enable anomaly detection
+     */
+    enabled: zod_1.z.boolean().default(true),
+    /**
+     * Metrics to monitor
+     */
+    metrics: zod_1.z.array(zod_1.z.enum([
+        'cpu-usage',
+        'memory-usage',
+        'response-time',
+        'error-rate',
+        'throughput',
+        'latency',
+        'connection-count',
+        'queue-depth',
+    ])),
+    /**
+     * Detection algorithm
+     */
+    algorithm: zod_1.z.enum([
+        'statistical', // Statistical thresholds
+        'machine-learning', // ML-based detection
+        'heuristic', // Rule-based heuristics
+        'hybrid', // Combination of methods
+    ]).default('hybrid'),
+    /**
+     * Sensitivity level
+     */
+    sensitivity: zod_1.z.enum(['low', 'medium', 'high']).default('medium')
+        .describe('How aggressively to detect anomalies'),
+    /**
+     * Time window for analysis (seconds)
+     */
+    timeWindow: zod_1.z.number().int().min(60).default(300)
+        .describe('Historical data window for anomaly detection'),
+    /**
+     * Confidence threshold (0-100)
+     */
+    confidenceThreshold: zod_1.z.number().min(0).max(100).default(80)
+        .describe('Minimum confidence to flag as anomaly'),
+    /**
+     * Alert on detection
+     */
+    alertOnDetection: zod_1.z.boolean().default(true),
+});
+/**
+ * Self-Healing Action
+ * Defines an automated recovery action
+ */
+exports.SelfHealingActionSchema = zod_1.z.object({
+    /**
+     * Action identifier
+     */
+    id: zod_1.z.string(),
+    /**
+     * Action type
+     */
+    type: zod_1.z.enum([
+        'restart', // Restart the plugin
+        'scale', // Scale resources
+        'rollback', // Rollback to previous version
+        'clear-cache', // Clear caches
+        'adjust-config', // Adjust configuration
+        'execute-script', // Run custom script
+        'notify', // Notify administrators
+    ]),
+    /**
+     * Trigger condition
+     */
+    trigger: zod_1.z.object({
+        /**
+         * Health status that triggers this action
+         */
+        healthStatus: zod_1.z.array(plugin_lifecycle_advanced_zod_1.PluginHealthStatusSchema).optional(),
+        /**
+         * Anomaly types that trigger this action
+         */
+        anomalyTypes: zod_1.z.array(zod_1.z.string()).optional(),
+        /**
+         * Error patterns that trigger this action
+         */
+        errorPatterns: zod_1.z.array(zod_1.z.string()).optional(),
+        /**
+         * Custom condition expression
+         */
+        customCondition: zod_1.z.string().optional()
+            .describe('Custom trigger condition (e.g., "errorRate > 0.1")'),
+    }),
+    /**
+     * Action parameters
+     */
+    parameters: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    /**
+     * Maximum number of attempts
+     */
+    maxAttempts: zod_1.z.number().int().min(1).default(3),
+    /**
+     * Cooldown period between attempts (seconds)
+     */
+    cooldown: zod_1.z.number().int().min(0).default(60),
+    /**
+     * Timeout for action execution (seconds)
+     */
+    timeout: zod_1.z.number().int().min(1).default(300),
+    /**
+     * Require manual approval
+     */
+    requireApproval: zod_1.z.boolean().default(false),
+    /**
+     * Priority
+     */
+    priority: zod_1.z.number().int().min(1).default(5)
+        .describe('Action priority (lower number = higher priority)'),
+});
+/**
+ * Self-Healing Configuration
+ * Complete configuration for self-healing capabilities
+ */
+exports.SelfHealingConfigSchema = zod_1.z.object({
+    /**
+     * Enable self-healing
+     */
+    enabled: zod_1.z.boolean().default(true),
+    /**
+     * Healing strategy
+     */
+    strategy: zod_1.z.enum([
+        'conservative', // Only safe, proven actions
+        'moderate', // Balanced approach
+        'aggressive', // Try more recovery options
+    ]).default('moderate'),
+    /**
+     * Recovery actions
+     */
+    actions: zod_1.z.array(exports.SelfHealingActionSchema),
+    /**
+     * Anomaly detection
+     */
+    anomalyDetection: exports.AnomalyDetectionConfigSchema.optional(),
+    /**
+     * Maximum concurrent healing operations
+     */
+    maxConcurrentHealing: zod_1.z.number().int().min(1).default(1)
+        .describe('Maximum number of simultaneous healing attempts'),
+    /**
+     * Learning mode
+     */
+    learning: zod_1.z.object({
+        enabled: zod_1.z.boolean().default(true)
+            .describe('Learn from successful/failed healing attempts'),
+        feedbackLoop: zod_1.z.boolean().default(true)
+            .describe('Adjust strategy based on outcomes'),
+    }).optional(),
+});
+/**
+ * Auto-Scaling Policy
+ * Defines how to automatically scale plugin resources
+ */
+exports.AutoScalingPolicySchema = zod_1.z.object({
+    /**
+     * Enable auto-scaling
+     */
+    enabled: zod_1.z.boolean().default(false),
+    /**
+     * Scaling metric
+     */
+    metric: zod_1.z.enum([
+        'cpu-usage',
+        'memory-usage',
+        'request-rate',
+        'response-time',
+        'queue-depth',
+        'custom',
+    ]),
+    /**
+     * Custom metric query (when metric is "custom")
+     */
+    customMetric: zod_1.z.string().optional(),
+    /**
+     * Target value for the metric
+     */
+    targetValue: zod_1.z.number()
+        .describe('Desired metric value (e.g., 70 for 70% CPU)'),
+    /**
+     * Scaling bounds
+     */
+    bounds: zod_1.z.object({
+        /**
+         * Minimum instances
+         */
+        minInstances: zod_1.z.number().int().min(1).default(1),
+        /**
+         * Maximum instances
+         */
+        maxInstances: zod_1.z.number().int().min(1).default(10),
+        /**
+         * Minimum resources per instance
+         */
+        minResources: zod_1.z.object({
+            cpu: zod_1.z.string().optional().describe('CPU limit (e.g., "0.5", "1")'),
+            memory: zod_1.z.string().optional().describe('Memory limit (e.g., "512Mi", "1Gi")'),
+        }).optional(),
+        /**
+         * Maximum resources per instance
+         */
+        maxResources: zod_1.z.object({
+            cpu: zod_1.z.string().optional(),
+            memory: zod_1.z.string().optional(),
+        }).optional(),
+    }),
+    /**
+     * Scale up behavior
+     */
+    scaleUp: zod_1.z.object({
+        /**
+         * Threshold to trigger scale up
+         */
+        threshold: zod_1.z.number()
+            .describe('Metric value that triggers scale up'),
+        /**
+         * Stabilization window (seconds)
+         */
+        stabilizationWindow: zod_1.z.number().int().min(0).default(60)
+            .describe('How long metric must exceed threshold'),
+        /**
+         * Cooldown period (seconds)
+         */
+        cooldown: zod_1.z.number().int().min(0).default(300)
+            .describe('Minimum time between scale-up operations'),
+        /**
+         * Step size
+         */
+        stepSize: zod_1.z.number().int().min(1).default(1)
+            .describe('Number of instances to add'),
+    }),
+    /**
+     * Scale down behavior
+     */
+    scaleDown: zod_1.z.object({
+        /**
+         * Threshold to trigger scale down
+         */
+        threshold: zod_1.z.number()
+            .describe('Metric value that triggers scale down'),
+        /**
+         * Stabilization window (seconds)
+         */
+        stabilizationWindow: zod_1.z.number().int().min(0).default(300)
+            .describe('How long metric must be below threshold'),
+        /**
+         * Cooldown period (seconds)
+         */
+        cooldown: zod_1.z.number().int().min(0).default(600)
+            .describe('Minimum time between scale-down operations'),
+        /**
+         * Step size
+         */
+        stepSize: zod_1.z.number().int().min(1).default(1)
+            .describe('Number of instances to remove'),
+    }),
+    /**
+     * Predictive scaling
+     */
+    predictive: zod_1.z.object({
+        enabled: zod_1.z.boolean().default(false)
+            .describe('Use ML to predict future load'),
+        lookAhead: zod_1.z.number().int().min(60).default(300)
+            .describe('How far ahead to predict (seconds)'),
+        confidence: zod_1.z.number().min(0).max(100).default(80)
+            .describe('Minimum confidence for prediction-based scaling'),
+    }).optional(),
+});
+/**
+ * Root Cause Analysis Request
+ * Request for AI to analyze root cause of issues
+ */
+exports.RootCauseAnalysisRequestSchema = zod_1.z.object({
+    /**
+     * Incident identifier
+     */
+    incidentId: zod_1.z.string(),
+    /**
+     * Plugin identifier
+     */
+    pluginId: zod_1.z.string(),
+    /**
+     * Symptoms observed
+     */
+    symptoms: zod_1.z.array(zod_1.z.object({
+        type: zod_1.z.string().describe('Symptom type'),
+        description: zod_1.z.string(),
+        severity: zod_1.z.enum(['low', 'medium', 'high', 'critical']),
+        timestamp: zod_1.z.string().datetime(),
+    })),
+    /**
+     * Time range for analysis
+     */
+    timeRange: zod_1.z.object({
+        start: zod_1.z.string().datetime(),
+        end: zod_1.z.string().datetime(),
+    }),
+    /**
+     * Include log analysis
+     */
+    analyzeLogs: zod_1.z.boolean().default(true),
+    /**
+     * Include metric analysis
+     */
+    analyzeMetrics: zod_1.z.boolean().default(true),
+    /**
+     * Include dependency analysis
+     */
+    analyzeDependencies: zod_1.z.boolean().default(true),
+    /**
+     * Context information
+     */
+    context: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+});
+/**
+ * Root Cause Analysis Result
+ * Result of root cause analysis
+ */
+exports.RootCauseAnalysisResultSchema = zod_1.z.object({
+    /**
+     * Analysis identifier
+     */
+    analysisId: zod_1.z.string(),
+    /**
+     * Incident identifier
+     */
+    incidentId: zod_1.z.string(),
+    /**
+     * Identified root causes
+     */
+    rootCauses: zod_1.z.array(zod_1.z.object({
+        /**
+         * Cause identifier
+         */
+        id: zod_1.z.string(),
+        /**
+         * Description
+         */
+        description: zod_1.z.string(),
+        /**
+         * Confidence score (0-100)
+         */
+        confidence: zod_1.z.number().min(0).max(100),
+        /**
+         * Category
+         */
+        category: zod_1.z.enum([
+            'code-defect',
+            'configuration',
+            'resource-exhaustion',
+            'dependency-failure',
+            'network-issue',
+            'data-corruption',
+            'security-breach',
+            'other',
+        ]),
+        /**
+         * Evidence
+         */
+        evidence: zod_1.z.array(zod_1.z.object({
+            type: zod_1.z.enum(['log', 'metric', 'trace', 'event']),
+            content: zod_1.z.string(),
+            timestamp: zod_1.z.string().datetime().optional(),
+        })),
+        /**
+         * Impact assessment
+         */
+        impact: zod_1.z.enum(['low', 'medium', 'high', 'critical']),
+        /**
+         * Recommended actions
+         */
+        recommendations: zod_1.z.array(zod_1.z.string()),
+    })),
+    /**
+     * Contributing factors
+     */
+    contributingFactors: zod_1.z.array(zod_1.z.object({
+        description: zod_1.z.string(),
+        confidence: zod_1.z.number().min(0).max(100),
+    })).optional(),
+    /**
+     * Timeline of events
+     */
+    timeline: zod_1.z.array(zod_1.z.object({
+        timestamp: zod_1.z.string().datetime(),
+        event: zod_1.z.string(),
+        significance: zod_1.z.enum(['low', 'medium', 'high']),
+    })).optional(),
+    /**
+     * Remediation plan
+     */
+    remediation: zod_1.z.object({
+        /**
+         * Immediate actions
+         */
+        immediate: zod_1.z.array(zod_1.z.string()),
+        /**
+         * Short-term fixes
+         */
+        shortTerm: zod_1.z.array(zod_1.z.string()),
+        /**
+         * Long-term improvements
+         */
+        longTerm: zod_1.z.array(zod_1.z.string()),
+    }).optional(),
+    /**
+     * Overall confidence in analysis
+     */
+    overallConfidence: zod_1.z.number().min(0).max(100),
+    /**
+     * Analysis timestamp
+     */
+    timestamp: zod_1.z.string().datetime(),
+});
+/**
+ * Performance Optimization Suggestion
+ * AI-generated performance optimization suggestion
+ */
+exports.PerformanceOptimizationSchema = zod_1.z.object({
+    /**
+     * Optimization identifier
+     */
+    id: zod_1.z.string(),
+    /**
+     * Plugin identifier
+     */
+    pluginId: zod_1.z.string(),
+    /**
+     * Optimization type
+     */
+    type: zod_1.z.enum([
+        'caching',
+        'query-optimization',
+        'resource-allocation',
+        'code-refactoring',
+        'architecture-change',
+        'configuration-tuning',
+    ]),
+    /**
+     * Description
+     */
+    description: zod_1.z.string(),
+    /**
+     * Expected impact
+     */
+    expectedImpact: zod_1.z.object({
+        /**
+         * Performance improvement percentage
+         */
+        performanceGain: zod_1.z.number().min(0).max(100)
+            .describe('Expected performance improvement (%)'),
+        /**
+         * Resource savings
+         */
+        resourceSavings: zod_1.z.object({
+            cpu: zod_1.z.number().optional().describe('CPU reduction (%)'),
+            memory: zod_1.z.number().optional().describe('Memory reduction (%)'),
+            network: zod_1.z.number().optional().describe('Network reduction (%)'),
+        }).optional(),
+        /**
+         * Cost reduction
+         */
+        costReduction: zod_1.z.number().optional()
+            .describe('Estimated cost reduction (%)'),
+    }),
+    /**
+     * Implementation difficulty
+     */
+    difficulty: zod_1.z.enum(['trivial', 'easy', 'moderate', 'complex', 'very-complex']),
+    /**
+     * Implementation steps
+     */
+    steps: zod_1.z.array(zod_1.z.string()),
+    /**
+     * Risks and considerations
+     */
+    risks: zod_1.z.array(zod_1.z.string()).optional(),
+    /**
+     * Confidence score
+     */
+    confidence: zod_1.z.number().min(0).max(100),
+    /**
+     * Priority
+     */
+    priority: zod_1.z.enum(['low', 'medium', 'high', 'critical']),
+});
+/**
+ * AIOps Agent Configuration
+ * Configuration for AI operations agent
+ */
+exports.AIOpsAgentConfigSchema = zod_1.z.object({
+    /**
+     * Agent identifier
+     */
+    agentId: zod_1.z.string(),
+    /**
+     * Plugin identifier
+     */
+    pluginId: zod_1.z.string(),
+    /**
+     * Self-healing configuration
+     */
+    selfHealing: exports.SelfHealingConfigSchema.optional(),
+    /**
+     * Auto-scaling policies
+     */
+    autoScaling: zod_1.z.array(exports.AutoScalingPolicySchema).optional(),
+    /**
+     * Continuous monitoring
+     */
+    monitoring: zod_1.z.object({
+        enabled: zod_1.z.boolean().default(true),
+        interval: zod_1.z.number().int().min(1000).default(60000)
+            .describe('Monitoring interval in milliseconds'),
+        /**
+         * Metrics to collect
+         */
+        metrics: zod_1.z.array(zod_1.z.string()).optional(),
+    }).optional(),
+    /**
+     * Proactive optimization
+     */
+    optimization: zod_1.z.object({
+        enabled: zod_1.z.boolean().default(true),
+        /**
+         * Scan interval (seconds)
+         */
+        scanInterval: zod_1.z.number().int().min(3600).default(86400)
+            .describe('How often to scan for optimization opportunities'),
+        /**
+         * Auto-apply optimizations
+         */
+        autoApply: zod_1.z.boolean().default(false)
+            .describe('Automatically apply low-risk optimizations'),
+    }).optional(),
+    /**
+     * Incident response
+     */
+    incidentResponse: zod_1.z.object({
+        enabled: zod_1.z.boolean().default(true),
+        /**
+         * Auto-trigger root cause analysis
+         */
+        autoRCA: zod_1.z.boolean().default(true),
+        /**
+         * Notification channels
+         */
+        notifications: zod_1.z.array(zod_1.z.object({
+            channel: zod_1.z.enum(['email', 'slack', 'webhook', 'sms']),
+            config: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+        })).optional(),
+    }).optional(),
+});

package/dist/api/discovery.zod.d.ts

@@ -30,9 +30,9 @@ export declare const DiscoverySchema: z.ZodObject<{
     name: z.ZodString;
     version: z.ZodString;
     environment: z.ZodEnum<{
+        sandbox: "sandbox";
         development: "development";
         production: "production";
-        sandbox: "sandbox";
     }>;
     routes: z.ZodObject<{
         data: z.ZodString;

package/dist/api/endpoint.zod.d.ts

@@ -38,8 +38,8 @@ export declare const ApiEndpointSchema: z.ZodObject<{
     type: z.ZodEnum<{
         script: "script";
         flow: "flow";
-        object_operation: "object_operation";
         proxy: "proxy";
+        object_operation: "object_operation";
     }>;
     target: z.ZodString;
     objectParams: z.ZodOptional<z.ZodObject<{
@@ -87,8 +87,8 @@ export declare const ApiEndpoint: z.ZodObject<{
     type: z.ZodEnum<{
         script: "script";
         flow: "flow";
-        object_operation: "object_operation";
         proxy: "proxy";
+        object_operation: "object_operation";
     }>;
     target: z.ZodString;
     objectParams: z.ZodOptional<z.ZodObject<{