@howlil/ez-agents 3.4.2 → 4.0.0

package/ez-agents/tests/guards/context-budget-guard.test.cjs

@@ -0,0 +1,145 @@
+/**
+ * Context Budget Guard Tests
+ */
+
+const { describe, it } = require('vitest');
+const { strict: assert } = require('assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Import the guard
+const { 
+  getTokenUsage,
+  checkContextBudget,
+  shouldStop,
+  getRecommendedAction,
+  checkBudget,
+  THRESHOLDS
+} = require('../../ez-agents/bin/guards/context-budget-guard.cjs');
+
+describe('Context Budget Guard', () => {
+  describe('checkContextBudget', () => {
+    it('should return no warnings for low usage', () => {
+      const result = checkContextBudget(10000, 100000);
+      assert.strictEqual(result.percent, 10);
+      assert.strictEqual(result.warnings.length, 0);
+      assert.strictEqual(result.shouldStop, false);
+    });
+    
+    it('should return info warning at 50%', () => {
+      const result = checkContextBudget(50000, 100000);
+      assert.strictEqual(result.percent, 50);
+      assert.strictEqual(result.warnings.length, 1);
+      assert.strictEqual(result.warnings[0].level, 'info');
+      assert.strictEqual(result.shouldStop, false);
+    });
+    
+    it('should return warning at 70%', () => {
+      const result = checkContextBudget(70000, 100000);
+      assert.strictEqual(result.percent, 70);
+      assert.strictEqual(result.warnings.length, 2);
+      assert.strictEqual(result.warnings[1].level, 'warning');
+      assert.strictEqual(result.shouldStop, false);
+    });
+    
+    it('should return error and shouldStop at 80%', () => {
+      const result = checkContextBudget(80000, 100000);
+      assert.strictEqual(result.percent, 80);
+      assert.strictEqual(result.warnings.length, 3);
+      assert.strictEqual(result.warnings[2].level, 'error');
+      assert.strictEqual(result.shouldStop, true);
+    });
+    
+    it('should return all warnings at 95%', () => {
+      const result = checkContextBudget(95000, 100000);
+      assert.strictEqual(result.percent, 95);
+      assert.strictEqual(result.warnings.length, 3);
+      assert.strictEqual(result.shouldStop, true);
+      assert.strictEqual(result.remaining, 5000);
+    });
+  });
+  
+  describe('shouldStop', () => {
+    it('should return false below 80%', () => {
+      assert.strictEqual(shouldStop(79000, 100000), false);
+      assert.strictEqual(shouldStop(50000, 100000), false);
+    });
+    
+    it('should return true at 80% and above', () => {
+      assert.strictEqual(shouldStop(80000, 100000), true);
+      assert.strictEqual(shouldStop(90000, 100000), true);
+    });
+  });
+  
+  describe('getRecommendedAction', () => {
+    it('should return OK for low usage', () => {
+      const action = getRecommendedAction(30000, 100000);
+      assert.ok(action.includes('healthy'));
+    });
+    
+    it('should return INFO for 50-69%', () => {
+      const action = getRecommendedAction(60000, 100000);
+      assert.ok(action.includes('INFO'));
+      assert.ok(action.includes('Monitor'));
+    });
+    
+    it('should return WARNING for 70-79%', () => {
+      const action = getRecommendedAction(75000, 100000);
+      assert.ok(action.includes('WARNING'));
+      assert.ok(action.includes('split'));
+    });
+    
+    it('should return STOP for 80%+', () => {
+      const action = getRecommendedAction(85000, 100000);
+      assert.ok(action.includes('STOP'));
+      assert.ok(action.includes('Split'));
+    });
+  });
+  
+  describe('getTokenUsage', () => {
+    it('should return default when no context file', () => {
+      const result = getTokenUsage(null);
+      assert.strictEqual(result.current, 0);
+      assert.strictEqual(result.max, 100000);
+      assert.strictEqual(result.model, 'default');
+    });
+    
+    it('should return default when file does not exist', () => {
+      const result = getTokenUsage('/nonexistent/file.md');
+      assert.strictEqual(result.current, 0);
+      assert.strictEqual(result.max, 100000);
+    });
+    
+    it('should parse token usage from context file', () => {
+      const tempFile = path.join(os.tmpdir(), `context-${Date.now()}.md`);
+      const content = `
+# Context
+tokens_used: 50000
+token_limit: 100000
+model: claude-3-sonnet
+`;
+      fs.writeFileSync(tempFile, content);
+      
+      try {
+        const result = getTokenUsage(tempFile);
+        assert.strictEqual(result.current, 50000);
+        assert.strictEqual(result.max, 100000);
+        assert.strictEqual(result.model, 'claude-3-sonnet');
+      } finally {
+        fs.unlinkSync(tempFile);
+      }
+    });
+  });
+  
+  describe('checkBudget', () => {
+    it('should return complete budget status', () => {
+      const result = checkBudget(null, 'gpt-4');
+      assert.ok(result.model);
+      assert.ok(result.limit);
+      assert.ok('percent' in result);
+      assert.ok('warnings' in result);
+      assert.ok('action' in result);
+    });
+  });
+});

package/ez-agents/tests/guards/edge-case-guards.test.cjs

@@ -0,0 +1,238 @@
+/**
+ * Remaining Edge Case Guards Tests
+ * Tests for EDGE-03, EDGE-04, EDGE-05, EDGE-06
+ */
+
+import { describe, it } from 'vitest';
+import { strict as assert } from 'assert';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Import the guards
+import {
+  checkHiddenState,
+  listStateFiles,
+  validatePersistence
+} from '../../../bin/guards/hidden-state-guard.cjs';
+
+import {
+  checkIrreversibleOps,
+  requiresHumanApproval,
+  checkAutonomy
+} from '../../../bin/guards/autonomy-guard.cjs';
+
+import {
+  checkToolCount,
+  getActiveTools,
+  checkToolSprawl
+} from '../../../bin/guards/tool-sprawl-guard.cjs';
+
+import {
+  detectOrgChanges,
+  checkTeamOverhead,
+  flagTeamRestructure
+} from '../../../bin/guards/team-overhead-guard.cjs';
+
+describe('EDGE-03: Hidden State Guard', () => {
+  describe('listStateFiles', () => {
+    it('should return empty array when no .planning directory', () => {
+      const result = listStateFiles(os.tmpdir());
+      assert.ok(Array.isArray(result));
+    });
+    
+    it('should find markdown files in .planning directory', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'state-test-'));
+      const planningDir = path.join(tempDir, '.planning');
+      fs.mkdirSync(planningDir);
+      fs.writeFileSync(path.join(planningDir, 'test.md'), '# Test');
+      fs.writeFileSync(path.join(planningDir, 'other.txt'), 'not markdown');
+      
+      try {
+        const result = listStateFiles(tempDir);
+        assert.strictEqual(result.length, 1);
+        assert.ok(result[0].endsWith('test.md'));
+      } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+  });
+  
+  describe('checkHiddenState', () => {
+    it('should return no hidden state for empty output', () => {
+      const result = checkHiddenState('', os.tmpdir());
+      assert.strictEqual(result.hasHiddenState, false);
+    });
+    
+    it('should detect state references in output', () => {
+      const output = 'Phase 1 is complete. Task 5-02 is done. Status: BLOCKED';
+      const result = checkHiddenState(output, os.tmpdir());
+      assert.ok(result.stateReferences.length > 0);
+    });
+  });
+  
+  describe('validatePersistence', () => {
+    it('should validate persistence correctly', () => {
+      const output = 'All state is documented';
+      const result = validatePersistence(output, os.tmpdir());
+      assert.ok('valid' in result);
+      assert.ok('stateFiles' in result);
+    });
+  });
+});
+
+describe('EDGE-04: Autonomy Guard', () => {
+  describe('checkIrreversibleOps', () => {
+    it('should detect database drop as irreversible', () => {
+      const result = checkIrreversibleOps('Drop the database and recreate it');
+      assert.strictEqual(result.irreversible, true);
+      assert.strictEqual(result.requiresApproval, true);
+    });
+    
+    it('should detect production deploy as irreversible', () => {
+      const result = checkIrreversibleOps('Deploy to production server');
+      assert.strictEqual(result.irreversible, true);
+      assert.strictEqual(result.requiresApproval, true);
+    });
+    
+    it('should allow safe operations', () => {
+      const result = checkIrreversibleOps('Read the configuration file');
+      assert.strictEqual(result.irreversible, false);
+      assert.strictEqual(result.requiresApproval, false);
+    });
+    
+    it('should classify delete operations as irreversible', () => {
+      const result = checkIrreversibleOps('Delete all records from users table');
+      assert.strictEqual(result.irreversible, true);
+    });
+  });
+  
+  describe('requiresHumanApproval', () => {
+    it('should require approval for irreversible ops', () => {
+      assert.strictEqual(requiresHumanApproval('DROP DATABASE'), true);
+      assert.strictEqual(requiresHumanApproval('truncate table'), true);
+    });
+    
+    it('should not require approval for safe ops', () => {
+      assert.strictEqual(requiresHumanApproval('SELECT * FROM users'), false);
+      assert.strictEqual(requiresHumanApproval('read file'), false);
+    });
+  });
+  
+  describe('checkAutonomy', () => {
+    it('should flag irreversible operations in output', () => {
+      const output = 'Step 1: Drop the database. Step 2: Recreate schema.';
+      const result = checkAutonomy(output, os.tmpdir());
+      assert.strictEqual(result.requiresApproval, true);
+      assert.ok(result.flaggedOperations.length > 0);
+    });
+  });
+});
+
+describe('EDGE-05: Tool Sprawl Guard', () => {
+  describe('getActiveTools', () => {
+    it('should extract tools from context', () => {
+      const context = 'Using express for server and react for UI';
+      const tools = getActiveTools(context);
+      assert.ok(tools.includes('express'));
+      assert.ok(tools.includes('react'));
+    });
+    
+    it('should extract npm packages', () => {
+      const context = 'Install @scope/package and another-lib';
+      const tools = getActiveTools(context);
+      assert.ok(tools.some(t => t.includes('@scope/package') || t === 'another-lib'));
+    });
+  });
+  
+  describe('checkToolCount', () => {
+    it('should return optimal for 3-7 tools', () => {
+      const tools = ['tool1', 'tool2', 'tool3', 'tool4', 'tool5'];
+      const result = checkToolCount(tools);
+      assert.strictEqual(result.status, 'optimal');
+      assert.strictEqual(result.withinLimit, true);
+    });
+    
+    it('should return exceeded for >7 tools', () => {
+      const tools = ['t1', 't2', 't3', 't4', 't5', 't6', 't7', 't8', 't9', 't10'];
+      const result = checkToolCount(tools);
+      assert.strictEqual(result.status, 'exceeded');
+      assert.strictEqual(result.withinLimit, false);
+      assert.strictEqual(result.exceeded, 3);
+    });
+    
+    it('should return below-recommended for <3 tools', () => {
+      const tools = ['tool1'];
+      const result = checkToolCount(tools);
+      assert.strictEqual(result.status, 'below-recommended');
+    });
+  });
+  
+  describe('checkToolSprawl', () => {
+    it('should analyze tool usage', () => {
+      const context = 'Using vitest, playwright, and typescript for this task';
+      const result = checkToolSprawl(context);
+      assert.ok('count' in result);
+      assert.ok('tools' in result);
+      assert.ok('summary' in result);
+    });
+  });
+});
+
+describe('EDGE-06: Team Overhead Guard', () => {
+  describe('detectOrgChanges', () => {
+    it('should detect team structure suggestions', () => {
+      const output = 'You should reorganize team into squads';
+      const result = detectOrgChanges(output);
+      assert.strictEqual(result.hasOrgChanges, true);
+      assert.ok(result.suggestions.length > 0);
+    });
+    
+    it('should detect meeting suggestions', () => {
+      const output = 'Add a daily standup meeting';
+      const result = detectOrgChanges(output);
+      assert.strictEqual(result.hasOrgChanges, true);
+    });
+    
+    it('should detect role suggestions', () => {
+      const output = 'Create a new tech lead role';
+      const result = detectOrgChanges(output);
+      assert.strictEqual(result.hasOrgChanges, true);
+    });
+    
+    it('should not flag technical suggestions', () => {
+      const output = 'Add tests for the new feature';
+      const result = detectOrgChanges(output);
+      assert.strictEqual(result.hasOrgChanges, false);
+    });
+  });
+  
+  describe('flagTeamRestructure', () => {
+    it('should flag restructuring suggestions', () => {
+      const suggestion = 'Reorganize the team structure';
+      const result = flagTeamRestructure(suggestion);
+      assert.strictEqual(result.flagged, true);
+    });
+    
+    it('should assign severity based on keyword count', () => {
+      const suggestion = 'Reorganize team structure and create new roles and add meetings';
+      const result = flagTeamRestructure(suggestion);
+      assert.strictEqual(result.severity, 'high');
+    });
+  });
+  
+  describe('checkTeamOverhead', () => {
+    it('should provide complete analysis', () => {
+      const output = 'You should hire a new engineer and add sprint planning';
+      const result = checkTeamOverhead(output);
+      assert.strictEqual(result.hasOrgChanges, true);
+      assert.ok('summary' in result);
+      assert.ok('actionable' in result);
+    });
+  });
+});

package/ez-agents/tests/guards/hallucination-guard.test.cjs

@@ -0,0 +1,124 @@
+/**
+ * Hallucination Guard Tests
+ */
+
+const { describe, it } = require('vitest');
+const { strict: assert } = require('assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Import the guard
+const { 
+  checkCitation, 
+  verifyClaim, 
+  flagUncertainty,
+  checkHallucination 
+} = require('../../ez-agents/bin/guards/hallucination-guard.cjs');
+
+describe('Hallucination Guard', () => {
+  describe('checkCitation', () => {
+    it('should return no citation for non-existent claims', () => {
+      const result = checkCitation('nonexistent_claim_xyz123', os.tmpdir());
+      assert.strictEqual(result.cited, false);
+      assert.strictEqual(result.uncertainty, true);
+      assert.strictEqual(result.citations.length, 0);
+    });
+    
+    it('should find citation for existing content', () => {
+      // Create a temp file with known content
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'citation-test-'));
+      const testFile = path.join(tempDir, 'test.txt');
+      fs.writeFileSync(testFile, 'This is a test claim that should be found');
+      
+      try {
+        const result = checkCitation('test claim', tempDir);
+        assert.strictEqual(result.cited, true);
+        assert.strictEqual(result.uncertainty, false);
+        assert.ok(result.citations.length > 0);
+      } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+  });
+  
+  describe('verifyClaim', () => {
+    it('should verify library in package.json', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'verify-test-'));
+      const pkgPath = path.join(tempDir, 'package.json');
+      fs.writeFileSync(pkgPath, JSON.stringify({
+        dependencies: {
+          'express': '^4.18.0',
+          'vitest': '^1.0.0'
+        }
+      }));
+      
+      try {
+        const result = verifyClaim('library: express', tempDir);
+        assert.strictEqual(result.verified, true);
+        assert.strictEqual(result.source, 'package.json');
+        assert.strictEqual(result.details.name, 'express');
+      } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+    
+    it('should verify known libraries', () => {
+      const result = verifyClaim('using vitest for testing');
+      assert.strictEqual(result.verified, true);
+      assert.strictEqual(result.source, 'known-library');
+    });
+    
+    it('should not verify unknown libraries', () => {
+      const result = verifyClaim('using unknown-library-xyz123');
+      assert.strictEqual(result.verified, false);
+      assert.strictEqual(result.source, 'none');
+    });
+  });
+  
+  describe('flagUncertainty', () => {
+    it('should flag uncertain language', () => {
+      const result = flagUncertainty('This might work, but I am not sure');
+      assert.strictEqual(result.flagged, true);
+      assert.ok(result.uncertainPhrases.includes('might'));
+      assert.ok(result.uncertainPhrases.includes('not sure'));
+      assert.strictEqual(result.confidence, 'low');
+    });
+    
+    it('should not flag confident language', () => {
+      const result = flagUncertainty('This is the correct approach');
+      assert.strictEqual(result.flagged, false);
+      assert.strictEqual(result.uncertainPhrases.length, 0);
+      assert.strictEqual(result.confidence, 'high');
+    });
+    
+    it('should detect citation claims', () => {
+      const result = flagUncertainty('According to the documentation, this works');
+      assert.strictEqual(result.flagged, true);
+      assert.ok(result.uncertainPhrases.some(p => p.includes('citation claim')));
+    });
+  });
+  
+  describe('checkHallucination', () => {
+    it('should detect unverified library claims', () => {
+      const output = 'You should use the library unknown-lib-xyz for this';
+      const result = checkHallucination(output);
+      assert.strictEqual(result.hallucinationRisk, true);
+      assert.ok(result.unverifiedClaims.length > 0);
+    });
+    
+    it('should verify known library claims', () => {
+      const output = 'You should use express for the server';
+      const result = checkHallucination(output);
+      assert.strictEqual(result.hallucinationRisk, false);
+      assert.ok(result.verifiedClaims.length > 0);
+    });
+    
+    it('should flag uncertainty in output', () => {
+      const output = 'This might work, I think it should be correct';
+      const result = checkHallucination(output);
+      assert.strictEqual(result.uncertainty.flagged, true);
+      assert.strictEqual(result.confidence, 'medium');
+    });
+  });
+});

package/ez-agents/workflows/audit-milestone.md

@@ -74,7 +74,7 @@ Milestone Requirements:
 MUST map each integration finding to affected requirement IDs where applicable.
 
 Verify cross-phase wiring and E2E user flows.",
-  subagent_type="ez-integration-checker",
+  subagent_type="ez-verifier",
   model="{integration_checker_model}"
 )
 ```