elsabro 7.3.0 → 7.3.1

package/flow-engine/tests/skill-install.test.js

@@ -371,4 +371,258 @@ describe('skill-install.sh', () => {
       assert.ok(['ok', 'error'].includes(errResult.status));
     });
   });
+
+  // ---- Auto-install integration ----
+  describe('Auto-install integration', () => {
+    it('completes full workflow: check → install → validate', () => {
+      const mockDir = createMockNpx('exit 0');
+      const mockHome = createMockSkillsDir({
+        'integration-test.md': '---\nname: integration-test\n---\n# Test skill'
+      });
+      try {
+        // Step 1: Check registry availability
+        const checkResult = runInstall('check', {
+          env: { PATH: `${mockDir}:${process.env.PATH}` }
+        });
+        assert.equal(checkResult.status, 'ok', 'Registry check should succeed');
+
+        // Step 2: Install skill
+        const installResult = runInstall(
+          'install "npx -y skills add vercel-labs/agent-skills --skill integration-test -g -a claude-code"',
+          { env: { PATH: `${mockDir}:${process.env.PATH}`, HOME: mockHome } }
+        );
+        assert.equal(installResult.status, 'ok', 'Install should succeed');
+        assert.equal(installResult.skill, 'integration-test', 'Should extract correct skill name');
+
+        // Step 3: Validate installed skill
+        const validateResult = runInstall('validate "integration-test"', {
+          env: { HOME: mockHome }
+        });
+        assert.equal(validateResult.status, 'ok', 'Validation should succeed');
+        assert.equal(validateResult.has_frontmatter, true, 'Should detect frontmatter');
+      } finally {
+        cleanup(mockDir);
+        cleanup(mockHome);
+      }
+    });
+
+    it('handles install failure gracefully in workflow', () => {
+      const mockDir = createMockNpx('echo "Network error" >&2; exit 1');
+      const mockHome = createMockSkillsDir();
+      try {
+        // Step 1: Check succeeds (mock npx returns 0 for some calls)
+        const mockDirCheck = createMockNpx('exit 0');
+        const checkResult = runInstall('check', {
+          env: { PATH: `${mockDirCheck}:${process.env.PATH}` }
+        });
+        cleanup(mockDirCheck);
+        assert.equal(checkResult.status, 'ok');
+
+        // Step 2: Install fails
+        const installResult = runInstall(
+          'install "npx -y skills add vercel-labs/agent-skills --skill bad-network -g -a claude-code"',
+          { env: { PATH: `${mockDir}:${process.env.PATH}`, HOME: mockHome } }
+        );
+        assert.equal(installResult.status, 'error', 'Install should fail on network error');
+        assert.ok(installResult.message.includes('install failed'), 'Error message should indicate install failure');
+
+        // Step 3: Validation fails (skill not installed)
+        const validateResult = runInstall('validate "bad-network"', {
+          env: { HOME: mockHome }
+        });
+        assert.equal(validateResult.status, 'error', 'Validation should fail for non-existent skill');
+      } finally {
+        cleanup(mockDir);
+        cleanup(mockHome);
+      }
+    });
+
+    it('detects missing skill and triggers install suggestion', () => {
+      const mockHome = createMockSkillsDir({
+        'existing-skill.md': '---\nname: existing-skill\n---\n# Exists'
+      });
+      try {
+        // Try to validate a skill that doesn't exist
+        const validateResult = runInstall('validate "missing-skill"', {
+          env: { HOME: mockHome }
+        });
+        assert.equal(validateResult.status, 'error', 'Should error on missing skill');
+        assert.ok(validateResult.message.includes('not found'), 'Error should indicate skill not found');
+      } finally {
+        cleanup(mockHome);
+      }
+    });
+
+    it('verifies skill availability after successful install', () => {
+      const mockDir = createMockNpx('exit 0');
+      const mockHome = createMockSkillsDir();
+      try {
+        // Install skill
+        const installResult = runInstall(
+          'install "npx -y skills add vercel-labs/agent-skills --skill verify-test -g -a claude-code"',
+          { env: { PATH: `${mockDir}:${process.env.PATH}`, HOME: mockHome } }
+        );
+        assert.equal(installResult.status, 'ok');
+
+        // Create the skill file to simulate successful installation
+        const skillPath = path.join(mockHome, '.claude', 'skills', 'verify-test.md');
+        fs.writeFileSync(skillPath, '---\nname: verify-test\n---\n# Installed');
+
+        // Verify skill is now available
+        const validateResult = runInstall('validate "verify-test"', {
+          env: { HOME: mockHome }
+        });
+        assert.equal(validateResult.status, 'ok', 'Skill should be available after install');
+        assert.equal(validateResult.has_frontmatter, true);
+      } finally {
+        cleanup(mockDir);
+        cleanup(mockHome);
+      }
+    });
+
+    it('handles concurrent install attempts gracefully', () => {
+      const mockDir = createMockNpx('sleep 0.1; exit 0');
+      const mockHome = createMockSkillsDir();
+      try {
+        // Simulate checking multiple skills in sequence (not parallel, per spec)
+        const skills = ['skill-a', 'skill-b', 'skill-c'];
+        const results = skills.map(skill =>
+          runInstall(
+            `install "npx -y skills add vercel-labs/agent-skills --skill ${skill} -g -a claude-code"`,
+            { env: { PATH: `${mockDir}:${process.env.PATH}`, HOME: mockHome } }
+          )
+        );
+
+        // All should succeed
+        results.forEach((result, idx) => {
+          assert.equal(result.status, 'ok', `Install ${idx + 1} should succeed`);
+          assert.equal(result.skill, skills[idx], `Should extract correct skill name ${skills[idx]}`);
+        });
+      } finally {
+        cleanup(mockDir);
+        cleanup(mockHome);
+      }
+    });
+
+    it('recovers from partial install failure', () => {
+      const mockDir = createMockNpx('exit 0');
+      const mockHome = createMockSkillsDir();
+      try {
+        // First install succeeds
+        const install1 = runInstall(
+          'install "npx -y skills add vercel-labs/agent-skills --skill partial-1 -g -a claude-code"',
+          { env: { PATH: `${mockDir}:${process.env.PATH}`, HOME: mockHome } }
+        );
+        assert.equal(install1.status, 'ok');
+
+        // Second install with failing npx
+        const mockDirFail = createMockNpx('exit 1');
+        const install2 = runInstall(
+          'install "npx -y skills add vercel-labs/agent-skills --skill partial-2 -g -a claude-code"',
+          { env: { PATH: `${mockDirFail}:${process.env.PATH}`, HOME: mockHome } }
+        );
+        cleanup(mockDirFail);
+        assert.equal(install2.status, 'error', 'Second install should fail');
+
+        // Third install succeeds (recovery)
+        const install3 = runInstall(
+          'install "npx -y skills add vercel-labs/agent-skills --skill partial-3 -g -a claude-code"',
+          { env: { PATH: `${mockDir}:${process.env.PATH}`, HOME: mockHome } }
+        );
+        assert.equal(install3.status, 'ok', 'Should recover after failure');
+      } finally {
+        cleanup(mockDir);
+        cleanup(mockHome);
+      }
+    });
+
+    it('validates skill format after auto-install', () => {
+      const mockDir = createMockNpx('exit 0');
+      const mockHome = createMockSkillsDir();
+      try {
+        // Install skill
+        runInstall(
+          'install "npx -y skills add vercel-labs/agent-skills --skill format-test -g -a claude-code"',
+          { env: { PATH: `${mockDir}:${process.env.PATH}`, HOME: mockHome } }
+        );
+
+        // Create skill with invalid format (no frontmatter)
+        const skillPath = path.join(mockHome, '.claude', 'skills', 'format-test.md');
+        fs.writeFileSync(skillPath, '# No frontmatter\nJust content');
+
+        // Validate should still succeed but report no frontmatter
+        const validateResult = runInstall('validate "format-test"', {
+          env: { HOME: mockHome }
+        });
+        assert.equal(validateResult.status, 'ok', 'Should succeed even without frontmatter');
+        assert.equal(validateResult.has_frontmatter, false, 'Should detect missing frontmatter');
+      } finally {
+        cleanup(mockDir);
+        cleanup(mockHome);
+      }
+    });
+
+    it('handles registry unavailable during auto-install', () => {
+      const mockDir = createMockNpx('echo "Registry unavailable" >&2; exit 1');
+      try {
+        const checkResult = runInstall('check', {
+          env: { PATH: `${mockDir}:${process.env.PATH}` }
+        });
+        assert.equal(checkResult.status, 'error', 'Should fail when registry unavailable');
+        assert.ok(checkResult.message.includes('registry check failed'), 'Should indicate registry failure');
+      } finally {
+        cleanup(mockDir);
+      }
+    });
+
+    it('provides clear error for malformed install commands', () => {
+      const invalidCommands = [
+        '',  // Empty
+        'not-npx-command',  // Wrong prefix
+        'npx skills add',  // Missing --skill flag
+      ];
+
+      for (const cmd of invalidCommands) {
+        const result = runInstall(`install "${cmd}"`);
+        assert.equal(result.status, 'error', `Should error for invalid command: ${cmd}`);
+        assert.ok(result.message, 'Should provide error message');
+      }
+    });
+
+    it('maintains cache consistency across install workflow', () => {
+      const mockDir = createMockNpx('exit 0');
+      const mockHome = createMockSkillsDir();
+      const cacheDir = path.join(PROJECT_ROOT, '.cache');
+      const cacheFile = path.join(cacheDir, 'skill-discovery-cache.json');
+
+      // Save original cache state
+      const originalContent = fs.existsSync(cacheFile)
+        ? fs.readFileSync(cacheFile, 'utf8')
+        : null;
+
+      try {
+        // Create cache
+        if (!fs.existsSync(cacheDir)) fs.mkdirSync(cacheDir, { recursive: true });
+        fs.writeFileSync(cacheFile, '{"cached":"before-install"}');
+        assert.equal(fs.existsSync(cacheFile), true, 'Cache should exist before install');
+
+        // Install should invalidate cache
+        runInstall(
+          'install "npx -y skills add vercel-labs/agent-skills --skill cache-workflow -g -a claude-code"',
+          { env: { PATH: `${mockDir}:${process.env.PATH}`, HOME: mockHome } }
+        );
+
+        assert.equal(fs.existsSync(cacheFile), false, 'Cache should be invalidated after install');
+      } finally {
+        cleanup(mockDir);
+        cleanup(mockHome);
+        // Restore original cache state
+        if (originalContent !== null) {
+          fs.writeFileSync(cacheFile, originalContent);
+        } else if (fs.existsSync(cacheFile)) {
+          fs.unlinkSync(cacheFile);
+        }
+      }
+    });
+  });
 });

package/flow-engine/tests/validation.test.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { resolveExpression } = require('../src/template');
+
+describe('hasCriticalIssues validation', () => {
+  it('detects "critical" pattern', () => {
+    const ctx = {
+      review: {
+        issues: [{ severity: 'critical', msg: 'bug found' }]
+      }
+    };
+    const result = resolveExpression('hasCriticalIssues(review)', ctx);
+    assert.equal(result, true);
+  });
+
+  it('detects "blocking" pattern', () => {
+    const ctx = {
+      review: {
+        issues: [{ priority: 'blocking', msg: 'deployment blocked' }]
+      }
+    };
+    const result = resolveExpression('hasCriticalIssues(review)', ctx);
+    assert.equal(result, true);
+  });
+
+  it('detects "P0" pattern', () => {
+    const ctx = {
+      review: {
+        issues: [{ priority: 'P0', msg: 'critical bug' }]
+      }
+    };
+    const result = resolveExpression('hasCriticalIssues(review)', ctx);
+    assert.equal(result, true);
+  });
+
+  it('detects "MUST_FIX" pattern', () => {
+    const ctx = {
+      review: {
+        issues: [{ status: 'MUST_FIX', msg: 'security vulnerability' }]
+      }
+    };
+    const result = resolveExpression('hasCriticalIssues(review)', ctx);
+    assert.equal(result, true);
+  });
+
+  it('detects "URGENT" pattern', () => {
+    const ctx = {
+      review: {
+        issues: [{ severity: 'URGENT', msg: 'production down' }]
+      }
+    };
+    const result = resolveExpression('hasCriticalIssues(review)', ctx);
+    assert.equal(result, true);
+  });
+
+  it('returns false when no critical patterns found', () => {
+    const ctx = {
+      review: {
+        issues: [{ severity: 'low', msg: 'minor issue' }]
+      }
+    };
+    const result = resolveExpression('hasCriticalIssues(review)', ctx);
+    assert.equal(result, false);
+  });
+
+  it('returns false for empty object', () => {
+    const ctx = {
+      review: {}
+    };
+    const result = resolveExpression('hasCriticalIssues(review)', ctx);
+    assert.equal(result, false);
+  });
+
+  it('returns false for null/undefined', () => {
+    const ctx = {
+      review: null
+    };
+    const result = resolveExpression('hasCriticalIssues(review)', ctx);
+    assert.equal(result, false);
+  });
+
+  it('detects multiple critical patterns in same object', () => {
+    const ctx = {
+      review: {
+        issues: [
+          { severity: 'critical', msg: 'bug 1' },
+          { priority: 'P0', msg: 'bug 2' },
+          { status: 'MUST_FIX', msg: 'bug 3' }
+        ]
+      }
+    };
+    const result = resolveExpression('hasCriticalIssues(review)', ctx);
+    assert.equal(result, true);
+  });
+
+  it('works with deeply nested critical patterns', () => {
+    const ctx = {
+      review: {
+        results: {
+          branches: {
+            security: {
+              findings: [{ level: 'critical', detail: 'SQL injection' }]
+            }
+          }
+        }
+      }
+    };
+    const result = resolveExpression('hasCriticalIssues(review)', ctx);
+    assert.equal(result, true);
+  });
+
+  it('works with string input instead of object', () => {
+    const ctx = {
+      report: '{"status":"P0","message":"critical error"}'
+    };
+    const result = resolveExpression('hasCriticalIssues(report)', ctx);
+    assert.equal(result, true);
+  });
+
+  it('detects patterns in array of strings', () => {
+    const ctx = {
+      tags: ['urgent', 'needs-review', 'URGENT']
+    };
+    const result = resolveExpression('hasCriticalIssues(tags)', ctx);
+    assert.equal(result, true);
+  });
+
+  it('returns false for safe array of strings', () => {
+    const ctx = {
+      tags: ['low-priority', 'needs-review', 'documentation']
+    };
+    const result = resolveExpression('hasCriticalIssues(tags)', ctx);
+    assert.equal(result, false);
+  });
+});

package/flows/development-flow.json

@@ -12,7 +12,7 @@
   },
 
   "sync_metadata": {
-    "last_audit": "2026-02-08",
+    "last_audit": "2026-02-09",
     "audit_result": {
       "total_nodes": 44,
       "implemented": 42,
@@ -21,7 +21,7 @@
       "deprecated": 2,
       "implementation_rate": "95%"
     },
-    "note": "M5-P2: Added design_ui + interrupt_design_complete (2 new implemented nodes). 42 implemented, 2 deprecated (teams_spawn, interrupt_teams_failed). design_ui is optional side-branch, not on mandatory path."
+    "note": "M5-P3: Fixed teams profile to bypass deprecated nodes. interview_teams now routes to standard_analyze instead of teams_spawn. Agent Teams enforced inline via callbacks.js at parallel nodes. 2 deprecated nodes (teams_spawn, interrupt_teams_failed) kept for test coverage but unreachable in normal flow."
   },
 
   "inputs": {
@@ -243,7 +243,7 @@
         "task": "{{inputs.task}}",
         "topics": "prioridades del equipo y qué entregar primero, deadline y nivel de calidad esperado, áreas que necesitan más atención (frontend/backend/testing), integraciones críticas que no pueden fallar"
       },
-      "next": "teams_spawn"
+      "next": "standard_analyze"
     },
 
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elsabro",
-  "version": "7.3.0",
+  "version": "7.3.1",
   "description": "Sistema de desarrollo AI-powered para Claude Code - BMAD Method Integration, Spec-Driven Development, Party Mode, Next Step Suggestions, Stitch UI Design, Agent Teams, blocking code review, orquestación avanzada con flows declarativos",
   "bin": {
     "elsabro": "bin/install.js",