s9n-devops-agent 2.0.13 → 2.0.18-dev.0

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

@@ -729,8 +729,13 @@ async function commitOnce(repoRoot, msgPath) {
       msg = rest.length > 0 ? `${msg}\n${rest.join('\n')}${infraDetails}` : `${msg}${infraDetails}`;
     }
 
+const REQUIRE_AI_COMMIT = (process.env.AC_AI_COMMIT || "false").toLowerCase() === "true";
+
+// ...
+
     let committed = false;
     if (REQUIRE_MSG && conventionalHeaderOK(msg)) {
+      // (Existing commit logic...)
       // Update infrastructure documentation before commit
       if (infraChanges.hasInfraChanges) {
         await updateInfrastructureDoc(infraChanges, msg);
@@ -753,6 +758,47 @@ async function commitOnce(repoRoot, msgPath) {
       fs.writeFileSync(tmp, msg + "\n");
       committed = (await run("git", ["commit", "-F", tmp])).ok;
       try { fs.unlinkSync(tmp); } catch {}
+    } else if (REQUIRE_MSG && !conventionalHeaderOK(msg) && REQUIRE_AI_COMMIT) {
+      // AI COMMIT GENERATION
+      log("generating AI commit message...");
+      
+      // Look for the script in scripts/ or ../scripts/
+      let scriptPath = path.join(process.cwd(), 'scripts', 'generate-ai-commit.js');
+      if (!fs.existsSync(scriptPath)) {
+        // Try looking relative to __dirname
+        scriptPath = path.resolve(__dirname, '..', 'scripts', 'generate-ai-commit.js');
+      }
+      
+      if (fs.existsSync(scriptPath)) {
+        try {
+          const { stdout } = await execa('node', [scriptPath], { 
+            stdio: 'inherit',
+            env: { ...process.env, GROQ_API_KEY: process.env.GROQ_API_KEY } 
+          });
+          
+          // Re-read message after generation
+          msg = readMsgFile(msgPath);
+          if (conventionalHeaderOK(msg)) {
+             // Recursive call or just proceed? Let's proceed with commit logic duplicated or simple recursion
+             // To avoid recursion complexity, let's just commit here
+             
+             // ... Duplicated commit logic or recursive call
+             // Let's recursively call commitOnce to keep it clean (busy flag handles concurrency)
+             busy = false; // Reset busy temporarily
+             await commitOnce(repoRoot, msgPath);
+             return; 
+          }
+        } catch (err) {
+          log(`AI generation failed: ${err.message}`);
+        }
+      } else {
+        log(`AI script not found at ${scriptPath}`);
+      }
+      
+      if (!committed) {
+         log("message still not ready after AI attempt; skipping commit");
+         return;
+      }
     } else if (!REQUIRE_MSG) {
       committed = (await run("git", ["commit", "-m", "chore: cs-devops-agent"])).ok;
     } else {
@@ -764,6 +810,16 @@ async function commitOnce(repoRoot, msgPath) {
     if (CLEAR_MSG_WHEN === "commit") clearMsgFile(msgPath);
 
     const sha = (await run("git", ["rev-parse", "--short", "HEAD"])).stdout.trim();
+    
+    // VISIBLE NOTIFICATION FOR USER
+    console.log("\n" + "─".repeat(60));
+    console.log(`\x1b[32m✓ COMMITTED:\x1b[0m ${sha}`);
+    console.log(`  Branch:  ${await currentBranch()}`);
+    console.log(`  Message: ${header}`);
+    console.log("");
+    console.log(`\x1b[36m💡 TO FINISH:\x1b[0m Type \x1b[1mexit\x1b[0m to close session and cleanup`);
+    console.log("─".repeat(60) + "\n");
+    
     log(`committed ${sha} on ${await currentBranch()}`);
 
     if (PUSH) {
@@ -772,8 +828,13 @@ async function commitOnce(repoRoot, msgPath) {
       if (ok) {
         if (CLEAR_MSG_WHEN === "push") clearMsgFile(msgPath);
         
+        console.log(`\x1b[32m✓ PUSHED:\x1b[0m ${BRANCH} -> remote`);
+        console.log(""); // Empty line for spacing
+        
         // Handle Docker restart if configured
         await handleDockerRestart();
+      } else {
+        console.log(`\x1b[31m✗ PUSH FAILED:\x1b[0m Check logs for details`);
       }
     }
   } finally {
@@ -1564,6 +1625,23 @@ console.log();
     ],
   })
   .on("all", async (evt, p) => {
+    // Check if file is in local_deploy or .file-coordination (internal agent files)
+    if (p.includes('local_deploy/') || p.includes('.file-coordination/')) {
+      return;
+    }
+
+    // Check if file is ignored by git (respect .gitignore)
+    try {
+      // git check-ignore returns 0 if ignored, 1 if not ignored
+      // We use quiet mode (-q) and ignore stdio
+      execSync(`git check-ignore -q "${p}"`, { stdio: 'ignore' });
+      // If we get here, exit code was 0, so file IS ignored
+      if (DEBUG) console.log(`[debug] Ignoring gitignored file: ${p}`);
+      return;
+    } catch (e) {
+      // Exit code 1 means NOT ignored (or other error). Proceed.
+    }
+
     const now = Date.now();
     const isMsg = samePath(p, relMsg);
     
@@ -1618,8 +1696,10 @@ console.log();
   // INTERACTIVE COMMAND INTERFACE - Handle user commands during execution
   // ============================================================================
   
-  // Extract session ID from branch name or message file
+  // Extract session ID from environment, branch name, or message file
   const sessionId = (() => {
+    if (process.env.DEVOPS_SESSION_ID) return process.env.DEVOPS_SESSION_ID;
+    
     const branch = STATIC_BRANCH || BRANCH;
     const match = branch.match(/([a-z0-9]{4}-[a-z0-9]{4})/i);
     if (match) return match[1];
@@ -1651,7 +1731,7 @@ console.log();
   const rl = readline.createInterface({
     input: input,
     output: output,
-    prompt: '[agent] > ',
+    prompt: '\\x1b[36m[agent] >\\x1b[0m ',
     terminal: true
   });
   
@@ -1754,7 +1834,7 @@ console.log();
       case 'exit':
       case 'quit':
       case 'q':
-        console.log("\nInitiating clean shutdown...");
+        console.log("\\n\\x1b[35m[Session] Initiating clean shutdown...\\x1b[0m");
         
         // Check for uncommitted changes
         const uncommitted = await hasUncommittedChanges();
@@ -1995,7 +2075,7 @@ console.log();
           }
         }
         
-        console.log("\nGoodbye!");
+        console.log("\n\\x1b[35m[Session] Exiting worker process...\\x1b[0m");
         rl.close();
         process.exit(0);
         break;

package/src/house-rules-manager.js

@@ -166,10 +166,10 @@ class HouseRulesManager {
 
   /**
    * Find existing house rules file
-   * Searches across the repository, excluding the DevOps agent directories
+   * STRICT MODE: Only searches in the project root
    */
   findHouseRulesFile() {
-    // First try the standard locations
+    // Standard locations in root only
     const possiblePaths = [
       'houserules.md',
       'HOUSERULES.md',
@@ -195,18 +195,8 @@ class HouseRulesManager {
       }
     }
 
-    // If not found in standard locations, search the repository
-    // excluding DevOps agent directories
-    const foundPath = this.searchForHouseRules(this.projectRoot);
-    if (foundPath) {
-      this.houseRulesPath = foundPath;
-      // Only log if not running as CLI
-      if (!process.argv[1]?.endsWith('house-rules-manager.js')) {
-        console.log(`Found house rules at: ${foundPath}`);
-      }
-      return foundPath;
-    }
-
+    // STRICT MODE: Do not search recursively.
+    // If not found in root, return null.
     return null;
   }
 

package/src/instruction-formatter.js

@@ -151,7 +151,15 @@ export function formatInstructions(session, options = {}) {
     lines.push('');
   }
   
-  // Footer
+  // STOP instruction
+  lines.push('━'.repeat(70));
+  lines.push('');
+  lines.push(`${colors.red}${status.warning} IMPORTANT: STOP HERE${colors.reset}`);
+  lines.push('');
+  lines.push(`${colors.bright}Do NOT start coding or making changes yet!${colors.reset}`);
+  lines.push(`${colors.dim}Follow the steps above in order when instructed.${colors.reset}`);
+  lines.push(`${colors.dim}Wait for further instructions from the user before proceeding.${colors.reset}`);
+  lines.push('');
   lines.push('━'.repeat(70));
   lines.push('');
   lines.push(`${status.checkmark} ${colors.green}DevOps Agent is now monitoring this session...${colors.reset}`);

package/src/session-coordinator.js

@@ -62,7 +62,7 @@ const CONFIG = {
 // SESSION COORDINATOR CLASS
 // ============================================================================
 
-class SessionCoordinator {
+export class SessionCoordinator {
   constructor() {
     this.repoRoot = this.getRepoRoot();
     this.sessionsPath = path.join(this.repoRoot, CONFIG.sessionsDir);
@@ -265,20 +265,129 @@ class SessionCoordinator {
     }
   }
   
+  /**
+   * Initialize House Rules Contracts folder and files
+   */
+  async initializeContractsFolder() {
+    const contractsDir = path.join(this.repoRoot, 'House_Rules_Contracts');
+    
+    // Check if contracts folder already exists
+    if (fs.existsSync(contractsDir)) {
+      console.log(`${CONFIG.colors.dim}✓ Contracts folder already exists${CONFIG.colors.reset}`);
+      return;
+    }
+    
+    console.log(`\n${CONFIG.colors.blue}Creating contracts folder...${CONFIG.colors.reset}`);
+    
+    try {
+      // Create contracts directory
+      fs.mkdirSync(contractsDir, { recursive: true });
+      
+      // Find the npm package location to copy templates
+      const packageRoot = path.resolve(__dirname, '..');
+      const contractsTemplateDir = path.join(packageRoot, 'House_Rules_Contracts');
+      
+      if (fs.existsSync(contractsTemplateDir)) {
+        // Copy all contract template files
+        const files = fs.readdirSync(contractsTemplateDir);
+        let copiedCount = 0;
+        
+        for (const file of files) {
+          if (file.endsWith('.md') || file.endsWith('.json')) {
+            const srcPath = path.join(contractsTemplateDir, file);
+            const destPath = path.join(contractsDir, file);
+            const content = fs.readFileSync(srcPath, 'utf8');
+            fs.writeFileSync(destPath, content);
+            copiedCount++;
+          }
+        }
+        
+        console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Created contracts folder with ${copiedCount} template files`);
+        console.log(`${CONFIG.colors.dim}  Location: ${contractsDir}${CONFIG.colors.reset}`);
+        console.log(`${CONFIG.colors.dim}  Files: API_CONTRACT.md, DATABASE_SCHEMA_CONTRACT.md, SQL_CONTRACT.json, etc.${CONFIG.colors.reset}`);
+      } else {
+        // Fallback: create empty contracts folder with basic README
+        const readmeContent = `# House Rules Contracts\n\nThis folder contains contract files that document all project components.\n\nSee houserules.md for complete documentation on the Contract System.\n`;
+        fs.writeFileSync(path.join(contractsDir, 'README.md'), readmeContent);
+        console.log(`${CONFIG.colors.yellow}⚠ Created empty contracts folder (templates not found in package)${CONFIG.colors.reset}`);
+        console.log(`${CONFIG.colors.dim}  You can manually populate contract files from the DevOps Agent repository${CONFIG.colors.reset}`);
+      }
+    } catch (err) {
+      console.log(`${CONFIG.colors.red}✗ Error creating contracts folder: ${err.message}${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  You can manually create House_Rules_Contracts/ folder${CONFIG.colors.reset}`);
+    }
+  }
+  
   /**
    * Ensure house rules are set up for the project
    */
   async ensureHouseRulesSetup() {
     const houseRulesManager = new HouseRulesManager(this.repoRoot);
+    const houseRulesPath = path.join(this.repoRoot, 'houserules.md');
     
     // Check if house rules exist
-    if (!houseRulesManager.houseRulesPath || !fs.existsSync(houseRulesManager.houseRulesPath)) {
+    if (!fs.existsSync(houseRulesPath)) {
       console.log(`\n${CONFIG.colors.yellow}House rules not found - creating default house rules...${CONFIG.colors.reset}`);
-      // Auto-create default house rules without prompting
-      const result = await houseRulesManager.updateHouseRules({ createIfMissing: true, backupExisting: false });
-      if (result.created) {
-        console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} House rules created at: ${CONFIG.colors.bright}${result.path}${CONFIG.colors.reset}`);
+      console.log(`\n${CONFIG.colors.bright}=== Folder Organization Strategy ===${CONFIG.colors.reset}`);
+      console.log();
+      console.log(`${CONFIG.colors.bright}Option 1: STRUCTURED Organization${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • NEW code follows a module-based structure:${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}    ModuleName/src/featurename/   (source code)${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}    ModuleName/test/featurename/  (tests)${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • Existing files stay where they are (no moving!)${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • Benefits: Better discoverability, clear ownership, scales well${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • Best for: Larger projects, teams, microservices${CONFIG.colors.reset}`);
+      console.log();
+      console.log(`${CONFIG.colors.bright}Option 2: FLEXIBLE Organization${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • Use any folder structure you prefer${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • No enforced patterns for new code${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • Benefits: Freedom, simplicity, less overhead${CONFIG.colors.reset}`);
+      console.log(`${CONFIG.colors.dim}  • Best for: Small projects, prototypes, solo developers${CONFIG.colors.reset}`);
+      console.log();
+      console.log(`${CONFIG.colors.yellow}Note: Both include the full contract system for preventing duplicate work.${CONFIG.colors.reset}`);
+      
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      
+      const wantsStructure = await new Promise((resolve) => {
+        rl.question(`${CONFIG.colors.green}Use structured organization? (Y/n):${CONFIG.colors.reset} `, (answer) => {
+          rl.close();
+          resolve(answer.toLowerCase() !== 'n');
+        });
+      });
+      
+      // Determine which template to copy
+      const templateName = wantsStructure ? 'houserules_structured.md' : 'houserules.md';
+      
+      // Find the npm package location (where this script is running from)
+      // session-coordinator.js is in src/, so package root is one level up
+      const packageRoot = path.resolve(__dirname, '..');
+      const templatePath = path.join(packageRoot, templateName);
+      
+      // Copy the template to the project root
+      try {
+        if (fs.existsSync(templatePath)) {
+          const templateContent = fs.readFileSync(templatePath, 'utf8');
+          fs.writeFileSync(houseRulesPath, templateContent);
+          console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} House rules created at: ${CONFIG.colors.bright}${houseRulesPath}${CONFIG.colors.reset}`);
+          console.log(`${CONFIG.colors.dim}Using ${wantsStructure ? 'structured' : 'flexible'} organization template${CONFIG.colors.reset}`);
+        } else {
+          console.log(`${CONFIG.colors.yellow}⚠ Template not found, creating basic house rules...${CONFIG.colors.reset}`);
+          // Fallback to programmatic creation
+          const result = await houseRulesManager.updateHouseRules({ createIfMissing: true, backupExisting: false });
+          if (result.created) {
+            console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} House rules created at: ${CONFIG.colors.bright}${result.path}${CONFIG.colors.reset}`);
+          }
+        }
+      } catch (err) {
+        console.log(`${CONFIG.colors.red}✗ Error creating house rules: ${err.message}${CONFIG.colors.reset}`);
+        console.log(`${CONFIG.colors.dim}You can manually create houserules.md in your project root${CONFIG.colors.reset}`);
       }
+      
+      // Initialize contracts folder after house rules are created
+      await this.initializeContractsFolder();
     } else {
       // House rules exist - check if they need updating
       const status = houseRulesManager.getStatus();
@@ -1014,7 +1123,44 @@ class SessionCoordinator {
     
     const sessionId = this.generateSessionId();
     const task = options.task || 'development';
-    const agentType = options.agent || 'claude';
+    
+    // If agent type wasn't provided, ask for it now
+    let agentType = options.agent;
+    if (!agentType) {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      
+      console.log(`\n${CONFIG.colors.blue}Select Agent Type:${CONFIG.colors.reset}`);
+      console.log(`  1) Claude (default)`);
+      console.log(`  2) Cline`);
+      console.log(`  3) Cursor`);
+      console.log(`  4) Copilot`);
+      console.log(`  5) Warp`);
+      console.log(`  6) Custom\n`);
+      
+      const agentChoice = await new Promise(resolve => {
+        rl.question('Agent [1]: ', resolve);
+      });
+      
+      switch(agentChoice.trim() || '1') {
+        case '1': agentType = 'claude'; break;
+        case '2': agentType = 'cline'; break;
+        case '3': agentType = 'cursor'; break;
+        case '4': agentType = 'copilot'; break;
+        case '5': agentType = 'warp'; break;
+        case '6':
+          agentType = await new Promise(resolve => {
+            rl.question('Enter agent name: ', resolve);
+          });
+          agentType = agentType.trim() || 'claude';
+          break;
+        default: agentType = 'claude';
+      }
+      rl.close();
+    }
+    
     const devInitials = this.getDeveloperInitials();
     
     console.log(`\n${CONFIG.colors.bgBlue}${CONFIG.colors.bright} Creating New Session ${CONFIG.colors.reset}`);
@@ -1405,6 +1551,11 @@ The DevOps agent will automatically:
     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(`⛔ IMPORTANT: STOP HERE AND WAIT`);
+    console.log(`Do NOT start coding or making changes yet!`);
+    console.log(`Follow the steps above in order when instructed by the user.`);
+    console.log(`Wait for further instructions before proceeding.`);
     console.log();
     
     console.log(`${CONFIG.colors.yellow}══════════════════════════════════════════════════════════════${CONFIG.colors.reset}`);
@@ -2173,7 +2324,8 @@ async function main() {
             console.log(`  2) Cline`);
             console.log(`  3) Cursor`);
             console.log(`  4) Copilot`);
-            console.log(`  5) Custom\n`);
+            console.log(`  5) Warp`);
+            console.log(`  6) Custom\n`);
             
             const agentChoice = await new Promise(resolve => {
               rl.question('Agent [1]: ', resolve);
@@ -2185,7 +2337,8 @@ async function main() {
               case '2': agent = 'cline'; break;
               case '3': agent = 'cursor'; break;
               case '4': agent = 'copilot'; break;
-              case '5':
+              case '5': agent = 'warp'; break;
+              case '6':
                 const customAgent = await new Promise(resolve => {
                   rl.question('Enter agent name: ', resolve);
                 });
@@ -2221,7 +2374,7 @@ async function main() {
       
       const agent = args.includes('--agent') ? 
         args[args.indexOf('--agent') + 1] : 
-        'claude';
+        undefined; // Pass undefined to trigger prompt in createSession
       
       await coordinator.createAndStart({ task, agent });
       break;
@@ -2301,8 +2454,10 @@ ${CONFIG.colors.yellow}Typical Workflow:${CONFIG.colors.reset}
   }
 }
 
-// Run the CLI
-main().catch(err => {
-  console.error(`${CONFIG.colors.red}Error: ${err.message}${CONFIG.colors.reset}`);
-  process.exit(1);
-});
+// Run the CLI only if executed directly
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main().catch(err => {
+    console.error(`${CONFIG.colors.red}Error: ${err.message}${CONFIG.colors.reset}`);
+    process.exit(1);
+  });
+}