s9n-devops-agent 2.0.18-dev.3 → 2.0.18-dev.5

package/README.md

@@ -81,6 +81,7 @@ s9n-devops-agent start
 ### 🌲 Smart Branch Management
 - **Hierarchy:** `session/task` → `daily/date` → `main`.
 - **Auto-Merge:** Sessions automatically merge into daily branches, which roll over to main.
+- **Base Branch Selection:** Choose any branch (main, develop, etc.) as the starting point for your session worktree.
 
 ### 📋 House Rules System
 - **Context Injection:** AI agents read `docs/houserules.md` to understand your coding conventions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s9n-devops-agent",
-  "version": "2.0.18-dev.3",
+  "version": "2.0.18-dev.5",
   "description": "CS_DevOpsAgent - Intelligent Git Automation System with multi-agent support and session management",
   "type": "module",
   "main": "src/cs-devops-agent-worker.js",

package/src/agent-chat.js

@@ -51,9 +51,14 @@ const CONFIG = {
 
 class SmartAssistant {
   constructor() {
-    this.groq = new Groq({
-      apiKey: process.env.GROQ_API_KEY || process.env.OPENAI_API_KEY
-    });
+    // Initialize Groq client lazily or with null if key is missing
+    const apiKey = process.env.GROQ_API_KEY || process.env.OPENAI_API_KEY;
+    
+    if (apiKey) {
+      this.groq = new Groq({ apiKey });
+    } else {
+      this.groq = null; // Will be initialized in start()
+    }
     
     this.history = [];
     this.repoRoot = process.cwd();
@@ -125,8 +130,16 @@ When you want to perform an action, use the available tools.`;
    * Initialize the chat session
    */
   async start() {
+    // Ensure Groq client is initialized
+    if (!this.groq) {
+      const apiKey = credentialsManager.getGroqApiKey();
+      if (apiKey) {
+        this.groq = new Groq({ apiKey });
+      }
+    }
+
     // Check for Groq API Key
-    if (!credentialsManager.hasGroqApiKey()) {
+    if (!this.groq && !credentialsManager.hasGroqApiKey()) {
       console.log('\n' + '='.repeat(60));
       console.log(`${CONFIG.colors.yellow}⚠️  GROQ API KEY MISSING${CONFIG.colors.reset}`);
       console.log('='.repeat(60));

package/src/cs-devops-agent-worker.js

@@ -165,6 +165,10 @@ const FORCE_ROLLOVER  = (process.env.AC_FORCE_ROLLOVER  || "false").toLowerCase(
 const VERSION_PREFIX       = process.env.AC_VERSION_PREFIX || "v0.";
 const VERSION_START_MINOR  = Number(process.env.AC_VERSION_START_MINOR || "20");     // Start at v0.20 for micro-revisions
 const VERSION_BASE_REF     = process.env.AC_VERSION_BASE_REF || "origin/main";      // where new version branches start
+
+// Rebase configuration
+const REBASE_INTERVAL_HOURS = Number(process.env.AC_REBASE_INTERVAL || 0);
+const BASE_BRANCH           = process.env.AC_BASE_BRANCH || 'HEAD';
 // ------------------------------------------------
 
 const log  = (...a) => console.log("[cs-devops-agent]", ...a);
@@ -953,6 +957,109 @@ function detectInfrastructureChanges(changedFiles) {
   return detected;
 }
 
+// ============================================================================
+// AUTO-REBASE FUNCTIONALITY
+// ============================================================================
+
+/**
+ * Check if it's time to rebase and perform the operation
+ * @param {string} repoRoot - Repository root
+ * @returns {Promise<boolean>} - True if rebase occurred
+ */
+async function checkAndPerformRebase(repoRoot) {
+  if (REBASE_INTERVAL_HOURS <= 0) return false;
+  if (BASE_BRANCH === 'HEAD') return false; // Can't rebase from HEAD (relative)
+  
+  // Calculate interval in ms
+  const intervalMs = REBASE_INTERVAL_HOURS * 60 * 60 * 1000;
+  const now = Date.now();
+  
+  // Check if enough time has passed
+  if (!global.lastRebaseTime) global.lastRebaseTime = now; // Initialize on first run
+  if (now - global.lastRebaseTime < intervalMs) return false;
+  
+  // Don't rebase if we are busy
+  if (busy) return false;
+  
+  try {
+    busy = true;
+    
+    console.log('\n' + '━'.repeat(60));
+    console.log(`\x1b[33m⚠️  AUTO-REBASE IN PROGRESS - PAUSING AGENT...\x1b[0m`);
+    console.log(`Interval: ${REBASE_INTERVAL_HOURS} hours reached.`);
+    console.log(`Base: ${BASE_BRANCH}`);
+    console.log('━'.repeat(60) + '\n');
+    
+    // Check for uncommitted changes
+    const dirty = await hasUncommittedChanges();
+    let stashed = false;
+    
+    if (dirty) {
+      log('Stashing uncommitted changes before rebase...');
+      const stashRes = await run('git', ['stash', 'push', '-m', `Auto-stash before rebase ${new Date().toISOString()}`]);
+      if (stashRes.ok) stashed = true;
+      else {
+        console.error('\x1b[31m✗ Failed to stash changes. Aborting rebase.\x1b[0m');
+        busy = false;
+        return false;
+      }
+    }
+    
+    // Fetch latest
+    log(`Fetching latest changes from origin...`);
+    await run('git', ['fetch', 'origin', BASE_BRANCH]);
+    
+    // Rebase
+    log(`Rebasing onto origin/${BASE_BRANCH}...`);
+    const rebaseRes = await run('git', ['pull', '--rebase', 'origin', BASE_BRANCH]);
+    
+    if (rebaseRes.ok) {
+      console.log(`\x1b[32m✓ Rebase successful!\x1b[0m`);
+      
+      // Pop stash if needed
+      if (stashed) {
+        log('Restoring stashed changes...');
+        const popRes = await run('git', ['stash', 'pop']);
+        if (!popRes.ok) {
+          console.error('\x1b[31m⚠️  Conflict during stash pop. Manual intervention required.\x1b[0m');
+          console.log('\x1b[33mPlease resolve conflicts and continue.\x1b[0m');
+        } else {
+          console.log('\x1b[32m✓ Stash restored.\x1b[0m');
+        }
+      }
+      
+      global.lastRebaseTime = Date.now();
+    } else {
+      console.error(`\x1b[31m✗ REBASE CONFLICT DETECTED\x1b[0m`);
+      console.error(rebaseRes.stdout);
+      
+      // Abort rebase
+      log('Aborting rebase...');
+      await run('git', ['rebase', '--abort']);
+      
+      // Restore stash if we stashed
+      if (stashed) {
+        await run('git', ['stash', 'pop']);
+      }
+      
+      console.log('\x1b[33mRebase aborted. Please manually rebase your branch.\x1b[0m');
+      // Disable auto-rebase for this session to avoid loop?
+      // Or just wait for next interval.
+    }
+    
+    console.log(`\x1b[32m✓ RESUMING AGENT OPERATION\x1b[0m\n`);
+    return true;
+    
+  } catch (err) {
+    console.error(`Rebase error: ${err.message}`);
+    // Try to recover state
+    try { await run('git', ['rebase', '--abort']); } catch (e) {}
+    return false;
+  } finally {
+    busy = false;
+  }
+}
+
 /**
  * Update infrastructure documentation
  * @param {object} infraChanges - Infrastructure change details
@@ -1500,6 +1607,19 @@ console.log();
     log("watching…");
   }
 
+  // Schedule auto-rebase if configured
+  if (REBASE_INTERVAL_HOURS > 0) {
+    log(`Auto-rebase scheduled every ${REBASE_INTERVAL_HOURS} hours (checking every 5m)`);
+    // Initial check (in case we started overdue)
+    // Don't await this so we don't block startup
+    checkAndPerformRebase(repoRoot).catch(err => console.error(err));
+    
+    // Periodic check
+    setInterval(async () => {
+      await checkAndPerformRebase(repoRoot);
+    }, 5 * 60 * 1000); // Check every 5 minutes
+  }
+
   // ============================================================================
   // FILE WATCHER SETUP - Monitor for changes and trigger commits
   // ============================================================================

package/src/session-coordinator.js

@@ -830,7 +830,7 @@ export class SessionCoordinator {
    */
   async promptForBaseBranch() {
     console.log(`\n${CONFIG.colors.yellow}═══ Base Branch Selection ═══${CONFIG.colors.reset}`);
-    console.log(`${CONFIG.colors.dim}Select the branch you want to start your work FROM.${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}Which branch should I use as the starting point for your work?${CONFIG.colors.reset}`);
     
     // Get available branches
     const branches = this.getAvailableBranches();
@@ -1270,6 +1270,9 @@ export class SessionCoordinator {
     // Ask for base branch (where to start work from)
     const baseBranch = await this.promptForBaseBranch();
     
+    // Ask for auto-rebase interval
+    const rebaseInterval = await this.promptForRebaseInterval();
+    
     // Check for Docker configuration and ask about restart preference
     let dockerConfig = null;
     
@@ -1425,6 +1428,9 @@ export class SessionCoordinator {
       execSync(`git worktree add -b ${branchName} "${worktreePath}" ${baseRef}`, { stdio: 'pipe' });
       console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Worktree created at: ${worktreePath}`);
       
+      // Store base branch in session data for rebase logic
+      const sessionBaseBranch = baseRef === 'HEAD' ? await this.resolveHeadBranch() : baseRef;
+      
       // If we're in a submodule, set up the correct remote for the worktree
       if (isSubmodule && parentRemote) {
         console.log(`${CONFIG.colors.yellow}Configuring worktree to use parent repository remote...${CONFIG.colors.reset}`);
@@ -1446,11 +1452,13 @@ export class SessionCoordinator {
         task,
         worktreePath,
         branchName,
+        baseBranch: sessionBaseBranch,
         created: new Date().toISOString(),
         status: 'active',
         pid: process.pid,
         developerInitials: devInitials,
         mergeConfig: mergeConfig,
+        rebaseInterval: rebaseInterval,
         dockerConfig: dockerConfig
       };
       
@@ -1488,6 +1496,46 @@ export class SessionCoordinator {
     }
   }
 
+  /**
+   * Prompt for auto-rebase interval
+   */
+  async promptForRebaseInterval() {
+    console.log(`\n${CONFIG.colors.yellow}═══ Auto-Rebase Configuration ═══${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}I can automatically pull updates from the base branch to keep you up-to-date.${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}This helps prevent conflicts later by rebasing your work periodically.${CONFIG.colors.reset}`);
+    
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    return new Promise((resolve) => {
+      rl.question(`\nHow often should I rebase? (in hours, 0 to disable) [0]: `, (answer) => {
+        rl.close();
+        const hours = parseFloat(answer.trim());
+        if (isNaN(hours) || hours <= 0) {
+            console.log(`${CONFIG.colors.dim}Auto-rebase disabled. I'll let you manage updates manually.${CONFIG.colors.reset}`);
+            resolve(0);
+        } else {
+            console.log(`${CONFIG.colors.green}✓ I'll check for updates and rebase every ${hours} hour(s).${CONFIG.colors.reset}`);
+            resolve(hours);
+        }
+      });
+    });
+  }
+
+  /**
+   * Resolve HEAD to actual branch name
+   */
+  async resolveHeadBranch() {
+      try {
+          const head = execSync('git rev-parse --abbrev-ref HEAD', { cwd: this.repoRoot, encoding: 'utf8' }).trim();
+          return head;
+      } catch (e) {
+          return 'main';
+      }
+  }
+
   /**
    * Generate instructions for the coding agent
    */
@@ -1895,7 +1943,11 @@ The DevOps agent is monitoring this worktree for changes.
       AC_DATE_STYLE: process.env.AC_DATE_STYLE || 'dash',  // Preserve date style
       // Apply version configuration if set
       ...(projectSettings.versioningStrategy?.prefix && { AC_VERSION_PREFIX: projectSettings.versioningStrategy.prefix }),
-      ...(projectSettings.versioningStrategy?.startMinor && { AC_VERSION_START_MINOR: projectSettings.versioningStrategy.startMinor.toString() })
+      ...(projectSettings.versioningStrategy?.startMinor && { AC_VERSION_START_MINOR: projectSettings.versioningStrategy.startMinor.toString() }),
+      
+      // Rebase configuration
+      AC_REBASE_INTERVAL: (sessionData.rebaseInterval || 0).toString(),
+      AC_BASE_BRANCH: sessionData.baseBranch || 'HEAD' // We need to pass the base branch for rebasing
     };
     
     const agentScript = path.join(__dirname, 'cs-devops-agent-worker.js');