@vfarcic/dot-ai 1.12.0 → 1.14.0

package/dist/tools/remediate.js

@@ -51,6 +51,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const request_context_1 = require("../interfaces/request-context");
 const rbac_1 = require("../core/rbac");
+const session_events_1 = require("../core/session-events");
 const internal_tools_1 = require("../core/internal-tools");
 // PRD #143 Milestone 1: Hybrid approach - AI can use kubectl_api_resources tool OR continue with JSON dataRequests
 // Tool metadata for direct MCP registration
@@ -256,6 +257,13 @@ async function conductInvestigation(session, sessionManager, aiProvider, logger,
             finalAnalysis: output,
             status: 'analysis_complete',
         });
+        (0, session_events_1.getSessionEventBus)().publish(session_events_1.SESSION_EVENTS.SESSION_UPDATED, {
+            sessionId: session.sessionId,
+            toolName: 'remediate',
+            status: 'analysis_complete',
+            issue: session.data.issue,
+            timestamp: new Date().toISOString(),
+        });
         logger.info('Investigation and analysis completed', {
             requestId,
             sessionId: session.sessionId,
@@ -271,6 +279,13 @@ async function conductInvestigation(session, sessionManager, aiProvider, logger,
         });
         // Mark session as failed
         sessionManager.updateSession(session.sessionId, { status: 'failed' });
+        (0, session_events_1.getSessionEventBus)().publish(session_events_1.SESSION_EVENTS.SESSION_UPDATED, {
+            sessionId: session.sessionId,
+            toolName: 'remediate',
+            status: 'failed',
+            issue: session.data.issue,
+            timestamp: new Date().toISOString(),
+        });
         throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.AI_SERVICE, error_handling_1.ErrorSeverity.HIGH, `Investigation failed: ${error instanceof Error ? error.message : 'Unknown error'}`, {
             operation: 'investigation_loop',
             component: 'RemediateTool',
@@ -401,7 +416,31 @@ async function executeUserChoice(sessionManager, sessionId, choice, logger, requ
                 return await executeRemediationCommands(session, sessionManager, logger, requestId, currentInteractionId);
             case 2: {
                 // Execute via agent
-                // Use validation intent directly from final analysis
+                const actions = session.data.finalAnalysis.remediation.actions;
+                const gitSourceActions = actions.filter(a => a.gitSource && !a.command);
+                const kubectlActions = actions.filter(a => a.command && !a.gitSource);
+                if (gitSourceActions.length > 0 && kubectlActions.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    status: 'success',
+                                    sessionId: sessionId,
+                                    message: 'GitOps remediation detected - use automatic execution (choice 1) for PR creation',
+                                    remediation: session.data.finalAnalysis.remediation,
+                                    instructions: {
+                                        nextSteps: [
+                                            'This remediation requires GitOps PR creation which is handled automatically.',
+                                            'Please use choice 1 (Execute automatically) to create the PR.',
+                                            'Alternatively, manually apply the file changes from gitSource.files to your repository.',
+                                        ],
+                                    },
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
                 const validationIntent = session.data.finalAnalysis.validationIntent ||
                     'Check the status of the affected resources to verify the issue has been resolved';
                 return {
@@ -453,6 +492,7 @@ async function executeRemediationCommands(session, sessionManager, logger, reque
     const finalAnalysis = session.data.finalAnalysis;
     let overallSuccess = true;
     let executedCommandCount = 0;
+    let pullRequestInfo;
     logger.info('Starting remediation command execution', {
         requestId,
         sessionId: session.sessionId,
@@ -463,21 +503,76 @@ async function executeRemediationCommands(session, sessionManager, logger, reque
         const action = finalAnalysis.remediation.actions[i];
         const actionId = `action_${i + 1}`;
         try {
-            // PRD #407: Skip gitSource actions — these are Git-based remediation
-            // instructions for GitOps-managed resources, not executable commands
+            // PRD #408: Handle gitSource actions — create PR instead of kubectl
             if (action.gitSource && !action.command) {
-                logger.info('Skipping gitSource remediation action (not executable)', {
+                logger.info('Processing gitSource remediation action', {
                     requestId,
                     sessionId: session.sessionId,
                     actionId,
                     repoURL: action.gitSource.repoURL,
+                    repoPath: action.gitSource.repoPath,
                 });
-                results.push({
-                    action: `${actionId}: ${action.description} (skipped: Git-based)`,
-                    success: false,
-                    output: 'Git-based remediation — apply changes in the source repository',
-                    timestamp: new Date(),
-                });
+                if (!action.gitSource.repoPath) {
+                    results.push({
+                        action: `${actionId}: ${action.description} (failed: missing repoPath)`,
+                        success: false,
+                        output: 'Git-based remediation requires repoPath from investigation phase',
+                        timestamp: new Date(),
+                    });
+                    overallSuccess = false;
+                    continue;
+                }
+                const prInput = {
+                    repoPath: action.gitSource.repoPath,
+                    files: action.gitSource.files.map((f) => ({
+                        path: f.path,
+                        content: f.content,
+                    })),
+                    title: `fix: ${action.description}`,
+                    body: `## Remediation\n\n${action.rationale}\n\n**Risk Level:** ${action.risk}`,
+                    branchName: `remediate/${session.sessionId.slice(0, 12)}-${Date.now()}`,
+                    baseBranch: action.gitSource.branch || 'main',
+                };
+                const prExecutor = (0, internal_tools_1.createInternalToolExecutor)(session.sessionId);
+                const prResult = (await prExecutor('git_create_pr', prInput));
+                if (prResult.success && 'prUrl' in prResult) {
+                    const filesList = prResult.filesChanged && prResult.filesChanged.length > 0
+                        ? prResult.filesChanged.join(', ')
+                        : 'none';
+                    results.push({
+                        action: `${actionId}: ${action.description} (PR created)`,
+                        success: true,
+                        output: `PR #${prResult.prNumber}: ${prResult.prUrl}\nBranch: ${prResult.branch}\nFiles changed: ${filesList}`,
+                        timestamp: new Date(),
+                    });
+                    pullRequestInfo = {
+                        url: prResult.prUrl,
+                        number: prResult.prNumber,
+                        branch: prResult.branch,
+                        baseBranch: prResult.baseBranch,
+                        filesChanged: prResult.filesChanged,
+                    };
+                }
+                else if (prResult.success && 'error' in prResult) {
+                    const filesList = prResult.filesChanged && prResult.filesChanged.length > 0
+                        ? prResult.filesChanged.join(', ')
+                        : 'none';
+                    results.push({
+                        action: `${actionId}: ${action.description} (branch pushed, manual PR needed)`,
+                        success: true,
+                        output: `Branch: ${prResult.branch}\nFiles changed: ${filesList}\nNote: ${prResult.error}`,
+                        timestamp: new Date(),
+                    });
+                }
+                else {
+                    overallSuccess = false;
+                    results.push({
+                        action: `${actionId}: ${action.description} (failed)`,
+                        success: false,
+                        output: prResult.error,
+                        timestamp: new Date(),
+                    });
+                }
                 continue;
             }
             logger.info('Executing remediation action', {
@@ -620,6 +715,7 @@ IMPORTANT: You MUST respond with the final JSON analysis format as specified in
                         success: false,
                         summary: 'Validation found remaining issues after remediation',
                     },
+                    pullRequest: pullRequestInfo,
                 };
                 return {
                     content: [
@@ -657,6 +753,7 @@ IMPORTANT: You MUST respond with the final JSON analysis format as specified in
                     success: true,
                     summary: 'Validation confirmed issue resolution',
                 },
+                pullRequest: pullRequestInfo,
             };
             const content = [
                 {
@@ -684,6 +781,73 @@ IMPORTANT: You MUST respond with the final JSON analysis format as specified in
         status: overallSuccess ? 'executed_successfully' : 'executed_with_errors',
         executionResults: results,
     });
+    (0, session_events_1.getSessionEventBus)().publish(session_events_1.SESSION_EVENTS.SESSION_UPDATED, {
+        sessionId: session.sessionId,
+        toolName: 'remediate',
+        status: overallSuccess ? 'executed_successfully' : 'executed_with_errors',
+        issue: session.data.issue,
+        timestamp: new Date().toISOString(),
+    });
+    const hasOnlyGitOps = executedCommandCount === 0 && pullRequestInfo !== undefined;
+    const prInfo = pullRequestInfo;
+    let nextSteps;
+    if (hasOnlyGitOps && prInfo) {
+        nextSteps = [
+            'Changes have been pushed to a Git branch for GitOps reconciliation:',
+            `  PR: ${prInfo.url}`,
+            `  Branch: ${prInfo.branch} → ${prInfo.baseBranch}`,
+            `  Files changed: ${prInfo.filesChanged.join(', ')}`,
+            '',
+            'Next steps:',
+            '  1. Review and merge the PR in your Git repository',
+            '  2. Wait for Argo CD/Flux to sync the changes',
+            '  3. Verify the issue is resolved after reconciliation',
+            '',
+            `You can verify the fix by running: remediate("Verify that ${finalAnalysis.analysis.rootCause.toLowerCase()} has been resolved")`,
+        ];
+    }
+    else if (overallSuccess) {
+        if (validationResult) {
+            nextSteps = [
+                'The following kubectl commands were executed to remediate the issue:',
+                ...finalAnalysis.remediation.actions
+                    .filter(a => a.command)
+                    .map((action, index) => {
+                    const resultIndex = finalAnalysis.remediation.actions.indexOf(action);
+                    return `  ${index + 1}. ${action.command} ${results[resultIndex]?.success ? '✓' : '✗'}`;
+                }),
+                'Automatic validation has been completed - see validation results above',
+                'Monitor your cluster to ensure the issue remains resolved',
+            ];
+        }
+        else {
+            nextSteps = [
+                'The following kubectl commands were executed to remediate the issue:',
+                ...finalAnalysis.remediation.actions
+                    .filter(a => a.command)
+                    .map((action, index) => {
+                    const resultIndex = finalAnalysis.remediation.actions.indexOf(action);
+                    return `  ${index + 1}. ${action.command} ${results[resultIndex]?.success ? '✓' : '✗'}`;
+                }),
+                `You can verify the fix by running: remediate("Verify that ${finalAnalysis.analysis.rootCause.toLowerCase()} has been resolved")`,
+                'Monitor your cluster to ensure the issue is fully resolved',
+            ];
+        }
+    }
+    else {
+        nextSteps = [
+            'The following kubectl commands were attempted:',
+            ...finalAnalysis.remediation.actions
+                .filter(a => a.command)
+                .map((action, index) => {
+                const resultIndex = finalAnalysis.remediation.actions.indexOf(action);
+                return `  ${index + 1}. ${action.command} ${results[resultIndex]?.success ? '✓' : '✗'}`;
+            }),
+            'Some remediation commands failed - check the results above',
+            'Review the error messages and address any underlying issues',
+            'You may need to run additional commands or investigate further',
+        ];
+    }
     const response = {
         status: overallSuccess ? 'success' : 'failed',
         sessionId: session.sessionId,
@@ -691,37 +855,20 @@ IMPORTANT: You MUST respond with the final JSON analysis format as specified in
         results: results,
         executedCommands: results.map(r => r.action),
         message: overallSuccess
-            ? `Successfully executed ${results.length} remediation actions`
+            ? hasOnlyGitOps
+                ? `Successfully created PR for ${results.length} GitOps remediation action(s)`
+                : `Successfully executed ${results.length} remediation actions`
             : `Executed ${results.length} actions with ${results.filter(r => !r.success).length} failures`,
         validation: validationResult,
         instructions: {
-            showExecutedCommands: true,
-            showActualKubectlCommands: true,
-            nextSteps: overallSuccess
-                ? validationResult
-                    ? [
-                        'The following kubectl commands were executed to remediate the issue:',
-                        ...finalAnalysis.remediation.actions.map((action, index) => `  ${index + 1}. ${action.command} ${results[index]?.success ? '✓' : '✗'}`),
-                        'Automatic validation has been completed - see validation results above',
-                        'Monitor your cluster to ensure the issue remains resolved',
-                    ]
-                    : [
-                        'The following kubectl commands were executed to remediate the issue:',
-                        ...finalAnalysis.remediation.actions.map((action, index) => `  ${index + 1}. ${action.command} ${results[index]?.success ? '✓' : '✗'}`),
-                        `You can verify the fix by running: remediate("Verify that ${finalAnalysis.analysis.rootCause.toLowerCase()} has been resolved")`,
-                        'Monitor your cluster to ensure the issue is fully resolved',
-                    ]
-                : [
-                    'The following kubectl commands were attempted:',
-                    ...finalAnalysis.remediation.actions.map((action, index) => `  ${index + 1}. ${action.command} ${results[index]?.success ? '✓' : '✗'}`),
-                    'Some remediation commands failed - check the results above',
-                    'Review the error messages and address any underlying issues',
-                    'You may need to run additional commands or investigate further',
-                ],
+            showExecutedCommands: !hasOnlyGitOps,
+            showActualKubectlCommands: !hasOnlyGitOps,
+            nextSteps,
         },
         investigation: finalAnalysis.investigation,
         analysis: finalAnalysis.analysis,
         remediation: finalAnalysis.remediation,
+        pullRequest: pullRequestInfo,
     };
     logger.info('Remediation execution completed', {
         requestId,
@@ -796,6 +943,13 @@ async function handleRemediateTool(args) {
             interaction_id: validatedInput.interaction_id,
             status: 'investigating',
         });
+        (0, session_events_1.getSessionEventBus)().publish(session_events_1.SESSION_EVENTS.SESSION_CREATED, {
+            sessionId: session.sessionId,
+            toolName: 'remediate',
+            status: 'investigating',
+            issue: validatedInput.issue,
+            timestamp: session.createdAt,
+        });
         logger.info('Investigation session created', {
             requestId,
             sessionId: session.sessionId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vfarcic/dot-ai",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "description": "AI-powered development productivity platform that enhances software development workflows through intelligent automation and AI-driven assistance",
   "mcpName": "io.github.vfarcic/dot-ai",
   "main": "dist/index.js",
@@ -107,7 +107,7 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@ai-sdk/alibaba": "^1.0.10",
+    "@ai-sdk/alibaba": "^1.0.13",
     "@ai-sdk/amazon-bedrock": "^4.0.77",
     "@ai-sdk/anthropic": "^3.0.58",
     "@ai-sdk/google": "^3.0.43",

package/prompts/remediate-system.md

@@ -65,6 +65,7 @@ Once investigation is complete, respond with ONLY this JSON format:
         "gitSource": {
           "repoURL": "source repository URL — only when resource is GitOps-managed",
           "branch": "branch name",
+          "repoPath": "relative path to cloned repo (as returned by git_clone) — required for GitOps remediation",
           "files": [
             {
               "path": "path relative to repo root",
@@ -104,8 +105,9 @@ Once investigation is complete, respond with ONLY this JSON format:
 After identifying the problematic resource, check whether it is managed by a GitOps controller (e.g., Argo CD, Flux).
 
 **When GitOps management is detected**:
-- Clone the source repo, navigate and read the manifests to find the file(s) that need changing
-- Include `gitSource` in your remediation actions with the repo URL, branch, and full corrected file contents for each file that needs modification
+- Clone the source repo and capture the local path for use as `repoPath` in the remediation actions
+- Navigate and read the manifests to find the file(s) that need changing
+- Include `gitSource` in your remediation actions with `repoPath`, `repoURL`, `branch`, and full corrected file contents for each file that needs modification
 
 **When GitOps management is NOT detected**:
 - Proceed with standard kubectl-based remediation
@@ -190,6 +192,7 @@ After identifying the problematic resource, check whether it is managed by a Git
         "gitSource": {
           "repoURL": "https://github.com/org/infra-repo.git",
           "branch": "main",
+          "repoPath": "session-abc123/org-infra-repo",
           "files": [
             {
               "path": "apps/production/deployment.yaml",