@vfarcic/dot-ai 0.1.0

package/dist/core/index.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Core Intelligence Module
+ *
+ * Shared intelligence for both CLI and MCP interfaces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceRecommender = exports.ManifestValidator = exports.SchemaParser = exports.ClaudeIntegration = exports.WorkflowEngine = exports.MemorySystem = exports.KubernetesDiscovery = exports.DotAI = void 0;
+const discovery_1 = require("./discovery");
+const memory_1 = require("./memory");
+const workflow_1 = require("./workflow");
+const claude_1 = require("./claude");
+const schema_1 = require("./schema");
+class DotAI {
+    config;
+    initialized = false;
+    discovery;
+    memory;
+    workflow;
+    claude;
+    schema;
+    constructor(config = {}) {
+        this.validateConfig(config);
+        // Centralize environment variable reading
+        this.config = {
+            kubernetesConfig: config.kubernetesConfig || process.env.KUBECONFIG,
+            anthropicApiKey: config.anthropicApiKey || process.env.ANTHROPIC_API_KEY
+        };
+        // Initialize modules
+        this.discovery = new discovery_1.KubernetesDiscovery({
+            kubeconfigPath: this.config.kubernetesConfig
+        });
+        this.memory = new memory_1.MemorySystem();
+        this.workflow = new workflow_1.WorkflowEngine();
+        this.claude = new claude_1.ClaudeIntegration(this.config.anthropicApiKey || 'test-key');
+        // Initialize schema components
+        const parser = new schema_1.SchemaParser();
+        const validator = new schema_1.ManifestValidator();
+        const ranker = this.config.anthropicApiKey ?
+            new schema_1.ResourceRecommender({ claudeApiKey: this.config.anthropicApiKey }) :
+            null;
+        this.schema = {
+            parser,
+            validator,
+            ranker,
+            parseResource: async (resourceName) => {
+                // Get raw resource explanation from discovery  
+                const explanation = await this.discovery.explainResource(resourceName);
+                // Parse GROUP, KIND, VERSION from kubectl explain output
+                const lines = explanation.split('\n');
+                const groupLine = lines.find((line) => line.startsWith('GROUP:'));
+                const kindLine = lines.find((line) => line.startsWith('KIND:'));
+                const versionLine = lines.find((line) => line.startsWith('VERSION:'));
+                const group = groupLine ? groupLine.replace('GROUP:', '').trim() : '';
+                const kind = kindLine ? kindLine.replace('KIND:', '').trim() : resourceName;
+                const version = versionLine ? versionLine.replace('VERSION:', '').trim() : 'v1';
+                // Build apiVersion from group and version
+                const apiVersion = group ? `${group}/${version}` : version;
+                // Return raw explanation for AI processing
+                return {
+                    kind: kind,
+                    rawExplanation: explanation,
+                    apiVersion: apiVersion,
+                    group: group,
+                    description: explanation.split('\n').find((line) => line.startsWith('DESCRIPTION:'))?.replace('DESCRIPTION:', '').trim() || '',
+                    properties: new Map() // Raw explanation contains all field info for AI
+                };
+            },
+            rankResources: async (intent) => {
+                if (!ranker) {
+                    throw new Error('ResourceRanker not available. ANTHROPIC_API_KEY is required for AI-powered ranking.');
+                }
+                // Create discovery functions with proper binding
+                const discoverResourcesFn = async () => await this.discovery.discoverResources();
+                const explainResourceFn = async (resource) => await this.discovery.explainResource(resource);
+                return await ranker.findBestSolutions(intent, discoverResourcesFn, explainResourceFn);
+            }
+        };
+    }
+    validateConfig(config) {
+        if (config.anthropicApiKey === '') {
+            throw new Error('Invalid configuration: Empty API key provided');
+        }
+    }
+    async initialize() {
+        try {
+            // Initialize all modules
+            await this.discovery.connect();
+            await this.memory.initialize();
+            await this.workflow.initialize();
+            this.initialized = true;
+        }
+        catch (error) {
+            this.initialized = false;
+            throw error;
+        }
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    getVersion() {
+        return '0.1.0';
+    }
+    getAnthropicApiKey() {
+        return this.config.anthropicApiKey;
+    }
+}
+exports.DotAI = DotAI;
+// Re-export all modules for convenience
+var discovery_2 = require("./discovery");
+Object.defineProperty(exports, "KubernetesDiscovery", { enumerable: true, get: function () { return discovery_2.KubernetesDiscovery; } });
+var memory_2 = require("./memory");
+Object.defineProperty(exports, "MemorySystem", { enumerable: true, get: function () { return memory_2.MemorySystem; } });
+var workflow_2 = require("./workflow");
+Object.defineProperty(exports, "WorkflowEngine", { enumerable: true, get: function () { return workflow_2.WorkflowEngine; } });
+var claude_2 = require("./claude");
+Object.defineProperty(exports, "ClaudeIntegration", { enumerable: true, get: function () { return claude_2.ClaudeIntegration; } });
+var schema_2 = require("./schema");
+Object.defineProperty(exports, "SchemaParser", { enumerable: true, get: function () { return schema_2.SchemaParser; } });
+Object.defineProperty(exports, "ManifestValidator", { enumerable: true, get: function () { return schema_2.ManifestValidator; } });
+Object.defineProperty(exports, "ResourceRecommender", { enumerable: true, get: function () { return schema_2.ResourceRecommender; } });
+// Default export
+exports.default = DotAI;

package/dist/core/kubernetes-utils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared Kubernetes Utilities
+ *
+ * Common functions for interacting with Kubernetes clusters
+ */
+export interface KubectlConfig {
+    context?: string;
+    namespace?: string;
+    kubeconfig?: string;
+    timeout?: number;
+}
+/**
+ * Execute kubectl command with proper configuration
+ */
+export declare function executeKubectl(args: string[], config?: KubectlConfig): Promise<string>;
+/**
+ * Build kubectl command string with proper flags
+ */
+export declare function buildKubectlCommand(args: string[], config?: KubectlConfig): string;
+export declare class ErrorClassifier {
+    static classifyError(error: Error): {
+        type: string;
+        enhancedMessage: string;
+    };
+    private static isNetworkError;
+    private static isAuthenticationError;
+    private static isAuthorizationError;
+    private static isAPIAvailabilityError;
+    private static isKubeconfigError;
+    private static isVersionCompatibilityError;
+    private static enhanceNetworkError;
+    private static enhanceAuthenticationError;
+    private static enhanceAuthorizationError;
+    private static enhanceAPIAvailabilityError;
+    private static enhanceKubeconfigError;
+    private static enhanceVersionCompatibilityError;
+}
+//# sourceMappingURL=kubernetes-utils.d.ts.map

package/dist/core/kubernetes-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kubernetes-utils.d.ts","sourceRoot":"","sources":["../../src/core/kubernetes-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAsB5F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM,CAiBlF;AAGD,qBAAa,eAAe;IAC1B,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAA;KAAE;IA0D7E,OAAO,CAAC,MAAM,CAAC,cAAc;IAI7B,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAIpC,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAInC,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAIrC,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAMhC,OAAO,CAAC,MAAM,CAAC,2BAA2B;IAI1C,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAYlC,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAgBzC,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAYxC,OAAO,CAAC,MAAM,CAAC,2BAA2B;IAQ1C,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAYrC,OAAO,CAAC,MAAM,CAAC,gCAAgC;CAGhD"}

package/dist/core/kubernetes-utils.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Shared Kubernetes Utilities
+ *
+ * Common functions for interacting with Kubernetes clusters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorClassifier = void 0;
+exports.executeKubectl = executeKubectl;
+exports.buildKubectlCommand = buildKubectlCommand;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Execute kubectl command with proper configuration
+ */
+async function executeKubectl(args, config) {
+    const command = buildKubectlCommand(args, config);
+    const timeout = config?.timeout || 30000;
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            timeout,
+            maxBuffer: 100 * 1024 * 1024 // 100MB buffer for large clusters with 1000+ CRDs
+        });
+        if (stderr && !stderr.includes('Warning')) {
+            throw new Error(`kubectl command failed: ${stderr}`);
+        }
+        return stdout.trim();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error('kubectl binary not found. Please install kubectl and ensure it\'s in your PATH.');
+        }
+        // Use error classification for better error messages
+        const classified = ErrorClassifier.classifyError(error);
+        throw new Error(classified.enhancedMessage);
+    }
+}
+/**
+ * Build kubectl command string with proper flags
+ */
+function buildKubectlCommand(args, config) {
+    let command = 'kubectl';
+    if (config?.kubeconfig) {
+        command += ` --kubeconfig=${config.kubeconfig}`;
+    }
+    if (config?.context) {
+        command += ` --context=${config.context}`;
+    }
+    if (config?.namespace) {
+        command += ` --namespace=${config.namespace}`;
+    }
+    command += ` ${args.join(' ')}`;
+    return command;
+}
+// Enhanced Error Classification System
+class ErrorClassifier {
+    static classifyError(error) {
+        const originalMessage = error.message;
+        // Connection and Network Errors
+        if (this.isNetworkError(originalMessage)) {
+            return {
+                type: 'network',
+                enhancedMessage: this.enhanceNetworkError(originalMessage)
+            };
+        }
+        // Authentication Errors
+        if (this.isAuthenticationError(originalMessage)) {
+            return {
+                type: 'authentication',
+                enhancedMessage: this.enhanceAuthenticationError(originalMessage)
+            };
+        }
+        // Authorization/RBAC Errors
+        if (this.isAuthorizationError(originalMessage)) {
+            return {
+                type: 'authorization',
+                enhancedMessage: this.enhanceAuthorizationError(originalMessage)
+            };
+        }
+        // API Availability Errors
+        if (this.isAPIAvailabilityError(originalMessage)) {
+            return {
+                type: 'api-availability',
+                enhancedMessage: this.enhanceAPIAvailabilityError(originalMessage)
+            };
+        }
+        // Kubeconfig Validation Errors
+        if (this.isKubeconfigError(originalMessage)) {
+            return {
+                type: 'kubeconfig',
+                enhancedMessage: this.enhanceKubeconfigError(originalMessage)
+            };
+        }
+        // Version Compatibility Errors
+        if (this.isVersionCompatibilityError(originalMessage)) {
+            return {
+                type: 'version',
+                enhancedMessage: this.enhanceVersionCompatibilityError(originalMessage)
+            };
+        }
+        // Default: return original message with basic enhancement
+        return {
+            type: 'unknown',
+            enhancedMessage: `${originalMessage}\n\nTroubleshooting steps:\n- Run 'kubectl cluster-info' to verify cluster connectivity\n- Check your kubeconfig with 'kubectl config view'\n- Verify cluster endpoint accessibility`
+        };
+    }
+    static isNetworkError(message) {
+        return /getaddrinfo ENOTFOUND|timeout|ECONNREFUSED|ENOTFOUND|network|unreachable/i.test(message);
+    }
+    static isAuthenticationError(message) {
+        return /unauthorized|invalid bearer token|certificate|auth|authentication/i.test(message);
+    }
+    static isAuthorizationError(message) {
+        return /forbidden|cannot list|cannot get|cannot create|RBAC|permission denied/i.test(message);
+    }
+    static isAPIAvailabilityError(message) {
+        return /server could not find|resource type.*not found|doesn't have a resource type|no matches for kind/i.test(message);
+    }
+    static isKubeconfigError(message) {
+        // Be more specific - don't match "path does not exist" errors which are about manifest files
+        return /context.*does not exist|kubeconfig.*not found|invalid.*kubeconfig|config.*not found|no Auth Provider/i.test(message) &&
+            !/the path.*does not exist/.test(message);
+    }
+    static isVersionCompatibilityError(message) {
+        return /server version|version.*old|unsupported.*version|api.*version/i.test(message);
+    }
+    static enhanceNetworkError(message) {
+        if (message.includes('getaddrinfo ENOTFOUND')) {
+            return `DNS resolution failed: Cannot resolve cluster endpoint hostname.\n\nTroubleshooting steps:\n- Check cluster endpoint in kubeconfig: kubectl config view\n- Verify network connectivity and DNS settings\n- Confirm cluster is running and accessible\n- Check VPN connection if using private cluster\n\nOriginal error: ${message}`;
+        }
+        if (message.includes('timeout')) {
+            return `Connection timeout: Unable to reach cluster within timeout period.\n\nTroubleshooting steps:\n- Check network latency to cluster endpoint\n- Increase timeout value if needed\n- Verify cluster is responsive: kubectl get nodes\n- Check firewall and proxy settings\n\nOriginal error: ${message}`;
+        }
+        return `Network connectivity issue detected.\n\nTroubleshooting steps:\n- Verify cluster endpoint accessibility\n- Run 'kubectl cluster-info' to test connectivity\n- Check network and firewall settings\n- Confirm cluster is running\n\nOriginal error: ${message}`;
+    }
+    static enhanceAuthenticationError(message) {
+        if (message.includes('invalid bearer token')) {
+            return `Token may be expired: Bearer token authentication failed.\n\nTroubleshooting steps:\n- Token may be expired - refresh credentials\n- Check token format in kubeconfig\n- Re-authenticate with cluster: kubectl auth login\n- Verify service account token if applicable\n\nOriginal error: ${message}`;
+        }
+        if (message.includes('certificate')) {
+            return `Certificate authentication failed: Client certificate validation error.\n\nTroubleshooting steps:\n- Verify certificate path in kubeconfig\n- Check certificate expiration date\n- Ensure certificate authority (CA) bundle is correct\n- Re-generate client certificates if needed\n\nOriginal error: ${message}`;
+        }
+        if (message.includes('no Auth Provider found')) {
+            return `Authentication provider not available: Required auth plugin missing.\n\nTroubleshooting steps:\n- Install required authentication plugin (e.g., OIDC)\n- Check kubectl config for auth provider configuration\n- Verify authentication method compatibility\n- Consult cluster administrator for auth setup\n\nOriginal error: ${message}`;
+        }
+        return `Authentication failed: Invalid or missing credentials.\n\nTroubleshooting steps:\n- Verify credentials in kubeconfig\n- Re-authenticate with cluster\n- Check authentication method configuration\n- Contact cluster administrator if needed\n\nOriginal error: ${message}`;
+    }
+    static enhanceAuthorizationError(message) {
+        if (message.includes('customresourcedefinitions')) {
+            return `CRD discovery requires cluster-level permissions: Insufficient RBAC permissions.\n\nTroubleshooting steps:\n- CRD discovery requires admin privileges\n- Request cluster-admin role or CRD read permissions\n- Contact cluster administrator for permission escalation\n- Use 'kubectl auth can-i list customresourcedefinitions' to check permissions\n\nOriginal error: ${message}`;
+        }
+        if (message.includes('forbidden')) {
+            return `Insufficient permissions: RBAC restrictions prevent this operation.\n\nTroubleshooting steps:\n- RBAC role required for resource access\n- Request appropriate permissions from cluster administrator\n- Check current permissions: kubectl auth can-i list <resource>\n- Consider using cluster-admin role for discovery operations\n\nOriginal error: ${message}`;
+        }
+        return `Permission denied: Insufficient RBAC permissions for cluster access.\n\nTroubleshooting steps:\n- Request appropriate RBAC permissions\n- Check current access: kubectl auth can-i list <resource>\n- Contact cluster administrator for role assignment\n- Verify service account permissions if applicable\n\nOriginal error: ${message}`;
+    }
+    static enhanceAPIAvailabilityError(message) {
+        if (message.includes('apps/v1beta1')) {
+            return `API version not supported: Cluster doesn't support requested API version.\n\nTroubleshooting steps:\n- Try different API version (e.g., apps/v1 instead of apps/v1beta1)\n- Check available API versions: kubectl api-versions\n- Verify Kubernetes cluster version compatibility\n- Consult API migration guides for version changes\n\nOriginal error: ${message}`;
+        }
+        return `API resource not available: Requested resource type not found in cluster.\n\nTroubleshooting steps:\n- Check available resources: kubectl api-resources\n- Verify cluster supports required resource types\n- Check Kubernetes version compatibility\n- Confirm cluster configuration and enabled APIs\n\nOriginal error: ${message}`;
+    }
+    static enhanceKubeconfigError(message) {
+        if (message.includes('context') && message.includes('does not exist')) {
+            return `Context not found: Specified context doesn't exist in kubeconfig.\n\nTroubleshooting steps:\n- List available contexts: kubectl config get-contexts\n- Set correct context: kubectl config use-context <context-name>\n- Verify kubeconfig file contains required context\n- Check context name spelling and case sensitivity\n\nOriginal error: ${message}`;
+        }
+        if (message.includes('not found')) {
+            return `Kubeconfig file not found: Cannot locate configuration file.\n\nTroubleshooting steps:\n- Check file path exists and is accessible\n- Verify kubeconfig file permissions\n- Set KUBECONFIG environment variable if needed\n- Create kubeconfig file or copy from cluster administrator\n\nOriginal error: ${message}`;
+        }
+        return `Invalid kubeconfig format: Configuration file has syntax or format errors.\n\nTroubleshooting steps:\n- Validate YAML syntax in kubeconfig file\n- Check file structure: kubectl config view\n- Restore from backup or re-download from cluster\n- Verify all required sections (clusters, contexts, users)\n\nOriginal error: ${message}`;
+    }
+    static enhanceVersionCompatibilityError(message) {
+        return `Kubernetes version compatibility issue: Version mismatch detected.\n\nTroubleshooting steps:\n- Check cluster and client versions: kubectl version\n- Verify supported Kubernetes versions for this tool\n- Update kubectl client if needed\n- Consult compatibility matrix for version support\n\nOriginal error: ${message}`;
+    }
+}
+exports.ErrorClassifier = ErrorClassifier;

package/dist/core/memory.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Memory System Module
+ *
+ * Handles learning, context management, and recommendation storage
+ */
+export interface SuccessPattern {
+    type: string;
+    config: any;
+    timestamp: Date;
+}
+export interface FailurePattern {
+    type: string;
+    config: any;
+    error: string;
+    timestamp: Date;
+}
+export interface Recommendation {
+    suggestion: string;
+    confidence: number;
+    based_on: string[];
+}
+export declare class MemorySystem {
+    private storage;
+    private successPatterns;
+    private failurePatterns;
+    private context;
+    private initialized;
+    initialize(): Promise<void>;
+    store(key: string, data: any): Promise<void>;
+    retrieve(key: string): Promise<any>;
+    learnSuccess(type: string, config: any): Promise<void>;
+    learnFailure(type: string, config: any, error: string): Promise<void>;
+    getSuccessPatterns(type: string): Promise<SuccessPattern[]>;
+    getFailurePatterns(type: string): Promise<FailurePattern[]>;
+    getRecommendations(type: string, partialConfig: any): Promise<Recommendation[]>;
+    storePattern(type: string, pattern: any): Promise<void>;
+    retrievePattern(type: string): Promise<any[]>;
+    storeLessons(type: string, lessons: any): Promise<void>;
+    private calculateSimilarity;
+    setContext(key: string, value: any): Promise<void>;
+    getContext(): Promise<Record<string, any>>;
+    clearContext(key?: string): Promise<void>;
+    isInitialized(): boolean;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/core/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/core/memory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,GAAG,CAAC;IACZ,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,GAAG,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,WAAW,CAAkB;IAE/B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAInC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAYtD,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAarE,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAI3D,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAI3D,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,GAAG,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAmB/E,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvD,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAK7C,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7D,OAAO,CAAC,mBAAmB;IAYrB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlD,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAQ1C,YAAY,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ/C,aAAa,IAAI,OAAO;CAGzB"}

package/dist/core/memory.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Memory System Module
+ *
+ * Handles learning, context management, and recommendation storage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySystem = void 0;
+class MemorySystem {
+    storage = new Map();
+    successPatterns = new Map();
+    failurePatterns = new Map();
+    context = new Map();
+    initialized = false;
+    async initialize() {
+        // Initialize storage (in production, this would connect to persistent storage)
+        this.initialized = true;
+    }
+    async store(key, data) {
+        this.storage.set(key, data);
+    }
+    async retrieve(key) {
+        return this.storage.get(key) || null;
+    }
+    async learnSuccess(type, config) {
+        const pattern = {
+            type,
+            config,
+            timestamp: new Date()
+        };
+        const existing = this.successPatterns.get(type) || [];
+        existing.push(pattern);
+        this.successPatterns.set(type, existing);
+    }
+    async learnFailure(type, config, error) {
+        const pattern = {
+            type,
+            config,
+            error,
+            timestamp: new Date()
+        };
+        const existing = this.failurePatterns.get(type) || [];
+        existing.push(pattern);
+        this.failurePatterns.set(type, existing);
+    }
+    async getSuccessPatterns(type) {
+        return this.successPatterns.get(type) || [];
+    }
+    async getFailurePatterns(type) {
+        return this.failurePatterns.get(type) || [];
+    }
+    async getRecommendations(type, partialConfig) {
+        const successPatterns = await this.getSuccessPatterns(type);
+        const recommendations = [];
+        // Simple recommendation algorithm
+        for (const pattern of successPatterns) {
+            const similarity = this.calculateSimilarity(partialConfig, pattern.config);
+            if (similarity >= 0.5) {
+                recommendations.push({
+                    suggestion: `Consider using configuration similar to successful ${type}`,
+                    confidence: similarity,
+                    based_on: [`Success pattern from ${pattern.timestamp.toISOString()}`]
+                });
+            }
+        }
+        return recommendations;
+    }
+    async storePattern(type, pattern) {
+        // Store pattern as a success by default
+        await this.learnSuccess(type, pattern);
+    }
+    async retrievePattern(type) {
+        const patterns = await this.getSuccessPatterns(type);
+        return patterns.map(p => p.config);
+    }
+    async storeLessons(type, lessons) {
+        // Store lessons in the general storage
+        await this.store(`lessons-${type}`, lessons);
+    }
+    calculateSimilarity(config1, config2) {
+        // Simple similarity calculation
+        const keys1 = Object.keys(config1);
+        const keys2 = Object.keys(config2);
+        const commonKeys = keys1.filter(key => keys2.includes(key));
+        if (keys1.length === 0 && keys2.length === 0)
+            return 1;
+        if (keys1.length === 0 || keys2.length === 0)
+            return 0;
+        return commonKeys.length / Math.max(keys1.length, keys2.length);
+    }
+    async setContext(key, value) {
+        this.context.set(key, value);
+    }
+    async getContext() {
+        const result = {};
+        for (const [key, value] of this.context.entries()) {
+            result[key] = value;
+        }
+        return result;
+    }
+    async clearContext(key) {
+        if (key) {
+            this.context.delete(key);
+        }
+        else {
+            this.context.clear();
+        }
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+}
+exports.MemorySystem = MemorySystem;