s9n-devops-agent 1.2.0 → 1.3.1

package/src/session-coordinator.js

@@ -19,12 +19,12 @@
 
 import fs from 'fs';
 import path from 'path';
-import { execSync, spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { execSync, spawn, fork } from 'child_process';
 import crypto from 'crypto';
 import readline from 'readline';
 import { hasDockerConfiguration } from './docker-utils.js';
-import crypto from 'crypto';
-import readline from 'readline';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -461,7 +461,13 @@ class SessionCoordinator {
     });
     
     console.log(`\n${CONFIG.colors.yellow}═══ Auto-merge Configuration ═══${CONFIG.colors.reset}`);
-    console.log(`${CONFIG.colors.dim}(Automatically merge today's work into a target branch)${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}Automatically merge your daily work branches into a target branch.${CONFIG.colors.reset}`);
+    console.log();
+    console.log(`${CONFIG.colors.bright}How it works:${CONFIG.colors.reset}`);
+    console.log(`  • The agent creates dated branches (e.g., ${CONFIG.colors.blue}agent_dev_2025-10-01${CONFIG.colors.reset})`);
+    console.log(`  • At the end of each day, your work is automatically merged`);
+    console.log(`  • This keeps your target branch (main/develop) up to date`);
+    console.log(`  • Prevents accumulation of stale feature branches`);
     
     // Ask if they want auto-merge
     const autoMerge = await new Promise((resolve) => {
@@ -784,6 +790,28 @@ INSTRUCTIONS:
 - **Worktree Path:** \`${worktreePath}\`
 - **Branch:** \`${branchName}\`
 
+## 🚨 CRITICAL: File Coordination Protocol
+
+**BEFORE editing any files, you MUST:**
+
+1. **Declare your intent** by creating:
+   \`\`\`json
+   // File: .file-coordination/active-edits/<agent>-${sessionId}.json
+   {
+     "agent": "<your-name>",
+     "session": "${sessionId}",
+     "files": ["list", "files", "to", "edit"],
+     "operation": "edit",
+     "reason": "${task}",
+     "declaredAt": "<ISO-8601-timestamp>",
+     "estimatedDuration": 300
+   }
+   \`\`\`
+
+2. **Check for conflicts** - read all files in \`.file-coordination/active-edits/\`
+3. **Only proceed if no conflicts** - wait or choose different files if blocked
+4. **Release files when done** - delete your declaration after edits
+
 ## Instructions for Claude/Cline
 
 ### Step 1: Navigate to Your Worktree
@@ -797,18 +825,25 @@ git branch --show-current
 # Should output: ${branchName}
 \`\`\`
 
-### Step 3: Work on Your Task
+### Step 3: Declare Files Before Editing
+Create your declaration in \`.file-coordination/active-edits/\`
+
+### Step 4: Work on Your Task
 Make changes for: **${task}**
 
-### Step 4: Commit Your Changes
+### Step 5: Commit Your Changes
 Write your commit message to the session-specific file:
 \`\`\`bash
 echo "feat: your commit message here" > .devops-commit-${sessionId}.msg
 \`\`\`
 
-### Step 5: Automatic Processing
+### Step 6: Release Your File Locks
+Delete your declaration from \`.file-coordination/active-edits/\`
+
+### Step 7: Automatic Processing
 The DevOps agent will automatically:
 - Detect your changes
+- Check for coordination conflicts
 - Read your commit message
 - Commit and push to the remote repository
 - Clear the message file
@@ -853,11 +888,21 @@ The DevOps agent will automatically:
     console.log(`- Working Directory: ${instructions.worktreePath}`);
     console.log(`- Task: ${task || 'development'}`);
     console.log(``);
-    console.log(`Please switch to this directory before making any changes:`);
-    console.log(`cd "${instructions.worktreePath}"`);
+    console.log(`CRITICAL FIRST STEP:`);
+    console.log(`1. Read and follow the house rules: cat "${instructions.worktreePath}/houserules.md"`);
+    console.log(`2. Switch to the working directory: cd "${instructions.worktreePath}"`);
+    console.log(``);
+    console.log(`FILE COORDINATION PROTOCOL (from house rules at ${instructions.worktreePath}/houserules.md):`);
+    console.log(`Before editing ANY files, you MUST:`);
+    console.log(`- Declare your intent in .file-coordination/active-edits/<agent>-${sessionId}.json`);
+    console.log(`- Check for conflicts with other agents`);
+    console.log(`- Only edit files you've declared`);
+    console.log(`- Release files when done`);
     console.log(``);
     console.log(`Write commit messages to: .devops-commit-${sessionId}.msg`);
     console.log(`The DevOps agent will automatically commit and push changes.`);
+    console.log(``);
+    console.log(`Remember: ALWAYS check house rules first for the latest protocols!`);
     console.log();
     
     console.log(`${CONFIG.colors.yellow}══════════════════════════════════════════════════════════════${CONFIG.colors.reset}`);
@@ -1185,6 +1230,215 @@ The DevOps agent is monitoring this worktree for changes.
     
     return session;
   }
+  
+  /**
+   * Close a specific session
+   */
+  async closeSession(sessionId) {
+    const lockFile = path.join(this.locksPath, `${sessionId}.lock`);
+    
+    if (!fs.existsSync(lockFile)) {
+      console.error(`${CONFIG.colors.red}Session not found: ${sessionId}${CONFIG.colors.reset}`);
+      return false;
+    }
+    
+    const session = JSON.parse(fs.readFileSync(lockFile, 'utf8'));
+    console.log(`\n${CONFIG.colors.yellow}Closing session: ${sessionId}${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}Task: ${session.task}${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}Branch: ${session.branchName}${CONFIG.colors.reset}`);
+    
+    // Kill agent if running
+    if (session.agentPid) {
+      try {
+        process.kill(session.agentPid, 'SIGTERM');
+        console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Agent process stopped`);
+      } catch (err) {
+        // Process might already be dead
+      }
+    }
+    
+    // Check for uncommitted changes
+    if (fs.existsSync(session.worktreePath)) {
+      try {
+        const status = execSync(`git -C "${session.worktreePath}" status --porcelain`, { encoding: 'utf8' });
+        if (status.trim()) {
+          console.log(`\n${CONFIG.colors.yellow}Warning: Uncommitted changes found${CONFIG.colors.reset}`);
+          console.log(status);
+          
+          const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+          });
+          
+          const answer = await new Promise(resolve => {
+            rl.question('Commit these changes before closing? (y/N): ', resolve);
+          });
+          rl.close();
+          
+          if (answer.toLowerCase() === 'y') {
+            execSync(`git -C "${session.worktreePath}" add -A`, { stdio: 'pipe' });
+            execSync(`git -C "${session.worktreePath}" commit -m "chore: final session cleanup for ${sessionId}"`, { stdio: 'pipe' });
+            execSync(`git -C "${session.worktreePath}" push origin ${session.branchName}`, { stdio: 'pipe' });
+            console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Changes committed and pushed`);
+          }
+        }
+      } catch (err) {
+        console.log(`${CONFIG.colors.dim}Could not check git status${CONFIG.colors.reset}`);
+      }
+      
+      // Ask about removing worktree
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      
+      const removeWorktree = await new Promise(resolve => {
+        rl.question(`\nRemove worktree at ${session.worktreePath}? (Y/n): `, resolve);
+      });
+      rl.close();
+      
+      if (removeWorktree.toLowerCase() !== 'n') {
+        try {
+          // Remove worktree
+          execSync(`git worktree remove "${session.worktreePath}" --force`, { stdio: 'pipe' });
+          console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Worktree removed`);
+          
+          // Prune worktree list
+          execSync('git worktree prune', { stdio: 'pipe' });
+        } catch (err) {
+          console.error(`${CONFIG.colors.red}Failed to remove worktree: ${err.message}${CONFIG.colors.reset}`);
+        }
+      }
+    }
+    
+    // Remove lock file
+    fs.unlinkSync(lockFile);
+    console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Session closed successfully`);
+    
+    return true;
+  }
+  
+  /**
+   * Interactive session selection and close
+   */
+  async selectAndCloseSession() {
+    if (!fs.existsSync(this.locksPath)) {
+      console.log(`${CONFIG.colors.yellow}No active sessions${CONFIG.colors.reset}`);
+      return;
+    }
+    
+    const locks = fs.readdirSync(this.locksPath);
+    if (locks.length === 0) {
+      console.log(`${CONFIG.colors.yellow}No active sessions${CONFIG.colors.reset}`);
+      return;
+    }
+    
+    const sessions = [];
+    locks.forEach(lockFile => {
+      const lockPath = path.join(this.locksPath, lockFile);
+      const session = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+      sessions.push(session);
+    });
+    
+    console.log(`\n${CONFIG.colors.bright}Select session to close:${CONFIG.colors.reset}\n`);
+    
+    sessions.forEach((session, index) => {
+      const status = session.status === 'active' ? 
+        `${CONFIG.colors.green}●${CONFIG.colors.reset}` : 
+        `${CONFIG.colors.yellow}○${CONFIG.colors.reset}`;
+      
+      console.log(`${status} ${CONFIG.colors.bright}${index + 1})${CONFIG.colors.reset} ${session.sessionId}`);
+      console.log(`   Task: ${session.task}`);
+      console.log(`   Branch: ${session.branchName}`);
+      console.log(`   Created: ${session.created}`);
+      console.log();
+    });
+    
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    const answer = await new Promise(resolve => {
+      rl.question(`Select session (1-${sessions.length}) or 'q' to quit: `, resolve);
+    });
+    rl.close();
+    
+    if (answer.toLowerCase() === 'q') {
+      return;
+    }
+    
+    const index = parseInt(answer) - 1;
+    if (index >= 0 && index < sessions.length) {
+      await this.closeSession(sessions[index].sessionId);
+    } else {
+      console.log(`${CONFIG.colors.red}Invalid selection${CONFIG.colors.reset}`);
+    }
+  }
+  
+  /**
+   * Clean up all stale sessions and worktrees
+   */
+  async cleanupAll() {
+    console.log(`\n${CONFIG.colors.yellow}Cleaning up stale sessions and worktrees...${CONFIG.colors.reset}`);
+    
+    // Clean up old lock files (older than 24 hours)
+    const oneDayAgo = Date.now() - 86400000;
+    let cleanedLocks = 0;
+    
+    if (fs.existsSync(this.locksPath)) {
+      const locks = fs.readdirSync(this.locksPath);
+      locks.forEach(lockFile => {
+        const lockPath = path.join(this.locksPath, lockFile);
+        const stats = fs.statSync(lockPath);
+        if (stats.mtimeMs < oneDayAgo) {
+          fs.unlinkSync(lockPath);
+          cleanedLocks++;
+        }
+      });
+    }
+    
+    if (cleanedLocks > 0) {
+      console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Removed ${cleanedLocks} stale lock files`);
+    }
+    
+    // Prune git worktrees
+    try {
+      execSync('git worktree prune', { stdio: 'pipe' });
+      console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Pruned git worktrees`);
+    } catch (err) {
+      console.log(`${CONFIG.colors.dim}Could not prune worktrees${CONFIG.colors.reset}`);
+    }
+    
+    // Clean up orphaned worktree directories
+    if (fs.existsSync(this.worktreesPath)) {
+      const worktrees = fs.readdirSync(this.worktreesPath);
+      let cleanedWorktrees = 0;
+      
+      for (const dir of worktrees) {
+        const worktreePath = path.join(this.worktreesPath, dir);
+        
+        // Check if this worktree is still valid
+        try {
+          execSync(`git worktree list | grep "${worktreePath}"`, { stdio: 'pipe' });
+        } catch (err) {
+          // Worktree not in git list, it's orphaned
+          try {
+            fs.rmSync(worktreePath, { recursive: true, force: true });
+            cleanedWorktrees++;
+          } catch (err) {
+            console.log(`${CONFIG.colors.dim}Could not remove ${dir}${CONFIG.colors.reset}`);
+          }
+        }
+      }
+      
+      if (cleanedWorktrees > 0) {
+        console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Removed ${cleanedWorktrees} orphaned worktree directories`);
+      }
+    }
+    
+    console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Cleanup complete`);
+  }
 }
 
 // ============================================================================
@@ -1260,13 +1514,31 @@ async function main() {
       break;
     }
     
-    case 'list': {
-      coordinator.listSessions();
-      break;
+  case 'list': {
+    coordinator.listSessions();
+    break;
+  }
+  
+  case 'close': {
+    // Close a session and clean up
+    const sessionId = args[1];
+    if (sessionId) {
+      await coordinator.closeSession(sessionId);
+    } else {
+      // Interactive selection
+      await coordinator.selectAndCloseSession();
     }
-    
-    case 'help':
-    default: {
+    break;
+  }
+  
+  case 'cleanup': {
+    // Clean up stale sessions and worktrees
+    await coordinator.cleanupAll();
+    break;
+  }
+  
+  case 'help':
+  default: {
       console.log(`
 ${CONFIG.colors.bright}DevOps Session Coordinator${CONFIG.colors.reset}
 
@@ -1279,6 +1551,8 @@ ${CONFIG.colors.blue}Commands:${CONFIG.colors.reset}
   ${CONFIG.colors.green}create-and-start${CONFIG.colors.reset}    Create session and start agent (all-in-one)
   ${CONFIG.colors.green}request [agent]${CONFIG.colors.reset}     Request a session (for Claude to call)
   ${CONFIG.colors.green}list${CONFIG.colors.reset}                List all active sessions
+  ${CONFIG.colors.green}close [id]${CONFIG.colors.reset}          Close session and clean up worktree
+  ${CONFIG.colors.green}cleanup${CONFIG.colors.reset}             Clean up all stale sessions
   ${CONFIG.colors.green}help${CONFIG.colors.reset}                Show this help
 
 ${CONFIG.colors.blue}Options:${CONFIG.colors.reset}

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

@@ -735,7 +735,8 @@ export AC_MSG_MIN_BYTES="20"
 export AC_DEBOUNCE_MS="1500"
 export AC_MSG_DEBOUNCE_MS="3000"
 export AC_CLEAR_MSG_WHEN="push"
-export AC_ROLLOVER_PROMPT="true"
+# Daily rollover is automatic - no prompting needed
+export AC_ROLLOVER_PROMPT="false"
 export AC_DEBUG="false"
 
 # Check for debug flag
@@ -784,7 +785,8 @@ AC_MSG_DEBOUNCE_MS=3000
 
 # Behavior
 AC_CLEAR_MSG_WHEN=push
-AC_ROLLOVER_PROMPT=true
+# Daily rollover is automatic
+AC_ROLLOVER_PROMPT=false
 AC_DEBUG=false
 `;
   
@@ -826,7 +828,7 @@ function printInstructions(initials) {
   log.title('🎯 Daily Workflow:');
   console.log('');
   console.log(`• Your daily branches will be: ${colors.bright}dev_${initials}_YYYY-MM-DD${colors.reset}`);
-  console.log('• The worker handles day rollover automatically');
+  console.log('• The worker automatically creates new daily branches at midnight');
   console.log('• Commits require valid conventional format (feat/fix/docs/etc)');
   console.log('• Message file is cleared after successful push');
   console.log('');

package/start-devops-session.sh

@@ -237,6 +237,142 @@ select_session() {
     fi
 }
 
+# Function to setup house rules and file coordination
+setup_house_rules() {
+    local ROOT="$1"
+    local COORD_DIR="$ROOT/.file-coordination"
+    
+    # Check if we need to update existing house rules (even if coordination is set up)
+    if [[ -f "$SCRIPT_DIR/src/house-rules-manager.js" ]]; then
+        # Check status of house rules
+        local STATUS=$(node "$SCRIPT_DIR/src/house-rules-manager.js" status 2>/dev/null || echo '{"needsUpdate": false, "exists": true}')
+        local NEEDS_UPDATE=$(echo "$STATUS" | grep -o '"needsUpdate"[[:space:]]*:[[:space:]]*true' || echo "")
+        local EXISTS=$(echo "$STATUS" | grep -o '"exists"[[:space:]]*:[[:space:]]*true' || echo "")
+        
+        # Check if house rules were deleted (coordination exists but house rules don't)
+        if [[ -d "$COORD_DIR" ]] && [[ -z "$EXISTS" ]]; then
+            echo -e "${YELLOW}⚠ House rules file appears to be missing!${NC}"
+            echo "The file coordination system is set up, but house rules are gone."
+            echo
+            echo -n "Recreate house rules? (Y/n): "
+            read RECREATE
+            if [[ "${RECREATE}" != "n" ]] && [[ "${RECREATE}" != "N" ]]; then
+                echo -e "${BLUE}Recreating house rules...${NC}"
+                node "$SCRIPT_DIR/src/house-rules-manager.js" update 2>/dev/null
+                echo -e "${GREEN}✓ House rules recreated!${NC}"
+                echo
+            fi
+        elif [[ -n "$NEEDS_UPDATE" ]]; then
+            echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+            echo -e "${BOLD}House Rules Update Available${NC}"
+            echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+            echo
+            echo "The DevOps Agent has updated house rules sections."
+            echo "Your custom rules will be preserved."
+            echo
+            echo -n "Update house rules now? (Y/n): "
+            read UPDATE_CHOICE
+            
+            if [[ "${UPDATE_CHOICE}" != "n" ]] && [[ "${UPDATE_CHOICE}" != "N" ]]; then
+                echo -e "${BLUE}Updating house rules...${NC}"
+                node "$SCRIPT_DIR/src/house-rules-manager.js" update
+                echo -e "${GREEN}✓ House rules updated!${NC}"
+                echo
+            fi
+        fi
+    fi
+    
+    # Check if coordination system is already set up
+    if [[ -d "$COORD_DIR" ]] && [[ -f "$ROOT/check-file-availability.sh" ]]; then
+        return 0  # Already set up
+    fi
+    
+    echo -e "${YELLOW}═══════════════════════════════════════════════════════════${NC}"
+    echo -e "${BOLD}First-time Setup: House Rules & File Coordination${NC}"
+    echo -e "${YELLOW}═══════════════════════════════════════════════════════════${NC}"
+    echo
+    echo "House rules help AI agents understand your project conventions and"
+    echo "prevent conflicts when multiple agents work on the same codebase."
+    echo
+    
+    # Check for existing house rules
+    local HOUSERULES_PATH=""
+    local HOUSERULES_FOUND=false
+    
+    if [[ -f "$ROOT/houserules.md" ]]; then
+        HOUSERULES_PATH="$ROOT/houserules.md"
+        HOUSERULES_FOUND=true
+        echo -e "${GREEN}✓${NC} Found existing house rules at: houserules.md"
+    elif [[ -f "$ROOT/HOUSERULES.md" ]]; then
+        HOUSERULES_PATH="$ROOT/HOUSERULES.md"
+        HOUSERULES_FOUND=true
+        echo -e "${GREEN}✓${NC} Found existing house rules at: HOUSERULES.md"
+    elif [[ -f "$ROOT/.github/HOUSERULES.md" ]]; then
+        HOUSERULES_PATH="$ROOT/.github/HOUSERULES.md"
+        HOUSERULES_FOUND=true
+        echo -e "${GREEN}✓${NC} Found existing house rules at: .github/HOUSERULES.md"
+    elif [[ -f "$ROOT/docs/houserules.md" ]]; then
+        HOUSERULES_PATH="$ROOT/docs/houserules.md"
+        HOUSERULES_FOUND=true
+        echo -e "${GREEN}✓${NC} Found existing house rules at: docs/houserules.md"
+    else
+        echo "No existing house rules found."
+        echo
+        echo "Would you like to:"
+        echo "  ${BOLD}1)${NC} Create comprehensive house rules (recommended)"
+        echo "  ${BOLD}2)${NC} Specify path to existing house rules"
+        echo "  ${BOLD}3)${NC} Skip for now"
+        echo
+        echo -n "Your choice [1]: "
+        read CHOICE
+        
+        case "${CHOICE:-1}" in
+            1)
+                HOUSERULES_PATH="$ROOT/houserules.md"
+                HOUSERULES_FOUND=false
+                echo -e "${GREEN}✓${NC} Will create comprehensive house rules at: houserules.md"
+                ;;
+            2)
+                echo -n "Enter path to your house rules (relative to $ROOT): "
+                read CUSTOM_PATH
+                if [[ -f "$ROOT/$CUSTOM_PATH" ]]; then
+                    HOUSERULES_PATH="$ROOT/$CUSTOM_PATH"
+                    HOUSERULES_FOUND=true
+                    echo -e "${GREEN}✓${NC} Using house rules at: $CUSTOM_PATH"
+                else
+                    echo -e "${YELLOW}File not found. Creating new house rules at: houserules.md${NC}"
+                    HOUSERULES_PATH="$ROOT/houserules.md"
+                    HOUSERULES_FOUND=false
+                fi
+                ;;
+            3)
+                echo -e "${YELLOW}⚠ Skipping house rules setup${NC}"
+                echo "You can set them up later by running: ./scripts/setup-file-coordination.sh"
+                return 0
+                ;;
+        esac
+    fi
+    
+    echo
+    echo -e "${BLUE}Setting up file coordination system...${NC}"
+    
+    # Run the actual setup inline (simplified version)
+    if [[ -f "$SCRIPT_DIR/scripts/setup-file-coordination.sh" ]]; then
+        bash "$SCRIPT_DIR/scripts/setup-file-coordination.sh"
+    else
+        # Inline setup if script doesn't exist
+        mkdir -p "$COORD_DIR/active-edits" "$COORD_DIR/completed-edits"
+        echo -e "${GREEN}✓${NC} File coordination directories created"
+    fi
+    
+    echo
+    echo -e "${GREEN}✓ Setup complete!${NC} AI agents will now follow house rules and coordinate file edits."
+    echo
+    echo -e "${DIM}Press Enter to continue...${NC}"
+    read -r
+    echo
+}
+
 # Main function
 main() {
     # Show copyright first
@@ -256,6 +392,9 @@ main() {
     REPO_ROOT=$(git rev-parse --show-toplevel)
     cd "$REPO_ROOT"
     
+    # Check and setup house rules on first run
+    setup_house_rules "$REPO_ROOT"
+    
     echo -e "${BOLD}Welcome to DevOps Agent Session Manager${NC}"
     echo
     echo "This tool will:"