s9n-devops-agent 1.2.0 → 1.3.1

package/src/display-utils.cjs

@@ -0,0 +1,350 @@
+/**
+ * Display Utilities for CS DevOps Agent
+ * 
+ * Provides consistent, clean formatting for all console output
+ * Ensures professional appearance across all modules
+ */
+
+const COLORS = {
+  // Basic colors
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  
+  // Text colors
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  orange: '\x1b[38;5;208m',
+  
+  // Background colors
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m'
+};
+
+const ICONS = {
+  success: '✓',
+  error: '✗',
+  warning: '⚠',
+  info: 'ℹ',
+  arrow: '→',
+  bullet: '•',
+  lock: '🔒',
+  unlock: '🔓',
+  file: '📄',
+  folder: '📁',
+  clock: '⏱',
+  alert: '🚨',
+  orange: '🟧',
+  red: '🔴',
+  green: '🟢',
+  save: '💾',
+  copy: '📋',
+  robot: '🤖'
+};
+
+class DisplayUtils {
+  constructor() {
+    this.colors = COLORS;
+    this.icons = ICONS;
+    this.terminalWidth = process.stdout.columns || 80;
+  }
+
+  /**
+   * Print a clean header box
+   */
+  header(title, subtitle = '') {
+    const width = Math.min(this.terminalWidth, 70);
+    const line = '═'.repeat(width);
+    const padding = Math.floor((width - title.length) / 2);
+    
+    console.log();
+    console.log(this.colors.cyan + line + this.colors.reset);
+    console.log(this.colors.bright + ' '.repeat(padding) + title + this.colors.reset);
+    if (subtitle) {
+      const subPadding = Math.floor((width - subtitle.length) / 2);
+      console.log(this.colors.dim + ' '.repeat(subPadding) + subtitle + this.colors.reset);
+    }
+    console.log(this.colors.cyan + line + this.colors.reset);
+    console.log();
+  }
+
+  /**
+   * Print a section header
+   */
+  section(title) {
+    const width = Math.min(this.terminalWidth, 70);
+    const line = '─'.repeat(width);
+    
+    console.log();
+    console.log(this.colors.blue + this.colors.bright + title + this.colors.reset);
+    console.log(this.colors.dim + line + this.colors.reset);
+  }
+
+  /**
+   * Print a subsection
+   */
+  subsection(title) {
+    console.log();
+    console.log(this.colors.cyan + '▸ ' + title + this.colors.reset);
+  }
+
+  /**
+   * Success message
+   */
+  success(message, detail = '') {
+    console.log(
+      this.colors.green + this.icons.success + this.colors.reset + 
+      ' ' + message +
+      (detail ? this.colors.dim + ' (' + detail + ')' + this.colors.reset : '')
+    );
+  }
+
+  /**
+   * Error message
+   */
+  error(message, detail = '') {
+    console.log(
+      this.colors.red + this.icons.error + this.colors.reset + 
+      ' ' + message +
+      (detail ? this.colors.dim + ' (' + detail + ')' + this.colors.reset : '')
+    );
+  }
+
+  /**
+   * Warning message
+   */
+  warning(message, detail = '') {
+    console.log(
+      this.colors.yellow + this.icons.warning + this.colors.reset + 
+      ' ' + message +
+      (detail ? this.colors.dim + ' (' + detail + ')' + this.colors.reset : '')
+    );
+  }
+
+  /**
+   * Info message
+   */
+  info(message, detail = '') {
+    console.log(
+      this.colors.cyan + this.icons.info + this.colors.reset + 
+      ' ' + message +
+      (detail ? this.colors.dim + ' (' + detail + ')' + this.colors.reset : '')
+    );
+  }
+
+  /**
+   * Step/progress indicator
+   */
+  step(number, total, message) {
+    console.log(
+      this.colors.blue + `[${number}/${total}]` + this.colors.reset +
+      ' ' + message
+    );
+  }
+
+  /**
+   * Print a list item
+   */
+  listItem(message, indent = 2) {
+    console.log(' '.repeat(indent) + this.icons.bullet + ' ' + message);
+  }
+
+  /**
+   * Print key-value pair
+   */
+  keyValue(key, value, indent = 2) {
+    console.log(
+      ' '.repeat(indent) +
+      this.colors.dim + key + ':' + this.colors.reset + ' ' +
+      this.colors.bright + value + this.colors.reset
+    );
+  }
+
+  /**
+   * Print a table
+   */
+  table(headers, rows) {
+    // Calculate column widths
+    const widths = headers.map((h, i) => {
+      const headerWidth = h.length;
+      const maxRowWidth = Math.max(...rows.map(r => String(r[i]).length));
+      return Math.max(headerWidth, maxRowWidth) + 2;
+    });
+
+    // Print headers
+    const headerRow = headers.map((h, i) => 
+      h.padEnd(widths[i])
+    ).join('│ ');
+    
+    console.log();
+    console.log(this.colors.bright + headerRow + this.colors.reset);
+    console.log('─'.repeat(headerRow.length));
+
+    // Print rows
+    rows.forEach(row => {
+      const rowStr = row.map((cell, i) => 
+        String(cell).padEnd(widths[i])
+      ).join('│ ');
+      console.log(rowStr);
+    });
+    console.log();
+  }
+
+  /**
+   * Print emoji-based alert boxes (keeping the visual impact)
+   */
+  alertBox(type, title, message, instructions = null) {
+    const width = Math.min(this.terminalWidth, 70);
+    let borderChar, icon;
+    
+    switch(type) {
+      case 'conflict':
+        borderChar = '🔴';
+        icon = '🔴';
+        break;
+      case 'warning':
+        borderChar = '🟧';
+        icon = '🟧';
+        break;
+      default:
+        borderChar = '⚠️';
+        icon = '⚠️';
+    }
+
+    // Emoji border (much more eye-catching!)
+    console.log();
+    console.log(borderChar.repeat(30));
+    console.log(borderChar + '  ' + title);
+    console.log(borderChar.repeat(30));
+    
+    // Message
+    console.log();
+    if (Array.isArray(message)) {
+      message.forEach(line => console.log(line));
+    } else {
+      console.log(message);
+    }
+    
+    // Instructions
+    if (instructions) {
+      console.log();
+      console.log('📋 COPY THIS TO YOUR AGENT:');
+      console.log('─'.repeat(width));
+      console.log(instructions);
+      console.log('─'.repeat(width));
+    }
+    
+    console.log();
+    console.log(borderChar.repeat(30));
+    console.log();
+  }
+
+  /**
+   * Print a progress bar
+   */
+  progressBar(current, total, label = '') {
+    const width = 30;
+    const percentage = Math.round((current / total) * 100);
+    const filled = Math.round((current / total) * width);
+    const empty = width - filled;
+    
+    const bar = 
+      this.colors.green + '█'.repeat(filled) + 
+      this.colors.dim + '░'.repeat(empty) + this.colors.reset;
+    
+    console.log(
+      `${label} ${bar} ${percentage}% (${current}/${total})`
+    );
+  }
+
+  /**
+   * Clear line and rewrite (for updating status)
+   */
+  updateLine(message) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    process.stdout.write(message);
+  }
+
+  /**
+   * Print session info in a clean format
+   */
+  sessionInfo(sessionData) {
+    this.section('Session Information');
+    this.keyValue('Session ID', sessionData.sessionId);
+    this.keyValue('Task', sessionData.task || 'General development');
+    this.keyValue('Branch', sessionData.branchName);
+    this.keyValue('Status', sessionData.status);
+    if (sessionData.worktreePath) {
+      this.keyValue('Worktree', sessionData.worktreePath);
+    }
+    if (sessionData.claimedBy) {
+      this.keyValue('Agent', sessionData.claimedBy);
+    }
+  }
+
+  /**
+   * Print a clean menu
+   */
+  menu(title, options) {
+    this.section(title);
+    options.forEach((option, index) => {
+      const key = option.key || (index + 1);
+      const label = option.label || option;
+      const desc = option.description || '';
+      
+      console.log(
+        '  ' +
+        this.colors.cyan + '[' + key + ']' + this.colors.reset + ' ' +
+        this.colors.bright + label + this.colors.reset +
+        (desc ? '\n      ' + this.colors.dim + desc + this.colors.reset : '')
+      );
+    });
+    console.log();
+  }
+
+  /**
+   * Print instructions for agents
+   */
+  agentInstructions(sessionId, worktreePath, task) {
+    const width = Math.min(this.terminalWidth, 70);
+    const line = '═'.repeat(width);
+    
+    console.log();
+    console.log(this.colors.bgCyan + this.colors.black + ' INSTRUCTIONS FOR AI AGENT ' + this.colors.reset);
+    console.log(this.colors.cyan + line + this.colors.reset);
+    console.log();
+    console.log('I\'m working in a DevOps-managed session with the following setup:');
+    console.log(`• Session ID: ${sessionId}`);
+    console.log(`• Working Directory: ${worktreePath}`);
+    console.log(`• Task: ${task || 'development'}`);
+    console.log();
+    console.log('Please switch to this directory before making any changes:');
+    console.log(this.colors.yellow + `cd "${worktreePath}"` + this.colors.reset);
+    console.log();
+    console.log(this.colors.bright + 'IMPORTANT: File Coordination Protocol' + this.colors.reset);
+    console.log('Before editing ANY files, you MUST:');
+    console.log('1. Declare your intent by creating .file-coordination/active-edits/<agent>-' + sessionId + '.json');
+    console.log('2. List all files you plan to edit in that JSON file');
+    console.log('3. Check for conflicts with other agents\' declarations');
+    console.log('4. Only proceed if no conflicts exist');
+    console.log('5. Release the files when done');
+    console.log();
+    console.log('Write commit messages to: ' + this.colors.yellow + `.devops-commit-${sessionId}.msg` + this.colors.reset);
+    console.log('The DevOps agent will automatically commit and push changes.');
+    console.log();
+    console.log(this.colors.cyan + line + this.colors.reset);
+  }
+}
+
+module.exports = new DisplayUtils();

package/src/file-coordinator.cjs

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+
+/**
+ * File Coordination System for Multi-Agent Development
+ * 
+ * This module provides conflict detection and reporting for multiple agents
+ * editing files in the same repository. It implements an advisory lock system
+ * where agents declare their intent to edit files, and conflicts are reported
+ * to users for resolution.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+class FileCoordinator {
+  constructor(sessionId, workingDir = process.cwd()) {
+    this.sessionId = sessionId;
+    this.workingDir = workingDir;
+    this.coordDir = path.join(workingDir, '.file-coordination');
+    this.activeEditsDir = path.join(this.coordDir, 'active-edits');
+    this.completedEditsDir = path.join(this.coordDir, 'completed-edits');
+    this.conflictsDir = path.join(this.coordDir, 'conflicts');
+    
+    // Ensure directories exist
+    this.ensureDirectories();
+  }
+
+  ensureDirectories() {
+    [this.coordDir, this.activeEditsDir, this.completedEditsDir, this.conflictsDir].forEach(dir => {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    });
+  }
+
+  /**
+   * Get all active declarations from other agents
+   */
+  getActiveDeclarations() {
+    const declarations = {};
+    
+    if (!fs.existsSync(this.activeEditsDir)) {
+      return declarations;
+    }
+
+    const files = fs.readdirSync(this.activeEditsDir);
+    
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        try {
+          const content = fs.readFileSync(path.join(this.activeEditsDir, file), 'utf8');
+          const declaration = JSON.parse(content);
+          
+          // Check if declaration is still valid (not expired)
+          const declaredAt = new Date(declaration.declaredAt);
+          const estimatedDuration = declaration.estimatedDuration || 300; // 5 minutes default
+          const expiresAt = new Date(declaredAt.getTime() + estimatedDuration * 1000);
+          
+          if (new Date() < expiresAt) {
+            declarations[file] = declaration;
+          } else {
+            // Move expired declaration to completed
+            this.moveToCompleted(file);
+          }
+        } catch (err) {
+          console.error(`Error reading declaration ${file}:`, err.message);
+        }
+      }
+    }
+    
+    return declarations;
+  }
+
+  /**
+   * Check if specific files are currently being edited by other agents
+   */
+  checkFilesForConflicts(filesToCheck) {
+    const conflicts = [];
+    const declarations = this.getActiveDeclarations();
+    
+    for (const [declFile, declaration] of Object.entries(declarations)) {
+      // Skip our own declarations
+      if (declaration.session === this.sessionId) {
+        continue;
+      }
+      
+      // Check for file overlaps
+      const declaredFiles = declaration.files || [];
+      for (const file of filesToCheck) {
+        if (declaredFiles.includes(file)) {
+          conflicts.push({
+            file,
+            conflictsWith: declaration.agent,
+            session: declaration.session,
+            reason: declaration.reason || 'No reason provided',
+            declaredAt: declaration.declaredAt
+          });
+        }
+      }
+    }
+    
+    return conflicts;
+  }
+
+  /**
+   * Detect conflicts between actual changes and declared edits
+   */
+  async detectUndeclaredEdits() {
+    try {
+      // Get list of modified files from git
+      const modifiedFiles = execSync('git diff --name-only', {
+        cwd: this.workingDir,
+        encoding: 'utf8'
+      }).trim().split('\n').filter(f => f);
+      
+      const stagedFiles = execSync('git diff --cached --name-only', {
+        cwd: this.workingDir,
+        encoding: 'utf8'
+      }).trim().split('\n').filter(f => f);
+      
+      const allChangedFiles = [...new Set([...modifiedFiles, ...stagedFiles])];
+      
+      if (allChangedFiles.length === 0) {
+        return { hasConflicts: false };
+      }
+      
+      // Check if these files are declared by someone
+      const conflicts = this.checkFilesForConflicts(allChangedFiles);
+      
+      // Check if we have our own declaration
+      const ourDeclarationFile = this.findOurDeclaration();
+      let ourDeclaredFiles = [];
+      
+      if (ourDeclarationFile) {
+        try {
+          const content = fs.readFileSync(ourDeclarationFile, 'utf8');
+          const declaration = JSON.parse(content);
+          ourDeclaredFiles = declaration.files || [];
+        } catch (err) {
+          console.error('Error reading our declaration:', err.message);
+        }
+      }
+      
+      // Find undeclared edits (files we changed but didn't declare)
+      const undeclaredEdits = allChangedFiles.filter(
+        file => !ourDeclaredFiles.includes(file)
+      );
+      
+      return {
+        hasConflicts: conflicts.length > 0 || undeclaredEdits.length > 0,
+        conflicts,
+        undeclaredEdits,
+        allChangedFiles
+      };
+      
+    } catch (err) {
+      console.error('Error detecting undeclared edits:', err.message);
+      return { hasConflicts: false, error: err.message };
+    }
+  }
+
+  /**
+   * Find our current declaration file
+   */
+  findOurDeclaration() {
+    if (!fs.existsSync(this.activeEditsDir)) {
+      return null;
+    }
+    
+    const files = fs.readdirSync(this.activeEditsDir);
+    
+    for (const file of files) {
+      if (file.includes(this.sessionId) && file.endsWith('.json')) {
+        return path.join(this.activeEditsDir, file);
+      }
+    }
+    
+    // Try to find by session ID in content
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        try {
+          const content = fs.readFileSync(path.join(this.activeEditsDir, file), 'utf8');
+          const declaration = JSON.parse(content);
+          if (declaration.session === this.sessionId) {
+            return path.join(this.activeEditsDir, file);
+          }
+        } catch (err) {
+          // Skip invalid files
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Create a conflict report for the user
+   */
+  createConflictReport(conflictData) {
+    const timestamp = new Date().toISOString();
+    const reportFile = path.join(this.conflictsDir, `conflict-${this.sessionId}-${Date.now()}.md`);
+    
+    let report = `# ⚠️ FILE COORDINATION CONFLICT DETECTED\n\n`;
+    report += `**Time:** ${timestamp}\n`;
+    report += `**Session:** ${this.sessionId}\n\n`;
+    
+    if (conflictData.conflicts && conflictData.conflicts.length > 0) {
+      report += `## 🔒 Files Being Edited by Other Agents\n\n`;
+      report += `The following files are currently being edited by other agents:\n\n`;
+      
+      for (const conflict of conflictData.conflicts) {
+        report += `### ${conflict.file}\n`;
+        report += `- **Blocked by:** ${conflict.conflictsWith} (session: ${conflict.session})\n`;
+        report += `- **Reason:** ${conflict.reason}\n`;
+        report += `- **Since:** ${conflict.declaredAt}\n\n`;
+      }
+      
+      report += `### ❌ ACTION REQUIRED\n\n`;
+      report += `You have attempted to edit files that are currently locked by other agents.\n\n`;
+      report += `**Options:**\n`;
+      report += `1. **Wait** for the other agent to complete their edits\n`;
+      report += `2. **Coordinate** with ${conflictData.conflicts[0].conflictsWith} to resolve the conflict\n`;
+      report += `3. **Choose different files** to edit\n`;
+      report += `4. **Force override** (not recommended - will cause merge conflicts)\n\n`;
+    }
+    
+    if (conflictData.undeclaredEdits && conflictData.undeclaredEdits.length > 0) {
+      report += `## 📝 Undeclared File Edits\n\n`;
+      report += `The following files were edited without declaration:\n\n`;
+      
+      for (const file of conflictData.undeclaredEdits) {
+        report += `- ${file}\n`;
+      }
+      
+      report += `\n### ⚠️ ADVISORY WARNING\n\n`;
+      report += `These files were modified without following the coordination protocol.\n\n`;
+      report += `**To fix this:**\n`;
+      report += `1. Run: \`./scripts/coordination/declare-file-edits.sh ${this.sessionId.split('-')[0]} ${this.sessionId} ${conflictData.undeclaredEdits.join(' ')}\`\n`;
+      report += `2. Or revert these changes if they were unintentional\n\n`;
+    }
+    
+    report += `## 📋 How to Resolve\n\n`;
+    report += `1. **Check current declarations:**\n`;
+    report += `   \`\`\`bash\n`;
+    report += `   ls -la .file-coordination/active-edits/\n`;
+    report += `   \`\`\`\n\n`;
+    report += `2. **Declare your intended edits:**\n`;
+    report += `   \`\`\`bash\n`;
+    report += `   ./scripts/coordination/declare-file-edits.sh <agent-name> ${this.sessionId} <files...>\n`;
+    report += `   \`\`\`\n\n`;
+    report += `3. **Release files when done:**\n`;
+    report += `   \`\`\`bash\n`;
+    report += `   ./scripts/coordination/release-file-edits.sh <agent-name> ${this.sessionId}\n`;
+    report += `   \`\`\`\n\n`;
+    
+    report += `---\n`;
+    report += `*This report was generated automatically by the File Coordination System*\n`;
+    
+    // Write report
+    fs.writeFileSync(reportFile, report);
+    
+    // Also write a simplified alert to stdout
+    console.log('\n' + '='.repeat(60));
+    console.log('⚠️  FILE COORDINATION CONFLICT DETECTED');
+    console.log('='.repeat(60));
+    
+    if (conflictData.conflicts && conflictData.conflicts.length > 0) {
+      console.log('\n❌ BLOCKED FILES:');
+      for (const conflict of conflictData.conflicts) {
+        console.log(`   ${conflict.file} (locked by ${conflict.conflictsWith})`);
+      }
+    }
+    
+    if (conflictData.undeclaredEdits && conflictData.undeclaredEdits.length > 0) {
+      console.log('\n📝 UNDECLARED EDITS:');
+      for (const file of conflictData.undeclaredEdits) {
+        console.log(`   ${file}`);
+      }
+    }
+    
+    console.log(`\n📄 Full report: ${reportFile}`);
+    console.log('='.repeat(60) + '\n');
+    
+    return reportFile;
+  }
+
+  /**
+   * Move a declaration to completed
+   */
+  moveToCompleted(filename) {
+    const sourcePath = path.join(this.activeEditsDir, filename);
+    const destPath = path.join(this.completedEditsDir, filename);
+    
+    try {
+      if (fs.existsSync(sourcePath)) {
+        fs.renameSync(sourcePath, destPath);
+      }
+    } catch (err) {
+      console.error(`Error moving ${filename} to completed:`, err.message);
+    }
+  }
+
+  /**
+   * Clean up old/stale declarations
+   */
+  cleanupStaleDeclarations(maxAgeMinutes = 60) {
+    const now = new Date();
+    const maxAge = maxAgeMinutes * 60 * 1000;
+    
+    if (!fs.existsSync(this.activeEditsDir)) {
+      return;
+    }
+    
+    const files = fs.readdirSync(this.activeEditsDir);
+    let cleaned = 0;
+    
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        const filePath = path.join(this.activeEditsDir, file);
+        const stats = fs.statSync(filePath);
+        const age = now - stats.mtime;
+        
+        if (age > maxAge) {
+          this.moveToCompleted(file);
+          cleaned++;
+        }
+      }
+    }
+    
+    if (cleaned > 0) {
+      console.log(`Cleaned up ${cleaned} stale declaration(s)`);
+    }
+  }
+}
+
+// Export for use in other modules
+module.exports = FileCoordinator;
+
+// If run directly, perform a conflict check
+if (require.main === module) {
+  const sessionId = process.env.DEVOPS_SESSION_ID || 'manual-check';
+  const coordinator = new FileCoordinator(sessionId);
+  
+  console.log('Checking for file coordination conflicts...');
+  
+  coordinator.detectUndeclaredEdits().then(result => {
+    if (result.hasConflicts) {
+      coordinator.createConflictReport(result);
+      process.exit(1);
+    } else {
+      console.log('✅ No conflicts detected');
+      process.exit(0);
+    }
+  });
+}