@vfarcic/dot-ai 0.5.0 → 0.5.1

package/tests/tools/recommend.test.ts

@@ -0,0 +1,180 @@
+/**
+ * Tests for Recommend Tool
+ * 
+ * Tests the workflow guidance improvements for the recommend tool
+ */
+
+import { 
+  RECOMMEND_TOOL_NAME, 
+  RECOMMEND_TOOL_DESCRIPTION, 
+  RECOMMEND_TOOL_INPUT_SCHEMA,
+  handleRecommendTool 
+} from '../../src/tools/recommend';
+import { DotAI } from '../../src/core';
+import { ResourceRecommender } from '../../src/core/schema';
+
+// Mock dependencies
+jest.mock('../../src/core');
+jest.mock('../../src/core/schema');
+jest.mock('../../src/core/error-handling');
+jest.mock('../../src/core/claude');
+
+describe('Recommend Tool', () => {
+  describe('Tool Metadata', () => {
+    test('should have essential properties only', () => {
+      expect(RECOMMEND_TOOL_NAME).toBe('recommend');
+      expect(RECOMMEND_TOOL_DESCRIPTION).toContain('Deploy, create, run, or setup applications');
+      expect(RECOMMEND_TOOL_INPUT_SCHEMA).toBeDefined();
+    });
+
+    test('should have concise user-facing description', () => {
+      expect(RECOMMEND_TOOL_DESCRIPTION).toContain('Deploy, create, run, or setup applications');
+      expect(RECOMMEND_TOOL_DESCRIPTION).toContain('Ask the user to describe their application first');
+      expect(RECOMMEND_TOOL_DESCRIPTION.length).toBeLessThan(200); // Should be concise
+    });
+
+    test('should have valid input schema', () => {
+      expect(RECOMMEND_TOOL_INPUT_SCHEMA.intent).toBeDefined();
+    });
+  });
+
+  describe('Tool Handler - MCP Connectivity Fix Verification', () => {
+    test('should verify the fix: function parameters passed correctly', () => {
+      // This test verifies that our MCP connectivity fix is in place
+      // The fix changed from passing raw data to passing functions
+      
+      // Read the source code to verify the fix
+      const fs = require('fs');
+      const path = require('path');
+      const sourceCode = fs.readFileSync(
+        path.join(__dirname, '../../src/tools/recommend.ts'), 
+        'utf8'
+      );
+      
+      // Verify the fix: discoverResourcesFn should be defined as a function
+      expect(sourceCode).toContain('const discoverResourcesFn = async () => {');
+      expect(sourceCode).toContain('return await dotAI.discovery.discoverResources();');
+      
+      // Verify the function is passed to findBestSolutions (not raw data)
+      expect(sourceCode).toContain('discoverResourcesFn,');
+      expect(sourceCode).toContain('explainResourceFn');
+      
+      // Verify we're not passing raw data anymore (the old broken pattern)
+      expect(sourceCode).not.toContain('await dotAI.discovery.discoverResources(),');
+      expect(sourceCode).not.toContain('availableResources,'); // Old variable name
+    });
+    
+    test('should confirm CLI and MCP patterns now match', () => {
+      // Verify both CLI and MCP use the same pattern for calling ResourceRecommender
+      const fs = require('fs');
+      const path = require('path');
+      
+      const mcpCode = fs.readFileSync(
+        path.join(__dirname, '../../src/tools/recommend.ts'), 
+        'utf8'
+      );
+      
+      const cliCode = fs.readFileSync(
+        path.join(__dirname, '../../src/interfaces/cli.ts'), 
+        'utf8'
+      );
+      
+      // Both should use function-based approach
+      expect(mcpCode).toContain('const discoverResourcesFn = async () => {');
+      expect(cliCode).toContain('findBestSolutions(intent, discoverResourcesFn, explainResourceFn)'); // CLI uses same pattern
+      
+      // MCP should no longer have the broken pattern
+      expect(mcpCode).not.toContain('const availableResources = await dotAI.discovery.discoverResources();');
+    });
+  });
+
+  describe('Intent Validation', () => {
+    test('should include intent validation in source code', () => {
+      // Verify intent validation is implemented in the source
+      const fs = require('fs');
+      const path = require('path');
+      const sourceCode = fs.readFileSync(
+        path.join(__dirname, '../../src/tools/recommend.ts'), 
+        'utf8'
+      );
+      
+      // Check that validation function exists
+      expect(sourceCode).toContain('async function validateIntentWithAI');
+      expect(sourceCode).toContain('intent-validation.md');
+      
+      // Check that validation is called in the handler
+      expect(sourceCode).toContain('await validateIntentWithAI(args.intent, claudeIntegration)');
+      expect(sourceCode).toContain('Intent needs more specificity');
+    });
+
+    test('should validate prompt file exists', () => {
+      const fs = require('fs');
+      const path = require('path');
+      
+      const promptPath = path.join(__dirname, '../../prompts/intent-validation.md');
+      expect(fs.existsSync(promptPath)).toBe(true);
+      
+      const promptContent = fs.readFileSync(promptPath, 'utf8');
+      expect(promptContent).toContain('Intent Validation for Kubernetes Deployment Recommendations');
+      expect(promptContent).toContain('{intent}');
+      expect(promptContent).toContain('isSpecific');
+      expect(promptContent).toContain('suggestions');
+    });
+
+    test('should handle AI validation gracefully on service failures', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const sourceCode = fs.readFileSync(
+        path.join(__dirname, '../../src/tools/recommend.ts'), 
+        'utf8'
+      );
+      
+      // Verify error handling continues on AI service issues  
+      expect(sourceCode).toContain('console.warn(\'Intent validation failed, continuing with original intent:\', error);');
+      expect(sourceCode).toContain('logger.warn(\'Intent validation failed, continuing with recommendation\'');
+    });
+
+    test('should validate proper error structure for vague intents', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const sourceCode = fs.readFileSync(
+        path.join(__dirname, '../../src/tools/recommend.ts'), 
+        'utf8'
+      );
+      
+      // Check that validation errors are properly structured
+      expect(sourceCode).toContain('ErrorCategory.VALIDATION');
+      expect(sourceCode).toContain('ErrorSeverity.MEDIUM');
+      expect(sourceCode).toContain('intent_validation');
+      expect(sourceCode).toContain('Provide more specific details about your deployment');
+    });
+
+    test('should include ClaudeIntegration import', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const sourceCode = fs.readFileSync(
+        path.join(__dirname, '../../src/tools/recommend.ts'), 
+        'utf8'
+      );
+      
+      expect(sourceCode).toContain('import { ClaudeIntegration } from \'../core/claude\'');
+    });
+
+    test('should validate before expensive resource discovery', () => {
+      const fs = require('fs');
+      const path = require('path');
+      const sourceCode = fs.readFileSync(
+        path.join(__dirname, '../../src/tools/recommend.ts'), 
+        'utf8'
+      );
+      
+      // Validation should happen before ResourceRecommender initialization
+      const validationIndex = sourceCode.indexOf('await validateIntentWithAI');
+      const recommenderIndex = sourceCode.indexOf('new ResourceRecommender');
+      
+      expect(validationIndex).toBeGreaterThan(-1);
+      expect(recommenderIndex).toBeGreaterThan(-1);
+      expect(validationIndex).toBeLessThan(recommenderIndex);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noImplicitReturns": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "removeComments": false,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "coverage",
+    "**/*.test.ts",
+    "**/*.spec.ts"
+  ]
+} 

package/dist/cli.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/core/claude.d.ts

@@ -1,42 +0,0 @@
-/**
- * Claude Integration Module
- *
- * Handles AI communication, YAML generation, and learning integration
- */
-export interface ClaudeResponse {
-    content: string;
-    usage: {
-        input_tokens: number;
-        output_tokens: number;
-    };
-}
-export interface YAMLResponse {
-    yaml: string;
-    explanation: string;
-}
-export interface Interaction {
-    input: string;
-    output: string;
-    success: boolean;
-    timestamp?: Date;
-}
-export declare class ClaudeIntegration {
-    private client;
-    private apiKey;
-    private conversationHistory;
-    private interactions;
-    constructor(apiKey: string);
-    private validateApiKey;
-    sendMessage(message: string): Promise<ClaudeResponse>;
-    generateYAML(resourceType: string, config: any): Promise<YAMLResponse>;
-    recordInteraction(interaction: Interaction): Promise<void>;
-    getSuccessfulPatterns(): Promise<Interaction[]>;
-    getConversationHistory(): any[];
-    clearConversationHistory(): void;
-    generateManifest(spec: any): Promise<string>;
-    analyzeError(error: string, _context?: any): Promise<string>;
-    suggestImprovements(_manifest: string): Promise<string[]>;
-    processUserInput(input: string, context?: any): Promise<any>;
-    isInitialized(): boolean;
-}
-//# sourceMappingURL=claude.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/core/claude.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE;QACL,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,YAAY,CAAqB;gBAE7B,MAAM,EAAE,MAAM;IAW1B,OAAO,CAAC,cAAc;IAchB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAuErD,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,YAAY,CAAC;IA6CtE,iBAAiB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAS1D,qBAAqB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAIrD,sBAAsB,IAAI,GAAG,EAAE;IAI/B,wBAAwB,IAAI,IAAI;IAI1B,gBAAgB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IA+B5C,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAS5D,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAazD,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IA2BlE,aAAa,IAAI,OAAO;CAGzB"}

package/dist/core/claude.js

@@ -1,229 +0,0 @@
-"use strict";
-/**
- * Claude Integration Module
- *
- * Handles AI communication, YAML generation, and learning integration
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClaudeIntegration = void 0;
-const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
-class ClaudeIntegration {
-    client = null;
-    apiKey;
-    conversationHistory = [];
-    interactions = [];
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-        this.validateApiKey();
-        if (this.apiKey) {
-            this.client = new sdk_1.default({
-                apiKey: this.apiKey,
-            });
-        }
-    }
-    validateApiKey() {
-        // Allow test-friendly initialization
-        if (this.apiKey === 'test-key' || this.apiKey === 'mock-key') {
-            return; // Allow test keys
-        }
-        if (!this.apiKey) {
-            throw new Error('API key is required for Claude integration');
-        }
-        if (this.apiKey.length === 0) {
-            throw new Error('Invalid API key: API key cannot be empty');
-        }
-    }
-    async sendMessage(message) {
-        if (!this.client) {
-            throw new Error('Claude client not initialized due to missing API key');
-        }
-        if (this.apiKey === 'invalid-key') {
-            throw new Error('Authentication failed: Invalid API key');
-        }
-        try {
-            // Add message to conversation history
-            this.conversationHistory.push({ role: 'user', content: message });
-            // Use real Claude API if we have a real API key, otherwise fall back to mocks
-            if (this.apiKey.startsWith('sk-ant-') && this.client) {
-                // Make real API call to Claude
-                const completion = await this.client.messages.create({
-                    model: 'claude-3-5-sonnet-20241022',
-                    max_tokens: 4000,
-                    messages: [{ role: 'user', content: message }]
-                });
-                const content = completion.content[0].type === 'text' ? completion.content[0].text : '';
-                const response = {
-                    content,
-                    usage: {
-                        input_tokens: completion.usage.input_tokens,
-                        output_tokens: completion.usage.output_tokens
-                    }
-                };
-                this.conversationHistory.push({ role: 'assistant', content: response.content });
-                return response;
-            }
-            // For testing purposes, return mock responses
-            if (message.toLowerCase().includes('deploy a web application')) {
-                const response = {
-                    content: 'I can help you deploy a web application to Kubernetes. Let me guide you through the process of creating the necessary YAML manifests for your deployment.',
-                    usage: { input_tokens: 10, output_tokens: 25 }
-                };
-                this.conversationHistory.push({ role: 'assistant', content: response.content });
-                return response;
-            }
-            if (message.toLowerCase().includes('recommended resources') &&
-                this.conversationHistory.some(msg => msg.content.toLowerCase().includes('nginx'))) {
-                const response = {
-                    content: 'For nginx deployment, I recommend starting with 2 replicas, 500m CPU and 512Mi memory per pod. You can adjust these based on your traffic patterns.',
-                    usage: { input_tokens: 8, output_tokens: 30 }
-                };
-                this.conversationHistory.push({ role: 'assistant', content: response.content });
-                return response;
-            }
-            // Default mock response
-            const response = {
-                content: 'I understand you want help with Kubernetes deployment. Could you provide more specific details about what you\'d like to deploy?',
-                usage: { input_tokens: message.length / 4, output_tokens: 20 }
-            };
-            this.conversationHistory.push({ role: 'assistant', content: response.content });
-            return response;
-        }
-        catch (error) {
-            throw new Error(`Claude API error: ${error}`);
-        }
-    }
-    async generateYAML(resourceType, config) {
-        if (!this.client) {
-            throw new Error('Claude client not initialized');
-        }
-        // Mock YAML generation for testing
-        if (resourceType === 'deployment' && config.app === 'nginx') {
-            return {
-                yaml: `apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: ${config.app}
-  labels:
-    app: ${config.app}
-spec:
-  replicas: ${config.replicas || 1}
-  selector:
-    matchLabels:
-      app: ${config.app}
-  template:
-    metadata:
-      labels:
-        app: ${config.app}
-    spec:
-      containers:
-      - name: ${config.app}
-        image: ${config.image}
-        ports:
-        - containerPort: 80`,
-                explanation: `This deployment creates ${config.replicas || 1} replica(s) of ${config.app} using the ${config.image} image. The container exposes port 80 for web traffic.`
-            };
-        }
-        // Default YAML response
-        return {
-            yaml: `apiVersion: apps/v1
-kind: ${resourceType.charAt(0).toUpperCase() + resourceType.slice(1)}
-metadata:
-  name: example-${resourceType}
-spec:
-  # Generated configuration would go here`,
-            explanation: `This is a basic ${resourceType} manifest. You should customize it based on your specific requirements.`
-        };
-    }
-    async recordInteraction(interaction) {
-        const recordedInteraction = {
-            ...interaction,
-            timestamp: new Date()
-        };
-        this.interactions.push(recordedInteraction);
-    }
-    async getSuccessfulPatterns() {
-        return this.interactions.filter(interaction => interaction.success);
-    }
-    getConversationHistory() {
-        return [...this.conversationHistory];
-    }
-    clearConversationHistory() {
-        this.conversationHistory = [];
-    }
-    async generateManifest(spec) {
-        if (!this.client) {
-            throw new Error('Claude client not initialized');
-        }
-        // Simulate manifest generation
-        const yamlContent = `
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: ${spec.name || 'app'}
-spec:
-  replicas: ${spec.replicas || 1}
-  selector:
-    matchLabels:
-      app: ${spec.name || 'app'}
-  template:
-    metadata:
-      labels:
-        app: ${spec.name || 'app'}
-    spec:
-      containers:
-      - name: app
-        image: ${spec.image || 'nginx:latest'}
-        ports:
-        - containerPort: 80
-`;
-        return yamlContent.trim();
-    }
-    async analyzeError(error, _context) {
-        if (!this.client) {
-            throw new Error('Claude client not initialized');
-        }
-        // Simulate error analysis
-        return `Error analysis: ${error}. Suggested fix: Check the configuration and try again.`;
-    }
-    async suggestImprovements(_manifest) {
-        if (!this.client) {
-            throw new Error('Claude client not initialized');
-        }
-        // Simulate improvement suggestions
-        return [
-            'Add resource limits and requests',
-            'Consider adding health checks',
-            'Add labels for better organization'
-        ];
-    }
-    async processUserInput(input, context) {
-        if (!this.client) {
-            throw new Error('Claude client not initialized');
-        }
-        // Simulate interactive workflow processing
-        if (input.toLowerCase().includes('deploy') && context?.interactive) {
-            return {
-                phase: 'Planning',
-                questions: ['What type of database do you need?']
-            };
-        }
-        if (context?.responses) {
-            return {
-                phase: 'Validation',
-                nextSteps: ['Review generated manifest']
-            };
-        }
-        // Default response
-        return {
-            phase: 'Discovery',
-            suggestions: ['Start by exploring your cluster resources']
-        };
-    }
-    isInitialized() {
-        return this.client !== null;
-    }
-}
-exports.ClaudeIntegration = ClaudeIntegration;

package/dist/core/deploy-operation.d.ts

@@ -1,38 +0,0 @@
-/**
- * Deploy Operation - Handles Kubernetes manifest deployment with readiness checking
- */
-export interface DeployOptions {
-    solutionId: string;
-    sessionDir?: string;
-    timeout?: number;
-    kubeconfig?: string;
-}
-export interface DeployResult {
-    success: boolean;
-    solutionId: string;
-    manifestPath: string;
-    readinessTimeout: boolean;
-    message: string;
-    kubectlOutput: string;
-}
-export declare class DeployOperation {
-    private kubectlConfig;
-    constructor(kubeconfig?: string);
-    /**
-     * Deploy Kubernetes manifests from generated solution
-     */
-    deploy(options: DeployOptions): Promise<DeployResult>;
-    /**
-     * Get the manifest file path for the solution
-     */
-    private getManifestPath;
-    /**
-     * Verify that the manifest file exists
-     */
-    private verifyManifestExists;
-    /**
-     * Apply manifests using kubectl with readiness checking
-     */
-    private applyManifests;
-}
-//# sourceMappingURL=deploy-operation.d.ts.map

package/dist/core/deploy-operation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deploy-operation.d.ts","sourceRoot":"","sources":["../../src/core/deploy-operation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,aAAa,CAAgB;gBAEzB,UAAU,CAAC,EAAE,MAAM;IAM/B;;OAEG;IACU,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAiClE;;OAEG;IACH,OAAO,CAAC,eAAe;IASvB;;OAEG;YACW,oBAAoB;IAQlC;;OAEG;YACW,cAAc;CA8B7B"}

package/dist/core/deploy-operation.js

@@ -1,101 +0,0 @@
-"use strict";
-/**
- * Deploy Operation - Handles Kubernetes manifest deployment with readiness checking
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeployOperation = void 0;
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-const error_handling_1 = require("./error-handling");
-const kubernetes_utils_1 = require("./kubernetes-utils");
-class DeployOperation {
-    kubectlConfig;
-    constructor(kubeconfig) {
-        this.kubectlConfig = {
-            kubeconfig: kubeconfig || process.env.KUBECONFIG
-        };
-    }
-    /**
-     * Deploy Kubernetes manifests from generated solution
-     */
-    async deploy(options) {
-        return error_handling_1.ErrorHandler.withErrorHandling(async () => {
-            const manifestPath = this.getManifestPath(options);
-            // Verify manifest file exists
-            await this.verifyManifestExists(manifestPath);
-            // Update kubeconfig if provided in options
-            const kubectlConfig = {
-                ...this.kubectlConfig,
-                kubeconfig: options.kubeconfig || this.kubectlConfig.kubeconfig
-            };
-            // Apply manifests with kubectl
-            const kubectlOutput = await this.applyManifests(manifestPath, options.timeout || 30, kubectlConfig);
-            return {
-                success: true,
-                solutionId: options.solutionId,
-                manifestPath,
-                readinessTimeout: false,
-                message: 'Deployment completed successfully',
-                kubectlOutput
-            };
-        }, {
-            operation: 'deploy',
-            component: 'deploy-operation'
-        });
-    }
-    /**
-     * Get the manifest file path for the solution
-     */
-    getManifestPath(options) {
-        const sessionDir = options.sessionDir || process.env.DOT_AI_SESSION_DIR;
-        if (!sessionDir) {
-            throw new Error('Session directory not configured. Set DOT_AI_SESSION_DIR environment variable or provide sessionDir parameter.');
-        }
-        return (0, path_1.join)(sessionDir, `${options.solutionId}.yaml`);
-    }
-    /**
-     * Verify that the manifest file exists
-     */
-    async verifyManifestExists(manifestPath) {
-        try {
-            await (0, promises_1.access)(manifestPath);
-        }
-        catch (error) {
-            throw new Error(`Manifest file not found: ${manifestPath}`);
-        }
-    }
-    /**
-     * Apply manifests using kubectl with readiness checking
-     */
-    async applyManifests(manifestPath, timeout, kubectlConfig) {
-        // First, apply the manifests
-        const applyResult = await (0, kubernetes_utils_1.executeKubectl)(['apply', '-f', `"${manifestPath}"`], kubectlConfig);
-        // Try to wait for deployments to be ready (ignore failures for other resource types)
-        let waitOutput = '';
-        try {
-            const waitResult = await (0, kubernetes_utils_1.executeKubectl)([
-                'wait',
-                '--for=condition=available',
-                'deployments',
-                '--all',
-                `--timeout=${timeout}s`,
-                '--all-namespaces'
-            ], {
-                ...kubectlConfig,
-                timeout: (timeout + 10) * 1000 // Add 10 seconds buffer for kubectl command itself
-            });
-            waitOutput = `\n\nWait output:\n${waitResult}`;
-        }
-        catch (waitError) {
-            // If no deployments found or wait fails, that's OK for ConfigMaps, Services, etc.
-            if (waitError.message && waitError.message.includes('no matching resources found')) {
-                waitOutput = '\n\nWait output: No deployments found to wait for (likely ConfigMaps, Services, etc.)';
-            }
-            else {
-                waitOutput = `\n\nWait output: Warning - ${waitError.message}`;
-            }
-        }
-        return `Apply output:\n${applyResult}${waitOutput}`;
-    }
-}
-exports.DeployOperation = DeployOperation;