@vfarcic/dot-ai 0.195.0 → 1.0.0

package/dist/tools/deploy-manifests.js

@@ -3,16 +3,63 @@
  * Deploy Manifests Tool - Apply Kubernetes manifests or execute Helm installations
  * Supports both capability-based solutions (kubectl apply) and Helm-based solutions (helm install)
  */
+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.DEPLOYMANIFESTS_TOOL_INPUT_SCHEMA = exports.DEPLOYMANIFESTS_TOOL_DESCRIPTION = exports.DEPLOYMANIFESTS_TOOL_NAME = void 0;
 exports.handleDeployManifestsTool = handleDeployManifestsTool;
 const zod_1 = require("zod");
 const error_handling_1 = require("../core/error-handling");
 const deploy_operation_1 = require("../core/deploy-operation");
-const cluster_utils_1 = require("../core/cluster-utils");
 const generic_session_manager_1 = require("../core/generic-session-manager");
 const solution_utils_1 = require("../core/solution-utils");
-const helm_utils_1 = require("../core/helm-utils");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// PRD #343: Inline utilities (helm-utils.ts removed - all helm operations via plugin)
+/**
+ * Get the path for Helm values file
+ */
+function getHelmValuesPath(solutionId) {
+    const tmpDir = path.join(process.cwd(), 'tmp');
+    return path.join(tmpDir, `${solutionId}-values.yaml`);
+}
+/**
+ * Check if Helm values file exists for a solution
+ */
+function helmValuesExist(solutionId) {
+    return fs.existsSync(getHelmValuesPath(solutionId));
+}
 // Tool metadata for direct MCP registration
 exports.DEPLOYMANIFESTS_TOOL_NAME = 'deployManifests';
 exports.DEPLOYMANIFESTS_TOOL_DESCRIPTION = 'Deploy Kubernetes manifests from generated solution with kubectl apply --wait';
@@ -23,8 +70,9 @@ exports.DEPLOYMANIFESTS_TOOL_INPUT_SCHEMA = {
 };
 /**
  * Direct MCP tool handler for deployManifests functionality
+ * PRD #343: pluginManager required for kubectl operations
  */
-async function handleDeployManifestsTool(args, dotAI, logger, requestId) {
+async function handleDeployManifestsTool(args, dotAI, logger, requestId, pluginManager) {
     return await error_handling_1.ErrorHandler.withErrorHandling(async () => {
         logger.debug('Handling deployManifests request', {
             requestId,
@@ -33,8 +81,6 @@ async function handleDeployManifestsTool(args, dotAI, logger, requestId) {
         });
         // Input validation is handled automatically by MCP SDK with Zod schema
         // args are already validated and typed when we reach this point
-        // Ensure cluster connectivity before proceeding
-        await (0, cluster_utils_1.ensureClusterConnection)(dotAI, logger, requestId, 'DeployManifestsTool');
         // Load solution session to determine solution type
         const sessionManager = new generic_session_manager_1.GenericSessionManager('sol');
         const session = sessionManager.getSession(args.solutionId);
@@ -63,20 +109,72 @@ async function handleDeployManifestsTool(args, dotAI, logger, requestId) {
             if (!releaseName) {
                 throw new Error('Release name (name) is required for Helm deployment');
             }
-            // Get values path if values file exists
-            const valuesPath = (0, helm_utils_1.helmValuesExist)(args.solutionId)
-                ? (0, helm_utils_1.getHelmValuesPath)(args.solutionId)
-                : undefined;
-            logger.info('Starting Helm deployment', {
+            // Get values content if values file exists
+            // PRD #343: Read values and pass to plugin (no file path to plugin)
+            let valuesYaml;
+            if (helmValuesExist(args.solutionId)) {
+                valuesYaml = fs.readFileSync(getHelmValuesPath(args.solutionId), 'utf8');
+            }
+            logger.info('Starting Helm deployment via plugin', {
                 solutionId: args.solutionId,
                 chart: `${chart.repositoryName}/${chart.chartName}`,
                 releaseName,
                 namespace,
-                hasValuesFile: !!valuesPath,
+                hasValuesFile: !!valuesYaml,
                 timeout,
                 requestId
             });
-            const result = await (0, helm_utils_1.deployHelmRelease)(chart, releaseName, namespace, valuesPath, timeout);
+            // PRD #343: All Helm operations go through plugin system
+            // First, add/update the Helm repository
+            const repoResult = await pluginManager.invokeTool('helm_repo_add', {
+                name: chart.repositoryName,
+                url: chart.repository
+            });
+            if (!repoResult.success) {
+                logger.warn('Helm repo add failed', { error: repoResult.error?.message });
+            }
+            // Deploy using helm_install with wait
+            const installResult = await pluginManager.invokeTool('helm_install', {
+                releaseName,
+                chart: `${chart.repositoryName}/${chart.chartName}`,
+                namespace,
+                values: valuesYaml,
+                version: chart.version,
+                dryRun: false,
+                wait: true,
+                timeout: `${timeout}s`,
+                createNamespace: true
+            });
+            // Check for nested error in result
+            let nestedError;
+            if (installResult.success && typeof installResult.result === 'object' && installResult.result !== null) {
+                const nestedResult = installResult.result;
+                if (nestedResult.success === false) {
+                    nestedError = nestedResult.error || nestedResult.message || 'Helm install failed';
+                }
+            }
+            // Extract only the data field - never pass JSON wrapper
+            let output = '';
+            if (installResult.success && !nestedError) {
+                if (typeof installResult.result === 'object' && installResult.result !== null) {
+                    const resultData = installResult.result;
+                    if (resultData.data !== undefined) {
+                        output = String(resultData.data);
+                    }
+                    else if (typeof resultData === 'string') {
+                        output = resultData;
+                    }
+                    // Don't throw error here - empty output is acceptable for Helm
+                }
+                else {
+                    output = String(installResult.result || '');
+                }
+            }
+            const result = {
+                success: installResult.success && !nestedError,
+                output,
+                error: nestedError || (!installResult.success ? installResult.error?.message : undefined)
+            };
             logger.info('Helm deployment completed', {
                 success: result.success,
                 solutionId: args.solutionId,
@@ -118,10 +216,11 @@ async function handleDeployManifestsTool(args, dotAI, logger, requestId) {
             };
         }
         // Capability-based solution: Use existing DeployOperation
+        // PRD #343: Pass pluginManager for kubectl operations
         logger.info('Using capability-based deployment flow', {
             solutionId: args.solutionId
         });
-        const deployOp = new deploy_operation_1.DeployOperation();
+        const deployOp = new deploy_operation_1.DeployOperation(pluginManager);
         const deployOptions = {
             solutionId: args.solutionId,
             timeout

package/dist/tools/generate-manifests.d.ts

@@ -5,6 +5,7 @@
 import { z } from 'zod';
 import { DotAI } from '../core/index';
 import { Logger } from '../core/error-handling';
+import type { PluginManager } from '../core/plugin-manager';
 export declare const GENERATEMANIFESTS_TOOL_NAME = "generateManifests";
 export declare const GENERATEMANIFESTS_TOOL_DESCRIPTION = "Generate final Kubernetes manifests from fully configured solution (ONLY after completing ALL stages: required, basic, advanced, and open)";
 export declare const GENERATEMANIFESTS_TOOL_INPUT_SCHEMA: {
@@ -13,11 +14,12 @@ export declare const GENERATEMANIFESTS_TOOL_INPUT_SCHEMA: {
 };
 /**
  * Direct MCP tool handler for generateManifests functionality
+ * PRD #343: pluginManager required for kubectl operations
  */
 export declare function handleGenerateManifestsTool(args: {
     solutionId: string;
     interaction_id?: string;
-}, dotAI: DotAI, logger: Logger, requestId: string): Promise<{
+}, dotAI: DotAI, logger: Logger, requestId: string, pluginManager: PluginManager): Promise<{
     content: {
         type: 'text';
         text: string;

package/dist/tools/generate-manifests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-manifests.d.ts","sourceRoot":"","sources":["../../src/tools/generate-manifests.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,KAAK,EAA0B,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AA0BhD,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAC/D,eAAO,MAAM,kCAAkC,+IAA+I,CAAC;AAG/L,eAAO,MAAM,mCAAmC;;;CAG/C,CAAC;AAkvBF;;GAEG;AACH,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,EACrD,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,CAiUxD"}
+{"version":3,"file":"generate-manifests.d.ts","sourceRoot":"","sources":["../../src/tools/generate-manifests.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,KAAK,EAA0B,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAehD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAsD5D,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAC/D,eAAO,MAAM,kCAAkC,+IAA+I,CAAC;AAG/L,eAAO,MAAM,mCAAmC;;;CAG/C,CAAC;AA8xBF;;;GAGG;AACH,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,EACrD,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC;IAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAC,CAiUxD"}

package/dist/tools/generate-manifests.js

@@ -44,7 +44,6 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const error_handling_1 = require("../core/error-handling");
 const index_1 = require("../core/index");
-const cluster_utils_1 = require("../core/cluster-utils");
 const schema_1 = require("../core/schema");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -55,9 +54,45 @@ const solution_utils_1 = require("../core/solution-utils");
 const platform_utils_1 = require("../core/platform-utils");
 const crd_availability_1 = require("../core/crd-availability");
 const solution_cr_1 = require("../core/solution-cr");
-const helm_utils_1 = require("../core/helm-utils");
 const packaging_1 = require("../core/packaging");
 const visualization_1 = require("../core/visualization");
+// PRD #343: Inline utilities (helm-utils.ts removed - all helm operations via plugin)
+/**
+ * Ensure tmp directory exists
+ */
+function ensureTmpDir() {
+    const tmpDir = path.join(process.cwd(), 'tmp');
+    if (!fs.existsSync(tmpDir)) {
+        fs.mkdirSync(tmpDir, { recursive: true });
+    }
+    return tmpDir;
+}
+/**
+ * Get the path for Helm values file
+ */
+function getHelmValuesPath(solutionId) {
+    const tmpDir = path.join(process.cwd(), 'tmp');
+    return path.join(tmpDir, `${solutionId}-values.yaml`);
+}
+/**
+ * Build Helm command string for display to users
+ */
+function buildHelmCommandForDisplay(chart, releaseName, namespace, valuesPath) {
+    const parts = [
+        'helm upgrade --install',
+        releaseName,
+        `${chart.repositoryName}/${chart.chartName}`,
+        `--namespace ${namespace}`,
+        '--create-namespace'
+    ];
+    if (chart.version) {
+        parts.push(`--version ${chart.version}`);
+    }
+    if (valuesPath) {
+        parts.push(`-f ${valuesPath}`);
+    }
+    return parts.join(' ');
+}
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 // Tool metadata for direct MCP registration
 exports.GENERATEMANIFESTS_TOOL_NAME = 'generateManifests';
@@ -182,8 +217,9 @@ async function helmLint(chartDir, logger) {
 }
 /**
  * Validate manifests using multi-layer approach
+ * PRD #343: pluginManager required for kubectl operations
  */
-async function validateManifests(yamlPath) {
+async function validateManifests(yamlPath, pluginManager) {
     // First check if file exists
     if (!fs.existsSync(yamlPath)) {
         return {
@@ -204,7 +240,8 @@ async function validateManifests(yamlPath) {
         };
     }
     // 2. kubectl dry-run validation using ManifestValidator
-    const validator = new schema_1.ManifestValidator();
+    // PRD #343: Pass pluginManager for kubectl operations
+    const validator = new schema_1.ManifestValidator(pluginManager);
     return await validator.validateManifest(yamlPath, { dryRunMode: 'server' });
 }
 /**
@@ -311,34 +348,69 @@ ${errorContext.previousValues}
     return valuesContent;
 }
 /**
- * Validate Helm installation using dry-run (wrapper around shared utility)
+ * Validate Helm installation using dry-run via plugin
+ * PRD #343: All Helm operations go through plugin system
  */
-async function validateHelmInstallation(chart, releaseName, namespace, valuesPath, logger) {
-    logger.info('Running Helm dry-run validation', {
+async function validateHelmInstallation(chart, releaseName, namespace, valuesYaml, logger, pluginManager) {
+    logger.info('Running Helm dry-run validation via plugin', {
         chart: `${chart.repositoryName}/${chart.chartName}`,
         releaseName,
         namespace
     });
-    const result = await (0, helm_utils_1.validateHelmDryRun)(chart, releaseName, namespace, valuesPath);
-    if (result.success) {
-        logger.info('Helm dry-run validation successful');
+    try {
+        // First, add/update the Helm repository
+        const repoResult = await pluginManager.invokeTool('helm_repo_add', {
+            name: chart.repositoryName,
+            url: chart.repository
+        });
+        if (!repoResult.success) {
+            logger.warn('Helm repo add failed', { error: repoResult.error?.message });
+            return {
+                valid: false,
+                errors: [repoResult.error?.message || 'Failed to add Helm repository'],
+                warnings: []
+            };
+        }
+        // Run helm install with dry-run
+        const installResult = await pluginManager.invokeTool('helm_install', {
+            releaseName,
+            chart: `${chart.repositoryName}/${chart.chartName}`,
+            namespace,
+            values: valuesYaml,
+            version: chart.version,
+            dryRun: true,
+            createNamespace: true
+        });
+        if (installResult.success) {
+            logger.info('Helm dry-run validation successful');
+            return {
+                valid: true,
+                errors: [],
+                warnings: []
+            };
+        }
+        logger.warn('Helm dry-run validation failed', { error: installResult.error?.message });
         return {
-            valid: true,
-            errors: [],
+            valid: false,
+            errors: [installResult.error?.message || 'Unknown Helm validation error'],
+            warnings: []
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error('Helm validation error', error);
+        return {
+            valid: false,
+            errors: [errorMessage],
             warnings: []
         };
     }
-    logger.warn('Helm dry-run validation failed', { error: result.error });
-    return {
-        valid: false,
-        errors: [result.error || 'Unknown Helm validation error'],
-        warnings: []
-    };
 }
 /**
  * Handle Helm solution generation
+ * PRD #343: pluginManager required for Helm operations
  */
-async function handleHelmGeneration(solution, solutionId, dotAI, logger, requestId, sessionManager, interaction_id) {
+async function handleHelmGeneration(solution, solutionId, dotAI, logger, requestId, sessionManager, pluginManager, interaction_id) {
     const maxAttempts = 10;
     const chart = solution.chart;
     const userAnswers = (0, solution_utils_1.extractUserAnswers)(solution);
@@ -354,8 +426,8 @@ async function handleHelmGeneration(solution, solutionId, dotAI, logger, request
         });
     }
     // Prepare file paths using shared utilities
-    (0, helm_utils_1.ensureTmpDir)();
-    const valuesPath = (0, helm_utils_1.getHelmValuesPath)(solutionId);
+    ensureTmpDir();
+    const valuesPath = getHelmValuesPath(solutionId);
     // AI generation and validation loop
     let lastError;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -375,8 +447,9 @@ async function handleHelmGeneration(solution, solutionId, dotAI, logger, request
             // Save attempt for debugging
             const attemptPath = valuesPath.replace('.yaml', `_attempt_${attempt.toString().padStart(2, '0')}.yaml`);
             fs.writeFileSync(attemptPath, valuesYaml, 'utf8');
-            // Validate with helm dry-run
-            const validation = await validateHelmInstallation(chart, releaseName, namespace, valuesPath, logger);
+            // Validate with helm dry-run via plugin
+            // PRD #343: Pass values content directly to plugin (no file path needed)
+            const validation = await validateHelmInstallation(chart, releaseName, namespace, valuesYaml, logger, pluginManager);
             if (validation.valid) {
                 logger.info('Helm validation successful', {
                     attempt,
@@ -385,7 +458,7 @@ async function handleHelmGeneration(solution, solutionId, dotAI, logger, request
                 });
                 // Build user-friendly helm command with generic values file path
                 // (internal valuesPath is used for actual execution, not shown to user)
-                const helmCommand = (0, helm_utils_1.buildHelmCommand)(chart, releaseName, namespace, 'values.yaml');
+                const helmCommand = buildHelmCommandForDisplay(chart, releaseName, namespace, 'values.yaml');
                 // PRD #320: Update session with generateManifests data for visualization
                 sessionManager.updateSession(solutionId, {
                     ...solution,
@@ -528,8 +601,9 @@ function writePackageFiles(files, baseDir) {
 }
 /**
  * Package manifests and validate the output
+ * PRD #343: pluginManager required for kubectl operations
  */
-async function packageAndValidate(rawManifests, solution, outputFormat, outputPath, solutionId, dotAI, logger, interaction_id) {
+async function packageAndValidate(rawManifests, solution, outputFormat, outputPath, solutionId, dotAI, logger, pluginManager, interaction_id) {
     const maxAttempts = 5;
     let packagingError;
     const tmpDir = path.join(process.cwd(), 'tmp');
@@ -597,7 +671,7 @@ async function packageAndValidate(rawManifests, solution, outputFormat, outputPa
                 throw new Error('Render succeeded but no YAML content returned');
             }
             fs.writeFileSync(renderedYamlPath, renderResult.yaml, 'utf8');
-            const validation = await validateManifests(renderedYamlPath);
+            const validation = await validateManifests(renderedYamlPath, pluginManager);
             if (validation.valid) {
                 logger.info('Package validation successful', { format: outputFormat, attempt });
                 cleanupPackageDir();
@@ -628,8 +702,9 @@ async function packageAndValidate(rawManifests, solution, outputFormat, outputPa
 }
 /**
  * Direct MCP tool handler for generateManifests functionality
+ * PRD #343: pluginManager required for kubectl operations
  */
-async function handleGenerateManifestsTool(args, dotAI, logger, requestId) {
+async function handleGenerateManifestsTool(args, dotAI, logger, requestId, pluginManager) {
     return await error_handling_1.ErrorHandler.withErrorHandling(async () => {
         const maxAttempts = 10;
         logger.debug('Handling generateManifests request', {
@@ -641,8 +716,6 @@ async function handleGenerateManifestsTool(args, dotAI, logger, requestId) {
         // Initialize session manager
         const sessionManager = new generic_session_manager_1.GenericSessionManager('sol');
         logger.debug('Session manager initialized', { requestId });
-        // Ensure cluster connectivity before proceeding
-        await (0, cluster_utils_1.ensureClusterConnection)(dotAI, logger, requestId, 'GenerateManifestsTool');
         // Load solution session
         const session = sessionManager.getSession(args.solutionId);
         if (!session) {
@@ -672,7 +745,7 @@ async function handleGenerateManifestsTool(args, dotAI, logger, requestId) {
                 solutionId: args.solutionId,
                 chart: solution.chart ? `${solution.chart.repositoryName}/${solution.chart.chartName}` : 'unknown'
             });
-            return await handleHelmGeneration(solution, args.solutionId, dotAI, logger, requestId, sessionManager, args.interaction_id);
+            return await handleHelmGeneration(solution, args.solutionId, dotAI, logger, requestId, sessionManager, pluginManager, args.interaction_id);
         }
         // Capability-based solution: Generate Kubernetes manifests
         logger.info('Using capability-based manifest generation flow', {
@@ -702,7 +775,7 @@ async function handleGenerateManifestsTool(args, dotAI, logger, requestId) {
                 // Check if Solution CRD is available and generate Solution CR if present
                 let solutionCR = '';
                 try {
-                    const crdAvailable = await (0, crd_availability_1.isSolutionCRDAvailable)();
+                    const crdAvailable = await (0, crd_availability_1.isSolutionCRDAvailable)(pluginManager);
                     if (crdAvailable) {
                         solutionCR = (0, solution_cr_1.generateSolutionCR)({
                             solutionId: args.solutionId,
@@ -742,7 +815,8 @@ async function handleGenerateManifestsTool(args, dotAI, logger, requestId) {
                     requestId
                 });
                 // Validate manifests
-                const validation = await validateManifests(yamlPath);
+                // PRD #343: Pass pluginManager for kubectl operations
+                const validation = await validateManifests(yamlPath, pluginManager);
                 if (validation.valid) {
                     logger.info('Manifest validation successful', {
                         attempt,
@@ -754,7 +828,7 @@ async function handleGenerateManifestsTool(args, dotAI, logger, requestId) {
                     const outputPath = userAnswers.outputPath || './manifests';
                     // Handle packaging based on outputFormat
                     if (outputFormat === 'helm' || outputFormat === 'kustomize') {
-                        const packagingResult = await packageAndValidate(manifests, solution, outputFormat, outputPath, args.solutionId, dotAI, logger, args.interaction_id);
+                        const packagingResult = await packageAndValidate(manifests, solution, outputFormat, outputPath, args.solutionId, dotAI, logger, pluginManager, args.interaction_id);
                         // PRD #320: Update session with generateManifests data for visualization
                         sessionManager.updateSession(args.solutionId, {
                             ...solution,

package/dist/tools/operate-analysis.d.ts

@@ -1,15 +1,19 @@
 import { GenericSessionManager } from '../core/generic-session-manager';
+import { PluginManager } from '../core/plugin-manager';
 import { Logger } from '../core/error-handling';
 import { OperateSessionData } from './operate';
 /**
  * Analyzes user intent and generates operational proposal using AI tool loop
  *
+ * PRD #343: pluginManager is required - all kubectl operations go through plugin.
+ *
  * @param intent - User's operational intent (e.g., "update my-api to v2.0")
  * @param logger - Logger instance
  * @param sessionManager - Session manager instance
+ * @param pluginManager - Plugin manager for kubectl operations
  * @param sessionId - Optional session ID for refinement
  * @param interaction_id - Optional interaction ID for eval datasets
  * @returns Operation output with proposed changes
  */
-export declare function analyzeIntent(intent: string, logger: Logger, sessionManager: GenericSessionManager<OperateSessionData>, sessionId?: string, interaction_id?: string): Promise<any>;
+export declare function analyzeIntent(intent: string, logger: Logger, sessionManager: GenericSessionManager<OperateSessionData>, pluginManager: PluginManager, sessionId?: string, interaction_id?: string): Promise<any>;
 //# sourceMappingURL=operate-analysis.d.ts.map

package/dist/tools/operate-analysis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operate-analysis.d.ts","sourceRoot":"","sources":["../../src/tools/operate-analysis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAGxE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGhD,OAAO,EAEL,kBAAkB,EAMnB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,qBAAqB,CAAC,kBAAkB,CAAC,EACzD,SAAS,CAAC,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,GAAG,CAAC,CAoDd"}
+{"version":3,"file":"operate-analysis.d.ts","sourceRoot":"","sources":["../../src/tools/operate-analysis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGhD,OAAO,EAEL,kBAAkB,EAMnB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,qBAAqB,CAAC,kBAAkB,CAAC,EACzD,aAAa,EAAE,aAAa,EAC5B,SAAS,CAAC,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,GAAG,CAAC,CAoDd"}

package/dist/tools/operate-analysis.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeIntent = analyzeIntent;
-const kubectl_tools_1 = require("../core/kubectl-tools");
 const ai_provider_factory_1 = require("../core/ai-provider-factory");
 const shared_prompt_loader_1 = require("../core/shared-prompt-loader");
 const visualization_1 = require("../core/visualization");
@@ -9,22 +8,25 @@ const operate_1 = require("./operate");
 /**
  * Analyzes user intent and generates operational proposal using AI tool loop
  *
+ * PRD #343: pluginManager is required - all kubectl operations go through plugin.
+ *
  * @param intent - User's operational intent (e.g., "update my-api to v2.0")
  * @param logger - Logger instance
  * @param sessionManager - Session manager instance
+ * @param pluginManager - Plugin manager for kubectl operations
  * @param sessionId - Optional session ID for refinement
  * @param interaction_id - Optional interaction ID for eval datasets
  * @returns Operation output with proposed changes
  */
-async function analyzeIntent(intent, logger, sessionManager, sessionId, interaction_id) {
+async function analyzeIntent(intent, logger, sessionManager, pluginManager, sessionId, interaction_id) {
     logger.info('Starting operate analysis', { intent, sessionId });
     // 1. Embed context (patterns, policies, capabilities)
     const context = await (0, operate_1.embedContext)(intent, logger);
     // 2. Load prompts (static system + dynamic user message)
     const systemPrompt = loadSystemPrompt();
     const userMessage = buildUserMessage(intent, context);
-    // 3. Execute AI tool loop with kubectl tools
-    const aiResult = await executeToolLoop(systemPrompt, userMessage, logger, interaction_id);
+    // 3. Execute AI tool loop with kubectl tools (PRD #343: via plugin)
+    const aiResult = await executeToolLoop(systemPrompt, userMessage, logger, pluginManager, interaction_id);
     // 4. Parse AI response into structured format
     const proposedChanges = parseAIResponse(aiResult, logger);
     // 5. Create and save session
@@ -77,25 +79,53 @@ function buildUserMessage(intent, context) {
         capabilities: capabilitiesText
     });
 }
+/** Kubectl tool names for investigation and dry-run validation */
+const KUBECTL_INVESTIGATION_TOOL_NAMES = [
+    'kubectl_get',
+    'kubectl_describe',
+    'kubectl_logs',
+    'kubectl_events',
+    'kubectl_api_resources',
+    'kubectl_get_crd_schema',
+    'kubectl_get_resource_json',
+    // Dry-run tools for validation
+    'kubectl_patch_dryrun',
+    'kubectl_apply_dryrun',
+    'kubectl_delete_dryrun'
+];
 /**
  * Executes AI tool loop with kubectl investigation tools
  * AI autonomously inspects cluster and validates changes with dry-run
  *
+ * PRD #343: Kubectl tools are routed through the plugin system.
+ *
  * @param systemPrompt - Static instructions (cacheable)
  * @param userMessage - Dynamic content with intent and context
  * @param logger - Logger instance
+ * @param pluginManager - Plugin manager for kubectl operations
  * @param interaction_id - Optional interaction ID for eval datasets
  * @returns AI's final response
  * @throws Error if AI fails to converge within 30 iterations
  */
-async function executeToolLoop(systemPrompt, userMessage, logger, interaction_id) {
+async function executeToolLoop(systemPrompt, userMessage, logger, pluginManager, interaction_id) {
     logger.debug('Starting AI tool loop for operate analysis');
+    // PRD #343: Get kubectl tools from plugin
+    const kubectlTools = pluginManager.getDiscoveredTools().filter(t => KUBECTL_INVESTIGATION_TOOL_NAMES.includes(t.name));
+    if (kubectlTools.length === 0) {
+        throw new Error('No kubectl tools available from plugin. Ensure agentic-tools plugin is running.');
+    }
+    logger.debug('Using kubectl tools from plugin', {
+        toolCount: kubectlTools.length,
+        tools: kubectlTools.map(t => t.name)
+    });
+    // PRD #343: Create tool executor that routes through plugin
+    const toolExecutor = pluginManager.createToolExecutor();
     const aiProvider = (0, ai_provider_factory_1.createAIProvider)();
     const result = await aiProvider.toolLoop({
         systemPrompt,
         userMessage,
-        tools: kubectl_tools_1.KUBECTL_INVESTIGATION_TOOLS,
-        toolExecutor: kubectl_tools_1.executeKubectlTools,
+        tools: kubectlTools,
+        toolExecutor: toolExecutor,
         maxIterations: 30,
         operation: 'operate-analysis',
         evaluationContext: {

package/dist/tools/operate-execution.d.ts

@@ -6,13 +6,15 @@
  */
 import { Logger } from '../core/error-handling';
 import { GenericSessionManager } from '../core/generic-session-manager';
+import { PluginManager } from '../core/plugin-manager';
 import { OperateSessionData, OperateOutput } from './operate';
 /**
  * Executes approved operational changes
  * @param sessionId - Session ID with approved changes
  * @param logger - Logger instance
  * @param sessionManager - Session manager instance
+ * @param pluginManager - Plugin manager for kubectl operations (PRD #343)
  * @returns Operation output with execution results
  */
-export declare function executeOperations(sessionId: string, logger: Logger, sessionManager: GenericSessionManager<OperateSessionData>): Promise<OperateOutput>;
+export declare function executeOperations(sessionId: string, logger: Logger, sessionManager: GenericSessionManager<OperateSessionData>, pluginManager: PluginManager): Promise<OperateOutput>;
 //# sourceMappingURL=operate-execution.d.ts.map

package/dist/tools/operate-execution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operate-execution.d.ts","sourceRoot":"","sources":["../../src/tools/operate-execution.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAA8C,MAAM,wBAAwB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAExE,OAAO,EAAE,kBAAkB,EAAmB,aAAa,EAAE,MAAM,WAAW,CAAC;AAG/E;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,qBAAqB,CAAC,kBAAkB,CAAC,GACxD,OAAO,CAAC,aAAa,CAAC,CAwIxB"}
+{"version":3,"file":"operate-execution.d.ts","sourceRoot":"","sources":["../../src/tools/operate-execution.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAA8C,MAAM,wBAAwB,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAExE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAmB,aAAa,EAAE,MAAM,WAAW,CAAC;AAG/E;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,qBAAqB,CAAC,kBAAkB,CAAC,EACzD,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,aAAa,CAAC,CA0IxB"}

package/dist/tools/operate-execution.js

@@ -15,9 +15,10 @@ const remediate_1 = require("./remediate");
  * @param sessionId - Session ID with approved changes
  * @param logger - Logger instance
  * @param sessionManager - Session manager instance
+ * @param pluginManager - Plugin manager for kubectl operations (PRD #343)
  * @returns Operation output with execution results
  */
-async function executeOperations(sessionId, logger, sessionManager) {
+async function executeOperations(sessionId, logger, sessionManager, pluginManager) {
     logger.info('Starting operation execution', { sessionId });
     try {
         // 1. Load session with approved commands
@@ -36,8 +37,8 @@ async function executeOperations(sessionId, logger, sessionManager) {
             commandCount: session.data.commands.length,
             intent: session.data.intent
         });
-        // 2. Execute commands using shared executor
-        const { results, overallSuccess } = await (0, command_executor_1.executeCommands)(session.data.commands, logger, {
+        // 2. Execute commands using shared executor (PRD #343: via plugin)
+        const { results, overallSuccess } = await (0, command_executor_1.executeCommands)(session.data.commands, logger, pluginManager, {
             sessionId,
             context: 'operation',
             logMetadata: { intent: session.data.intent }
@@ -59,11 +60,12 @@ async function executeOperations(sessionId, logger, sessionManager) {
             });
             try {
                 // Call remediate tool internally with validation intent
+                // PRD #343: Pass pluginManager for kubectl operations
                 const validationResponse = await (0, remediate_1.handleRemediateTool)({
                     issue: session.data.validationIntent,
                     executedCommands: session.data.commands,
                     interaction_id: session.data.interaction_id
-                });
+                }, pluginManager);
                 // Extract validation result from remediate response
                 const validationData = JSON.parse(validationResponse.content[0].text);
                 if (validationData.status === 'resolved' || validationData.status === 'no_issue_found') {