@eldrforge/kodrdriv 1.2.131 → 1.2.132

package/dist/commands/publish.js

@@ -11,6 +11,7 @@ import { DEFAULT_OUTPUT_DIRECTORY, KODRDRIV_DEFAULTS } from '../constants.js';
 import fs from 'fs/promises';
 import { runGitWithLock } from '../util/gitMutex.js';
 import { filterContent } from '../util/stopContext.js';
+import { runAgenticPublish, formatAgenticPublishResult } from '@eldrforge/ai-service';
 
 const scanNpmrcForEnvVars = async (storage)=>{
     const logger = getLogger();
@@ -186,6 +187,7 @@ const runPrechecks = async (runConfig, targetBranch)=>{
         if (targetBranchExists) {
             const syncStatus = await isBranchInSyncWithRemote(effectiveTargetBranch);
             if (!syncStatus.inSync) {
+                var _runConfig_publish2;
                 logger.error(`BRANCH_SYNC_FAILED: Target branch not synchronized with remote | Branch: ${effectiveTargetBranch} | Status: out-of-sync | Impact: Cannot proceed with publish`);
                 logger.error('');
                 if (syncStatus.error) {
@@ -193,6 +195,48 @@ const runPrechecks = async (runConfig, targetBranch)=>{
                 } else if (syncStatus.localSha && syncStatus.remoteSha) {
                     logger.error(`BRANCH_SYNC_DIVERGENCE: Local and remote commits differ | Local SHA: ${syncStatus.localSha.substring(0, 8)} | Remote SHA: ${syncStatus.remoteSha.substring(0, 8)}`);
                 }
+                // Check if agentic publish is enabled
+                if ((_runConfig_publish2 = runConfig.publish) === null || _runConfig_publish2 === void 0 ? void 0 : _runConfig_publish2.agenticPublish) {
+                    logger.info('');
+                    logger.info('AGENTIC_PUBLISH_STARTING: Attempting automatic diagnosis and fix | Mode: agentic | Feature: AI-powered recovery');
+                    try {
+                        var _syncStatus_localSha, _syncStatus_remoteSha, _runConfig_publish3;
+                        const currentBranch = await GitHub.getCurrentBranchName();
+                        const agenticResult = await runAgenticPublish({
+                            targetBranch: effectiveTargetBranch,
+                            sourceBranch: currentBranch,
+                            issue: 'branch_sync',
+                            issueDetails: syncStatus.error || `Local SHA: ${(_syncStatus_localSha = syncStatus.localSha) === null || _syncStatus_localSha === void 0 ? void 0 : _syncStatus_localSha.substring(0, 8)}, Remote SHA: ${(_syncStatus_remoteSha = syncStatus.remoteSha) === null || _syncStatus_remoteSha === void 0 ? void 0 : _syncStatus_remoteSha.substring(0, 8)}`,
+                            workingDirectory: process.cwd(),
+                            maxIterations: ((_runConfig_publish3 = runConfig.publish) === null || _runConfig_publish3 === void 0 ? void 0 : _runConfig_publish3.agenticPublishMaxIterations) || 10,
+                            storage,
+                            logger,
+                            dryRun: runConfig.dryRun
+                        });
+                        // Display the formatted result
+                        const formattedResult = formatAgenticPublishResult(agenticResult);
+                        logger.info(formattedResult);
+                        if (agenticResult.success) {
+                            logger.info('AGENTIC_PUBLISH_SUCCESS: Issue resolved automatically | Status: ready-to-retry | Action: Re-running prechecks');
+                            // Re-run the sync check to verify it was fixed
+                            const reSyncStatus = await isBranchInSyncWithRemote(effectiveTargetBranch);
+                            if (reSyncStatus.inSync) {
+                                logger.info(`BRANCH_SYNC_VERIFIED: Target branch is now synchronized with remote | Branch: ${effectiveTargetBranch} | Status: in-sync`);
+                                return; // Continue with publish
+                            } else {
+                                logger.warn('AGENTIC_PUBLISH_VERIFICATION_FAILED: Branch still not in sync after agentic fix | Status: needs-attention');
+                            }
+                        }
+                        if (agenticResult.requiresManualIntervention) {
+                            throw new Error(`Target branch '${effectiveTargetBranch}' requires manual intervention. Please see the steps above.`);
+                        } else {
+                            throw new Error(`Agentic publish could not resolve the issue automatically. Please see the analysis above.`);
+                        }
+                    } catch (agenticError) {
+                        logger.warn(`AGENTIC_PUBLISH_FAILED: Agentic recovery failed | Error: ${agenticError.message} | Fallback: Manual steps`);
+                    // Fall through to manual steps
+                    }
+                }
                 logger.error('');
                 logger.error('RESOLUTION_STEPS: Manual intervention required to sync branches:');
                 logger.error(`   Step 1: Switch to target branch | Command: git checkout ${effectiveTargetBranch}`);
@@ -201,6 +245,7 @@ const runPrechecks = async (runConfig, targetBranch)=>{
                 logger.error('   Step 4: Return to feature branch and retry publish');
                 logger.error('');
                 logger.error(`ALTERNATIVE_OPTION: Automatic sync available | Command: kodrdriv publish --sync-target | Branch: ${effectiveTargetBranch}`);
+                logger.error(`ALTERNATIVE_OPTION_AI: AI-powered recovery available | Command: kodrdriv publish --agentic-publish | Branch: ${effectiveTargetBranch}`);
                 throw new Error(`Target branch '${effectiveTargetBranch}' is not in sync with remote. Please sync the branch before running publish.`);
             } else {
                 logger.info(`BRANCH_SYNC_VERIFIED: Target branch is synchronized with remote | Branch: ${effectiveTargetBranch} | Status: in-sync`);