@vfarcic/dot-ai 0.1.0

package/dist/tools/generate-manifests.js

@@ -0,0 +1,424 @@
+"use strict";
+/**
+ * Generate Manifests Tool - AI-driven manifest generation with validation loop
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATEMANIFESTS_TOOL_INPUT_SCHEMA = exports.GENERATEMANIFESTS_TOOL_DESCRIPTION = exports.GENERATEMANIFESTS_TOOL_NAME = void 0;
+exports.handleGenerateManifestsTool = handleGenerateManifestsTool;
+const zod_1 = require("zod");
+const error_handling_1 = require("../core/error-handling");
+const claude_1 = require("../core/claude");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const child_process_1 = require("child_process");
+const session_utils_1 = require("../core/session-utils");
+// Tool metadata for direct MCP registration
+exports.GENERATEMANIFESTS_TOOL_NAME = 'generateManifests';
+exports.GENERATEMANIFESTS_TOOL_DESCRIPTION = 'Generate final Kubernetes manifests from fully configured solution (ONLY after completing ALL stages: required, basic, advanced, and open)';
+// Zod schema for MCP registration
+exports.GENERATEMANIFESTS_TOOL_INPUT_SCHEMA = {
+    solutionId: zod_1.z.string().regex(/^sol_[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{6}_[a-f0-9]+$/).describe('The solution ID to generate manifests for (e.g., sol_2025-07-01T154349_1e1e242592ff)')
+};
+/**
+ * Load solution file and validate structure
+ */
+function loadSolutionFile(solutionId, sessionDir) {
+    const solutionPath = path.join(sessionDir, `${solutionId}.json`);
+    if (!fs.existsSync(solutionPath)) {
+        throw new Error(`Solution file not found: ${solutionPath}. Available files: ${fs.readdirSync(sessionDir).filter(f => f.endsWith('.json')).join(', ')}`);
+    }
+    try {
+        const content = fs.readFileSync(solutionPath, 'utf8');
+        const solution = JSON.parse(content);
+        if (!solution.solutionId || !solution.questions) {
+            throw new Error(`Invalid solution file structure: ${solutionId}. Missing required fields: solutionId or questions`);
+        }
+        return solution;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in solution file: ${solutionId}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Retrieve schemas for resources specified in the solution
+ */
+async function retrieveResourceSchemas(solution, dotAI, logger) {
+    try {
+        // Extract resource references from solution
+        const resourceRefs = (solution.resources || []).map((resource) => ({
+            kind: resource.kind,
+            apiVersion: resource.apiVersion,
+            group: resource.group
+        }));
+        if (resourceRefs.length === 0) {
+            logger.warn('No resources found in solution for schema retrieval');
+            return {};
+        }
+        logger.info('Retrieving schemas for solution resources', {
+            resourceCount: resourceRefs.length,
+            resources: resourceRefs.map((r) => `${r.kind}@${r.apiVersion}`)
+        });
+        const schemas = {};
+        // Retrieve schema for each resource
+        for (const resourceRef of resourceRefs) {
+            try {
+                const resourceKey = `${resourceRef.kind}.${resourceRef.apiVersion}`;
+                logger.debug('Retrieving schema', { resourceKey });
+                // Use discovery engine to explain the resource
+                const explanation = await dotAI.discovery.explainResource(resourceRef.kind);
+                schemas[resourceKey] = {
+                    kind: resourceRef.kind,
+                    apiVersion: resourceRef.apiVersion,
+                    schema: explanation,
+                    timestamp: new Date().toISOString()
+                };
+                logger.debug('Schema retrieved successfully', {
+                    resourceKey,
+                    schemaLength: explanation.length
+                });
+            }
+            catch (error) {
+                logger.error('Failed to retrieve schema for resource', error, {
+                    resource: resourceRef
+                });
+                // Fail fast - if we can't get schemas, manifest generation will likely fail
+                throw new Error(`Failed to retrieve schema for ${resourceRef.kind}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        logger.info('All resource schemas retrieved successfully', {
+            schemaCount: Object.keys(schemas).length
+        });
+        return schemas;
+    }
+    catch (error) {
+        logger.error('Schema retrieval failed', error);
+        throw new Error(`Failed to retrieve resource schemas: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Validate YAML syntax
+ */
+function validateYamlSyntax(yamlContent) {
+    try {
+        yaml.loadAll(yamlContent);
+        return { valid: true };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            error: error instanceof Error ? error.message : 'Unknown YAML syntax error'
+        };
+    }
+}
+/**
+ * Run kubectl dry-run validation
+ */
+async function runKubectlDryRun(yamlPath) {
+    return new Promise((resolve) => {
+        const kubectl = (0, child_process_1.spawn)('kubectl', ['apply', '--dry-run=server', '-f', yamlPath], {
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        kubectl.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        kubectl.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        kubectl.on('close', (code) => {
+            resolve({
+                success: code === 0,
+                yamlSyntaxValid: true, // If we get here, YAML was parseable
+                kubectlOutput: stderr || stdout,
+                exitCode: code || 0,
+                stderr,
+                stdout
+            });
+        });
+        kubectl.on('error', (error) => {
+            resolve({
+                success: false,
+                yamlSyntaxValid: true,
+                error: `Failed to run kubectl: ${error.message}`,
+                kubectlOutput: `kubectl command failed: ${error.message}`,
+                exitCode: -1,
+                stderr: error.message,
+                stdout: ''
+            });
+        });
+    });
+}
+/**
+ * Validate manifests using multi-layer approach
+ */
+async function validateManifests(yamlPath) {
+    // First check if file exists
+    if (!fs.existsSync(yamlPath)) {
+        return {
+            success: false,
+            yamlSyntaxValid: false,
+            error: `Manifest file not found: ${yamlPath}`
+        };
+    }
+    // Read YAML content
+    const yamlContent = fs.readFileSync(yamlPath, 'utf8');
+    // 1. YAML syntax validation
+    const syntaxCheck = validateYamlSyntax(yamlContent);
+    if (!syntaxCheck.valid) {
+        return {
+            success: false,
+            yamlSyntaxValid: false,
+            error: `YAML syntax error: ${syntaxCheck.error}`,
+            kubectlOutput: `YAML parsing failed: ${syntaxCheck.error}`
+        };
+    }
+    // 2. kubectl dry-run validation
+    return await runKubectlDryRun(yamlPath);
+}
+/**
+ * Generate manifests using AI with Claude integration
+ */
+async function generateManifestsWithAI(solution, dotAI, logger, errorContext) {
+    // Load prompt template
+    const promptPath = path.join(process.cwd(), 'prompts', 'manifest-generation.md');
+    const template = fs.readFileSync(promptPath, 'utf8');
+    // Retrieve schemas for solution resources
+    const resourceSchemas = await retrieveResourceSchemas(solution, dotAI, logger);
+    // Prepare template variables
+    const solutionData = JSON.stringify(solution, null, 2);
+    const previousAttempt = errorContext ? `
+### Generated Manifests:
+\`\`\`yaml
+${errorContext.previousManifests}
+\`\`\`
+` : 'None - this is the first attempt.';
+    const errorDetails = errorContext ? `
+**Attempt**: ${errorContext.attempt}
+**YAML Syntax Valid**: ${errorContext.yamlSyntaxValid}
+**kubectl Output**: ${errorContext.kubectlOutput}
+**Exit Code**: ${errorContext.exitCode}
+**Error Details**: ${errorContext.stderr}
+` : 'None - this is the first attempt.';
+    // Replace template variables
+    const schemasData = JSON.stringify(resourceSchemas, null, 2);
+    const aiPrompt = template
+        .replace('{solution}', solutionData)
+        .replace('{schemas}', schemasData)
+        .replace('{previous_attempt}', previousAttempt)
+        .replace('{error_details}', errorDetails);
+    const isRetry = !!errorContext;
+    logger.info('Generating manifests with AI', {
+        isRetry,
+        attempt: errorContext?.attempt,
+        hasErrorContext: !!errorContext,
+        solutionId: solution.solutionId
+    });
+    // Initialize Claude integration
+    const apiKey = process.env.ANTHROPIC_API_KEY || 'test-key';
+    const claudeIntegration = new claude_1.ClaudeIntegration(apiKey);
+    // Send prompt to Claude
+    const response = await claudeIntegration.sendMessage(aiPrompt);
+    // Extract YAML content from response
+    let manifestContent = response.content;
+    // Try to extract YAML from code blocks if wrapped
+    const yamlBlockMatch = manifestContent.match(/```(?:yaml|yml)?\s*([\s\S]*?)\s*```/);
+    if (yamlBlockMatch) {
+        manifestContent = yamlBlockMatch[1];
+    }
+    // Clean up any leading/trailing whitespace
+    manifestContent = manifestContent.trim();
+    logger.info('AI manifest generation completed', {
+        manifestLength: manifestContent.length,
+        isRetry,
+        solutionId: solution.solutionId
+    });
+    return manifestContent;
+}
+/**
+ * Direct MCP tool handler for generateManifests functionality
+ */
+async function handleGenerateManifestsTool(args, dotAI, logger, requestId) {
+    return await error_handling_1.ErrorHandler.withErrorHandling(async () => {
+        const maxAttempts = 10;
+        logger.debug('Handling generateManifests request', {
+            requestId,
+            solutionId: args?.solutionId
+        });
+        // Input validation is handled automatically by MCP SDK with Zod schema
+        // args are already validated and typed when we reach this point
+        // Get session directory from environment
+        let sessionDir;
+        try {
+            sessionDir = (0, session_utils_1.getAndValidateSessionDirectory)(args, true); // requireWrite=true for manifest generation
+            logger.debug('Session directory resolved and validated', { sessionDir });
+        }
+        catch (error) {
+            throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.HIGH, error instanceof Error ? error.message : 'Session directory validation failed', {
+                operation: 'session_directory_validation',
+                component: 'GenerateManifestsTool',
+                requestId,
+                suggestedActions: [
+                    'Ensure session directory exists and is writable',
+                    'Check directory permissions',
+                    'Verify the directory path is correct',
+                    'Verify DOT_AI_SESSION_DIR environment variable is correctly set'
+                ]
+            });
+        }
+        // Load solution file
+        let solution;
+        try {
+            solution = loadSolutionFile(args.solutionId, sessionDir);
+            logger.debug('Solution file loaded successfully', {
+                solutionId: args.solutionId,
+                hasQuestions: !!solution.questions,
+                primaryResources: solution.resources
+            });
+        }
+        catch (error) {
+            throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.STORAGE, error_handling_1.ErrorSeverity.HIGH, error instanceof Error ? error.message : 'Failed to load solution file', {
+                operation: 'solution_file_load',
+                component: 'GenerateManifestsTool',
+                requestId,
+                input: { solutionId: args.solutionId, sessionDir },
+                suggestedActions: [
+                    'Check that the solution ID is correct',
+                    'Verify the solution file exists in the session directory',
+                    'Ensure the solution was fully configured with all stages complete',
+                    'List available solution files in the session directory'
+                ]
+            });
+        }
+        // Prepare file path for manifests
+        const yamlPath = path.join(sessionDir, `${args.solutionId}.yaml`);
+        // AI generation and validation loop
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            logger.info('AI manifest generation attempt', {
+                attempt,
+                maxAttempts,
+                isRetry: attempt > 1,
+                requestId
+            });
+            try {
+                // Generate manifests with AI
+                const manifests = await generateManifestsWithAI(solution, dotAI, logger, lastError);
+                // Save manifests to file
+                fs.writeFileSync(yamlPath, manifests, 'utf8');
+                logger.info('Manifests saved to file', { yamlPath, attempt, requestId });
+                // Save a copy of this attempt for debugging
+                const attemptPath = yamlPath.replace('.yaml', `_attempt_${attempt.toString().padStart(2, '0')}.yaml`);
+                fs.writeFileSync(attemptPath, manifests, 'utf8');
+                logger.info('Saved manifest attempt for debugging', {
+                    attempt,
+                    attemptPath,
+                    requestId
+                });
+                // Validate manifests
+                const validation = await validateManifests(yamlPath);
+                if (validation.success) {
+                    logger.info('Manifest validation successful', {
+                        attempt,
+                        yamlPath,
+                        requestId
+                    });
+                    // Success! Return the validated manifests
+                    const response = {
+                        success: true,
+                        status: 'manifests_generated',
+                        solutionId: args.solutionId,
+                        manifests: manifests,
+                        yamlPath: yamlPath,
+                        validationAttempts: attempt,
+                        timestamp: new Date().toISOString()
+                    };
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify(response, null, 2)
+                            }]
+                    };
+                }
+                // Validation failed, prepare error context for next attempt
+                lastError = {
+                    attempt,
+                    previousManifests: manifests,
+                    yamlSyntaxValid: validation.yamlSyntaxValid,
+                    kubectlOutput: validation.kubectlOutput,
+                    exitCode: validation.exitCode,
+                    stderr: validation.stderr,
+                    stdout: validation.stdout
+                };
+                logger.warn('Manifest validation failed', {
+                    attempt,
+                    maxAttempts,
+                    yamlSyntaxValid: validation.yamlSyntaxValid,
+                    kubectlOutput: validation.kubectlOutput,
+                    requestId
+                });
+            }
+            catch (error) {
+                logger.error('Error during manifest generation attempt', error);
+                // If this is the last attempt, throw the error
+                if (attempt === maxAttempts) {
+                    throw error;
+                }
+                // Prepare error context for retry
+                lastError = {
+                    attempt,
+                    previousManifests: lastError?.previousManifests || '',
+                    yamlSyntaxValid: false,
+                    kubectlOutput: error instanceof Error ? error.message : 'Unknown error',
+                    exitCode: -1,
+                    stderr: error instanceof Error ? error.message : 'Unknown error',
+                    stdout: ''
+                };
+            }
+        }
+        // If we reach here, all attempts failed
+        throw new Error(`Failed to generate valid manifests after ${maxAttempts} attempts. Last error: ${lastError?.kubectlOutput}`);
+    }, {
+        operation: 'generate_manifests',
+        component: 'GenerateManifestsTool',
+        requestId,
+        input: args
+    });
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tool Exports Index
+ *
+ * Centralized exports for all available tools (direct handlers)
+ */
+export { RECOMMEND_TOOL_NAME, RECOMMEND_TOOL_DESCRIPTION, RECOMMEND_TOOL_INPUT_SCHEMA, handleRecommendTool } from './recommend';
+export { CHOOSESOLUTION_TOOL_NAME, CHOOSESOLUTION_TOOL_DESCRIPTION, CHOOSESOLUTION_TOOL_INPUT_SCHEMA, handleChooseSolutionTool } from './choose-solution';
+export { ANSWERQUESTION_TOOL_NAME, ANSWERQUESTION_TOOL_DESCRIPTION, ANSWERQUESTION_TOOL_INPUT_SCHEMA, handleAnswerQuestionTool } from './answer-question';
+export { GENERATEMANIFESTS_TOOL_NAME, GENERATEMANIFESTS_TOOL_DESCRIPTION, GENERATEMANIFESTS_TOOL_INPUT_SCHEMA, handleGenerateManifestsTool } from './generate-manifests';
+export { DEPLOYMANIFESTS_TOOL_NAME, DEPLOYMANIFESTS_TOOL_DESCRIPTION, DEPLOYMANIFESTS_TOOL_INPUT_SCHEMA, handleDeployManifestsTool } from './deploy-manifests';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,mBAAmB,EACnB,0BAA0B,EAC1B,2BAA2B,EAC3B,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,wBAAwB,EACxB,+BAA+B,EAC/B,gCAAgC,EAChC,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,wBAAwB,EACxB,+BAA+B,EAC/B,gCAAgC,EAChC,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,2BAA2B,EAC3B,kCAAkC,EAClC,mCAAmC,EACnC,2BAA2B,EAC5B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,yBAAyB,EACzB,gCAAgC,EAChC,iCAAiC,EACjC,yBAAyB,EAC1B,MAAM,oBAAoB,CAAC"}

package/dist/tools/index.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Tool Exports Index
+ *
+ * Centralized exports for all available tools (direct handlers)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDeployManifestsTool = exports.DEPLOYMANIFESTS_TOOL_INPUT_SCHEMA = exports.DEPLOYMANIFESTS_TOOL_DESCRIPTION = exports.DEPLOYMANIFESTS_TOOL_NAME = exports.handleGenerateManifestsTool = exports.GENERATEMANIFESTS_TOOL_INPUT_SCHEMA = exports.GENERATEMANIFESTS_TOOL_DESCRIPTION = exports.GENERATEMANIFESTS_TOOL_NAME = exports.handleAnswerQuestionTool = exports.ANSWERQUESTION_TOOL_INPUT_SCHEMA = exports.ANSWERQUESTION_TOOL_DESCRIPTION = exports.ANSWERQUESTION_TOOL_NAME = exports.handleChooseSolutionTool = exports.CHOOSESOLUTION_TOOL_INPUT_SCHEMA = exports.CHOOSESOLUTION_TOOL_DESCRIPTION = exports.CHOOSESOLUTION_TOOL_NAME = exports.handleRecommendTool = exports.RECOMMEND_TOOL_INPUT_SCHEMA = exports.RECOMMEND_TOOL_DESCRIPTION = exports.RECOMMEND_TOOL_NAME = void 0;
+// Export direct tool handlers for use in MCP server and CLI
+var recommend_1 = require("./recommend");
+Object.defineProperty(exports, "RECOMMEND_TOOL_NAME", { enumerable: true, get: function () { return recommend_1.RECOMMEND_TOOL_NAME; } });
+Object.defineProperty(exports, "RECOMMEND_TOOL_DESCRIPTION", { enumerable: true, get: function () { return recommend_1.RECOMMEND_TOOL_DESCRIPTION; } });
+Object.defineProperty(exports, "RECOMMEND_TOOL_INPUT_SCHEMA", { enumerable: true, get: function () { return recommend_1.RECOMMEND_TOOL_INPUT_SCHEMA; } });
+Object.defineProperty(exports, "handleRecommendTool", { enumerable: true, get: function () { return recommend_1.handleRecommendTool; } });
+var choose_solution_1 = require("./choose-solution");
+Object.defineProperty(exports, "CHOOSESOLUTION_TOOL_NAME", { enumerable: true, get: function () { return choose_solution_1.CHOOSESOLUTION_TOOL_NAME; } });
+Object.defineProperty(exports, "CHOOSESOLUTION_TOOL_DESCRIPTION", { enumerable: true, get: function () { return choose_solution_1.CHOOSESOLUTION_TOOL_DESCRIPTION; } });
+Object.defineProperty(exports, "CHOOSESOLUTION_TOOL_INPUT_SCHEMA", { enumerable: true, get: function () { return choose_solution_1.CHOOSESOLUTION_TOOL_INPUT_SCHEMA; } });
+Object.defineProperty(exports, "handleChooseSolutionTool", { enumerable: true, get: function () { return choose_solution_1.handleChooseSolutionTool; } });
+var answer_question_1 = require("./answer-question");
+Object.defineProperty(exports, "ANSWERQUESTION_TOOL_NAME", { enumerable: true, get: function () { return answer_question_1.ANSWERQUESTION_TOOL_NAME; } });
+Object.defineProperty(exports, "ANSWERQUESTION_TOOL_DESCRIPTION", { enumerable: true, get: function () { return answer_question_1.ANSWERQUESTION_TOOL_DESCRIPTION; } });
+Object.defineProperty(exports, "ANSWERQUESTION_TOOL_INPUT_SCHEMA", { enumerable: true, get: function () { return answer_question_1.ANSWERQUESTION_TOOL_INPUT_SCHEMA; } });
+Object.defineProperty(exports, "handleAnswerQuestionTool", { enumerable: true, get: function () { return answer_question_1.handleAnswerQuestionTool; } });
+var generate_manifests_1 = require("./generate-manifests");
+Object.defineProperty(exports, "GENERATEMANIFESTS_TOOL_NAME", { enumerable: true, get: function () { return generate_manifests_1.GENERATEMANIFESTS_TOOL_NAME; } });
+Object.defineProperty(exports, "GENERATEMANIFESTS_TOOL_DESCRIPTION", { enumerable: true, get: function () { return generate_manifests_1.GENERATEMANIFESTS_TOOL_DESCRIPTION; } });
+Object.defineProperty(exports, "GENERATEMANIFESTS_TOOL_INPUT_SCHEMA", { enumerable: true, get: function () { return generate_manifests_1.GENERATEMANIFESTS_TOOL_INPUT_SCHEMA; } });
+Object.defineProperty(exports, "handleGenerateManifestsTool", { enumerable: true, get: function () { return generate_manifests_1.handleGenerateManifestsTool; } });
+var deploy_manifests_1 = require("./deploy-manifests");
+Object.defineProperty(exports, "DEPLOYMANIFESTS_TOOL_NAME", { enumerable: true, get: function () { return deploy_manifests_1.DEPLOYMANIFESTS_TOOL_NAME; } });
+Object.defineProperty(exports, "DEPLOYMANIFESTS_TOOL_DESCRIPTION", { enumerable: true, get: function () { return deploy_manifests_1.DEPLOYMANIFESTS_TOOL_DESCRIPTION; } });
+Object.defineProperty(exports, "DEPLOYMANIFESTS_TOOL_INPUT_SCHEMA", { enumerable: true, get: function () { return deploy_manifests_1.DEPLOYMANIFESTS_TOOL_INPUT_SCHEMA; } });
+Object.defineProperty(exports, "handleDeployManifestsTool", { enumerable: true, get: function () { return deploy_manifests_1.handleDeployManifestsTool; } });

package/dist/tools/recommend.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Recommend Tool - AI-powered Kubernetes resource recommendations
+ */
+import { z } from 'zod';
+import { DotAI } from '../core/index';
+import { Logger } from '../core/error-handling';
+export declare const RECOMMEND_TOOL_NAME = "recommend";
+export declare const RECOMMEND_TOOL_DESCRIPTION = "Deploy, create, run, or setup applications on Kubernetes with AI-powered recommendations. Ask the user to describe their application first, then use their response here.";
+export declare const RECOMMEND_TOOL_INPUT_SCHEMA: {
+    intent: z.ZodString;
+};
+/**
+ * Direct MCP tool handler for recommend functionality
+ */
+export declare function handleRecommendTool(args: {
+    intent: string;
+}, dotAI: DotAI, logger: Logger, requestId: string): Promise<{
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=recommend.d.ts.map

package/dist/tools/recommend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommend.d.ts","sourceRoot":"","sources":["../../src/tools/recommend.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAOhD,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAC/C,eAAO,MAAM,0BAA0B,8KAA8K,CAAC;AAGtN,eAAO,MAAM,2BAA2B;;CAEvC,CAAC;AAyHF;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EACxB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAC,CA0NxD"}