@vfarcic/dot-ai 0.138.0 → 0.140.0

package/dist/tools/choose-solution.js

@@ -2,78 +2,20 @@
 /**
  * Choose Solution Tool - Select a solution and return its questions
  */
-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.CHOOSESOLUTION_TOOL_INPUT_SCHEMA = exports.CHOOSESOLUTION_TOOL_DESCRIPTION = exports.CHOOSESOLUTION_TOOL_NAME = void 0;
 exports.handleChooseSolutionTool = handleChooseSolutionTool;
 const zod_1 = require("zod");
 const error_handling_1 = require("../core/error-handling");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const session_utils_1 = require("../core/session-utils");
+const generic_session_manager_1 = require("../core/generic-session-manager");
 // Tool metadata for direct MCP registration
 exports.CHOOSESOLUTION_TOOL_NAME = 'chooseSolution';
 exports.CHOOSESOLUTION_TOOL_DESCRIPTION = 'Select a solution by ID and return its questions for configuration';
 // Zod schema for MCP registration
 exports.CHOOSESOLUTION_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 choose (e.g., sol_2025-07-01T154349_1e1e242592ff)')
+    solutionId: zod_1.z.string().regex(/^sol-\d+-[a-f0-9]{8}$/).describe('The solution ID to choose (e.g., sol-1762983784617-9ddae2b8)')
 };
-/**
- * Load solution file by ID
- */
-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);
-        // Validate solution structure
-        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}. ${error.message}`);
-        }
-        throw error;
-    }
-}
+// Session management now handled by GenericSessionManager
 /**
  * Direct MCP tool handler for chooseSolution functionality
  */
@@ -82,29 +24,26 @@ async function handleChooseSolutionTool(args, dotAI, logger, requestId) {
         logger.debug('Handling chooseSolution 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)(false); // requireWrite=false
-            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',
+        // Initialize session manager
+        const sessionManager = new generic_session_manager_1.GenericSessionManager('sol');
+        logger.debug('Session manager initialized', { requestId });
+        // Load solution session
+        const session = sessionManager.getSession(args.solutionId);
+        if (!session) {
+            throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.HIGH, `Solution not found: ${args.solutionId}`, {
+                operation: 'solution_loading',
                 component: 'ChooseSolutionTool',
                 requestId,
+                input: { solutionId: args.solutionId },
                 suggestedActions: [
-                    'Ensure session directory exists and is readable',
-                    'Check directory permissions',
-                    'Verify the directory path is correct',
-                    'Verify DOT_AI_SESSION_DIR environment variable is correctly set'
+                    'Verify the solution ID is correct',
+                    'Ensure the solution was created by the recommend tool',
+                    'Check that the session has not expired'
                 ]
             });
         }
-        // Load solution file
-        let solution;
+        const solution = session.data;
         try {
-            solution = loadSolutionFile(args.solutionId, sessionDir);
             logger.debug('Solution file loaded successfully', {
                 solutionId: args.solutionId,
                 hasQuestions: !!solution.questions,
@@ -117,23 +56,22 @@ async function handleChooseSolutionTool(args, dotAI, logger, requestId) {
             });
         }
         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',
+            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 session', {
+                operation: 'solution_session_load',
                 component: 'ChooseSolutionTool',
                 requestId,
-                input: { solutionId: args.solutionId, sessionDir },
+                input: { solutionId: args.solutionId },
                 suggestedActions: [
                     'Check that the solution ID is correct',
-                    'Verify the solution file exists in the session directory',
-                    'Ensure the solution was created by a recent recommend tool call',
-                    'List available solution files in the session directory'
+                    'Verify the solution session exists',
+                    'Ensure the solution was created by a recent recommend tool call'
                 ]
             });
         }
         // Prepare response with solution details and questions
         const response = {
             status: 'stage_questions',
-            solutionId: solution.solutionId,
+            solutionId: args.solutionId,
             currentStage: 'required',
             questions: solution.questions.required || [],
             nextStage: 'basic',
@@ -144,7 +82,6 @@ async function handleChooseSolutionTool(args, dotAI, logger, requestId) {
         };
         logger.info('Choose solution completed successfully', {
             solutionId: args.solutionId,
-            sessionDir,
             questionCategories: {
                 required: solution.questions.required?.length || 0,
                 basic: solution.questions.basic?.length || 0,

package/dist/tools/deploy-manifests.js

@@ -14,7 +14,7 @@ exports.DEPLOYMANIFESTS_TOOL_NAME = 'deployManifests';
 exports.DEPLOYMANIFESTS_TOOL_DESCRIPTION = 'Deploy Kubernetes manifests from generated solution with kubectl apply --wait';
 // Zod schema for MCP registration
 exports.DEPLOYMANIFESTS_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('Solution ID to deploy (e.g., sol_2025-07-01T154349_1e1e242592ff)'),
+    solutionId: zod_1.z.string().regex(/^sol-\d+-[a-f0-9]{8}$/).describe('Solution ID to deploy (e.g., sol-1762983784617-9ddae2b8)'),
     timeout: zod_1.z.number().min(1).max(600).optional().describe('Deployment timeout in seconds (default: 30)')
 };
 /**

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;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAYhD,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAC/D,eAAO,MAAM,kCAAkC,+IAA+I,CAAC;AAG/L,eAAO,MAAM,mCAAmC;;;CAG/C,CAAC;AAyRF;;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,CAsMxD"}
+{"version":3,"file":"generate-manifests.d.ts","sourceRoot":"","sources":["../../src/tools/generate-manifests.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAahD,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAC/D,eAAO,MAAM,kCAAkC,+IAA+I,CAAC;AAG/L,eAAO,MAAM,mCAAmC;;;CAG/C,CAAC;AA2PF;;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,CAwLxD"}

package/dist/tools/generate-manifests.js

@@ -46,7 +46,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const shared_prompt_loader_1 = require("../core/shared-prompt-loader");
 const yaml = __importStar(require("js-yaml"));
-const session_utils_1 = require("../core/session-utils");
+const generic_session_manager_1 = require("../core/generic-session-manager");
 const solution_utils_1 = require("../core/solution-utils");
 const platform_utils_1 = require("../core/platform-utils");
 // Tool metadata for direct MCP registration
@@ -54,32 +54,9 @@ 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)'),
+    solutionId: zod_1.z.string().regex(/^sol-\d+-[a-f0-9]{8}$/).describe('The solution ID to generate manifests for (e.g., sol-1762983784617-9ddae2b8)'),
     interaction_id: zod_1.z.string().optional().describe('INTERNAL ONLY - Do not populate. Used for evaluation dataset generation.')
 };
-/**
- * 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
  */
@@ -181,7 +158,7 @@ async function validateManifests(yamlPath) {
 /**
  * Generate manifests using AI provider
  */
-async function generateManifestsWithAI(solution, dotAI, logger, errorContext, dotAiLabels, interaction_id) {
+async function generateManifestsWithAI(solution, solutionId, dotAI, logger, errorContext, dotAiLabels, interaction_id) {
     // Retrieve schemas for solution resources
     const resourceSchemas = await retrieveResourceSchemas(solution, dotAI, logger);
     // Prepare template variables
@@ -212,7 +189,7 @@ ${errorContext.previousManifests}
         isRetry,
         attempt: errorContext?.attempt,
         hasErrorContext: !!errorContext,
-        solutionId: solution.solutionId
+        solutionId
     });
     // Get AI provider from dotAI
     const aiProvider = dotAI.ai;
@@ -227,17 +204,16 @@ ${errorContext.previousManifests}
     logger.info('AI manifest generation completed', {
         manifestLength: manifestContent.length,
         isRetry,
-        solutionId: solution.solutionId
+        solutionId
     });
     return manifestContent;
 }
 /**
  * Generate dot-ai application metadata ConfigMap
  */
-function generateMetadataConfigMap(solution, userAnswers, logger) {
+function generateMetadataConfigMap(solution, solutionId, userAnswers, logger) {
     const appName = userAnswers.name;
     const namespace = userAnswers.namespace || 'default';
-    const solutionId = solution.solutionId;
     const originalIntent = solution.intent;
     // Validate required fields (will throw if missing)
     const dotAiLabels = (0, solution_utils_1.addDotAiLabels)(undefined, userAnswers, solution);
@@ -294,53 +270,39 @@ async function handleGenerateManifestsTool(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
-        // Get session directory from environment
-        let sessionDir;
-        try {
-            sessionDir = (0, session_utils_1.getAndValidateSessionDirectory)(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'
-                ]
-            });
-        }
+        // 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 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',
+        // Load solution session
+        const session = sessionManager.getSession(args.solutionId);
+        if (!session) {
+            throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.HIGH, `Solution not found: ${args.solutionId}`, {
+                operation: 'solution_loading',
                 component: 'GenerateManifestsTool',
                 requestId,
-                input: { solutionId: args.solutionId, sessionDir },
+                input: { solutionId: args.solutionId },
                 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'
+                    'Verify the solution ID is correct',
+                    'Ensure the solution was created by the recommend tool',
+                    'Ensure all configuration stages were completed',
+                    'Check that the session has not expired'
                 ]
             });
         }
-        // Prepare file path for manifests
-        const yamlPath = path.join(sessionDir, `${args.solutionId}.yaml`);
+        const solution = session.data;
+        logger.debug('Solution loaded successfully', {
+            solutionId: args.solutionId,
+            hasQuestions: !!solution.questions,
+            primaryResources: solution.resources
+        });
+        // Prepare file path for manifests (store in tmp directory)
+        const tmpDir = path.join(process.cwd(), 'tmp');
+        if (!fs.existsSync(tmpDir)) {
+            fs.mkdirSync(tmpDir, { recursive: true });
+        }
+        const yamlPath = path.join(tmpDir, `${args.solutionId}.yaml`);
         // AI generation and validation loop
         let lastError;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -355,9 +317,9 @@ async function handleGenerateManifestsTool(args, dotAI, logger, requestId) {
                 const userAnswers = (0, solution_utils_1.extractUserAnswers)(solution);
                 const dotAiLabels = (0, solution_utils_1.addDotAiLabels)(undefined, userAnswers, solution);
                 // Generate manifests with AI (including labels)
-                const aiManifests = await generateManifestsWithAI(solution, dotAI, logger, lastError, dotAiLabels, args.interaction_id);
+                const aiManifests = await generateManifestsWithAI(solution, args.solutionId, dotAI, logger, lastError, dotAiLabels, args.interaction_id);
                 // Generate metadata ConfigMap
-                const metadataConfigMap = generateMetadataConfigMap(solution, userAnswers, logger);
+                const metadataConfigMap = generateMetadataConfigMap(solution, args.solutionId, userAnswers, logger);
                 // Combine ConfigMap with AI-generated manifests
                 const manifests = metadataConfigMap + '---\n' + aiManifests;
                 // Save manifests to file

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

@@ -0,0 +1,15 @@
+import { GenericSessionManager } from '../core/generic-session-manager';
+import { Logger } from '../core/error-handling';
+import { OperateSessionData } from './operate';
+/**
+ * Analyzes user intent and generates operational proposal using AI tool loop
+ *
+ * @param intent - User's operational intent (e.g., "update my-api to v2.0")
+ * @param logger - Logger instance
+ * @param sessionManager - Session manager instance
+ * @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>;
+//# sourceMappingURL=operate-analysis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operate-analysis.d.ts","sourceRoot":"","sources":["../../src/tools/operate-analysis.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAGxE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,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,CAgDd"}

package/dist/tools/operate-analysis.js

@@ -0,0 +1,238 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeIntent = analyzeIntent;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const kubectl_tools_1 = require("../core/kubectl-tools");
+const ai_provider_factory_1 = require("../core/ai-provider-factory");
+const operate_1 = require("./operate");
+/**
+ * Analyzes user intent and generates operational proposal using AI tool loop
+ *
+ * @param intent - User's operational intent (e.g., "update my-api to v2.0")
+ * @param logger - Logger instance
+ * @param sessionManager - Session manager instance
+ * @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) {
+    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);
+    // 4. Parse AI response into structured format
+    const proposedChanges = parseAIResponse(aiResult, logger);
+    // 5. Create and save session
+    const session = await saveAnalysisSession(intent, context, proposedChanges, sessionManager, sessionId, interaction_id, logger);
+    logger.info('Operate analysis complete', { sessionId: session.sessionId });
+    // 6. Return formatted output for user
+    return {
+        status: 'awaiting_user_approval',
+        sessionId: session.sessionId,
+        analysis: {
+            summary: proposedChanges.analysis,
+            currentState: proposedChanges.currentState,
+            proposedChanges: session.data.proposedChanges,
+            commands: session.data.commands,
+            dryRunValidation: session.data.dryRunValidation,
+            patternsApplied: session.data.patternsApplied,
+            capabilitiesUsed: session.data.capabilitiesUsed,
+            policiesChecked: session.data.policiesChecked,
+            risks: session.data.risks,
+            validationIntent: session.data.validationIntent
+        },
+        message: 'Operational proposal generated successfully. Review changes and execute with operate(sessionId, executeChoice=1).',
+        nextAction: `Review the proposed changes and call operate({ sessionId: "${session.sessionId}", executeChoice: 1 }) to execute.`
+    };
+}
+/**
+ * Loads static system prompt from prompts/operate-system.md
+ * This prompt is cacheable across all operate calls
+ */
+function loadSystemPrompt() {
+    const promptPath = path_1.default.join(process.cwd(), 'prompts', 'operate-system.md');
+    return fs_1.default.readFileSync(promptPath, 'utf8');
+}
+/**
+ * Builds dynamic user message with intent and embedded context
+ * Uses template from prompts/operate-user.md and formatting functions from operate.ts
+ */
+function buildUserMessage(intent, context) {
+    const templatePath = path_1.default.join(process.cwd(), 'prompts', 'operate-user.md');
+    const template = fs_1.default.readFileSync(templatePath, 'utf8');
+    // Format context sections using shared formatting functions
+    const patternsText = (0, operate_1.formatPatterns)(context.patterns);
+    const policiesText = (0, operate_1.formatPolicies)(context.policies);
+    const capabilitiesText = (0, operate_1.formatCapabilities)(context.capabilities);
+    // Replace template placeholders (use double braces to match template syntax)
+    return template
+        .replace('{{intent}}', intent)
+        .replace('{{patterns}}', patternsText)
+        .replace('{{policies}}', policiesText)
+        .replace('{{capabilities}}', capabilitiesText);
+}
+/**
+ * Executes AI tool loop with kubectl investigation tools
+ * AI autonomously inspects cluster and validates changes with dry-run
+ *
+ * @param systemPrompt - Static instructions (cacheable)
+ * @param userMessage - Dynamic content with intent and context
+ * @param logger - Logger instance
+ * @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) {
+    logger.debug('Starting AI tool loop for operate analysis');
+    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,
+        maxIterations: 30,
+        operation: 'operate-analysis',
+        evaluationContext: {
+            user_intent: userMessage.substring(0, 200) // First 200 chars as context
+        },
+        interaction_id
+    });
+    logger.debug('AI tool loop completed', {
+        iterations: result.iterations,
+        toolCallsExecuted: result.toolCallsExecuted.length,
+        responseLength: result.finalMessage.length
+    });
+    return result.finalMessage;
+}
+/**
+ * Parses AI response into structured ProposedChanges format
+ * Enforces strict JSON parsing with validation
+ *
+ * @param response - AI's final response
+ * @param logger - Logger instance
+ * @returns Parsed proposed changes
+ * @throws Error if response is not valid JSON or missing required fields
+ */
+function parseAIResponse(response, logger) {
+    logger.debug('Parsing AI response');
+    // Extract JSON from code block
+    const jsonMatch = response.match(/```json\n([\s\S]+?)\n```/);
+    if (!jsonMatch) {
+        const truncatedResponse = response.substring(0, 500);
+        logger.error(`AI response missing JSON code block. Response: ${truncatedResponse}`);
+        throw new Error('AI did not return structured JSON response. Expected ```json code block with proposal.');
+    }
+    try {
+        const parsed = JSON.parse(jsonMatch[1]);
+        // Validate required fields
+        if (!parsed.analysis || typeof parsed.analysis !== 'string') {
+            throw new Error('AI response missing required "analysis" field (string)');
+        }
+        if (!parsed.commands || !Array.isArray(parsed.commands)) {
+            throw new Error('AI response missing required "commands" array');
+        }
+        if (parsed.commands.length === 0) {
+            throw new Error('AI response has empty "commands" array - no operations proposed');
+        }
+        if (!parsed.dryRunValidation || typeof parsed.dryRunValidation !== 'object') {
+            throw new Error('AI response missing required "dryRunValidation" object');
+        }
+        // Trust AI's claim but log for audit trail
+        logger.info('AI dry-run validation status', {
+            validation: parsed.dryRunValidation,
+            status: parsed.dryRunValidation.status
+        });
+        // Ensure proposedChanges structure exists
+        if (!parsed.proposedChanges) {
+            parsed.proposedChanges = { create: [], update: [], delete: [] };
+        }
+        // Validate proposedChanges structure
+        const changes = parsed.proposedChanges;
+        if (!Array.isArray(changes.create))
+            changes.create = [];
+        if (!Array.isArray(changes.update))
+            changes.update = [];
+        if (!Array.isArray(changes.delete))
+            changes.delete = [];
+        // Ensure metadata arrays exist
+        if (!Array.isArray(parsed.patternsApplied))
+            parsed.patternsApplied = [];
+        if (!Array.isArray(parsed.capabilitiesUsed))
+            parsed.capabilitiesUsed = [];
+        if (!Array.isArray(parsed.policiesChecked))
+            parsed.policiesChecked = [];
+        // Ensure risks object exists
+        if (!parsed.risks) {
+            parsed.risks = { level: 'low', description: 'No specific risks identified' };
+        }
+        // Ensure validationIntent exists
+        if (!parsed.validationIntent || typeof parsed.validationIntent !== 'string') {
+            parsed.validationIntent = 'Validate that the operation completed successfully';
+        }
+        logger.debug('AI response parsed successfully', {
+            commandCount: parsed.commands.length,
+            createCount: changes.create.length,
+            updateCount: changes.update.length,
+            deleteCount: changes.delete.length
+        });
+        return parsed;
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to parse AI response: ${errorMsg}`);
+        throw new Error(`Invalid AI response format: ${errorMsg}`);
+    }
+}
+/**
+ * Saves analysis session to disk using GenericSessionManager
+ *
+ * @param intent - User's operational intent
+ * @param context - Embedded context
+ * @param proposedChanges - Parsed AI proposal
+ * @param sessionManager - Session manager instance
+ * @param sessionId - Optional existing session ID for updates
+ * @param interaction_id - Optional interaction ID for eval datasets
+ * @param logger - Logger instance
+ * @returns Saved session
+ */
+async function saveAnalysisSession(intent, context, proposedChanges, sessionManager, sessionId, interaction_id, logger) {
+    const sessionData = {
+        intent,
+        interaction_id,
+        context,
+        proposedChanges: proposedChanges.proposedChanges,
+        commands: proposedChanges.commands,
+        dryRunValidation: proposedChanges.dryRunValidation,
+        patternsApplied: proposedChanges.patternsApplied,
+        capabilitiesUsed: proposedChanges.capabilitiesUsed,
+        policiesChecked: proposedChanges.policiesChecked,
+        risks: proposedChanges.risks,
+        validationIntent: proposedChanges.validationIntent,
+        status: 'analysis_complete'
+    };
+    if (sessionId) {
+        // Update existing session (refinement case)
+        logger.debug('Updating existing operate session', { sessionId });
+        await sessionManager.replaceSession(sessionId, sessionData);
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Failed to retrieve session ${sessionId} after update`);
+        }
+        return session;
+    }
+    else {
+        // Create new session
+        logger.debug('Creating new operate session');
+        const session = await sessionManager.createSession(sessionData);
+        logger.info('Operate session created', { sessionId: session.sessionId });
+        return session;
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Operate Execution Workflow
+ *
+ * Executes approved operational changes using shared command executor
+ * and validates results using remediate tool
+ */
+import { Logger } from '../core/error-handling';
+import { GenericSessionManager } from '../core/generic-session-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
+ * @returns Operation output with execution results
+ */
+export declare function executeOperations(sessionId: string, logger: Logger, sessionManager: GenericSessionManager<OperateSessionData>): Promise<OperateOutput>;
+//# sourceMappingURL=operate-execution.d.ts.map

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

@@ -0,0 +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"}