agentic-team-templates 0.17.0 → 0.19.0

package/src/index.test.js

@@ -7,6 +7,9 @@ import { run, _internals } from './index.js';
 const {
   PACKAGE_NAME,
   CURRENT_VERSION,
+  CURSOR_RULES_DIR,
+  LEGACY_CURSORRULES_DIR,
+  CATEGORIES,
   TEMPLATES,
   TEMPLATE_ALIASES,
   SHARED_RULES,
@@ -14,6 +17,7 @@ const {
   DEFAULT_IDES,
   compareVersions,
   resolveTemplateAlias,
+  getTemplateRulePath,
   filesMatch,
   parseMarkdownSections,
   generateSectionSignature,
@@ -106,12 +110,15 @@ describe('Constants', () => {
       expect(Object.keys(TEMPLATES).sort()).toEqual(expectedTemplates.sort());
     });
 
-    it('each template should have description and rules array', () => {
+    it('each template should have category, description, and rules array', () => {
       for (const [name, template] of Object.entries(TEMPLATES)) {
+        expect(template).toHaveProperty('category');
+        expect(CATEGORIES).toContain(template.category);
+
         expect(template).toHaveProperty('description');
         expect(typeof template.description).toBe('string');
         expect(template.description.length).toBeGreaterThan(0);
-        
+
         expect(template).toHaveProperty('rules');
         expect(Array.isArray(template.rules)).toBe(true);
         expect(template.rules.length).toBeGreaterThan(0);
@@ -123,6 +130,15 @@ describe('Constants', () => {
         expect(template.rules).toContain('overview.md');
       }
     });
+
+    it('each template rule file should exist on disk', () => {
+      for (const [name, template] of Object.entries(TEMPLATES)) {
+        for (const rule of template.rules) {
+          const rulePath = getTemplateRulePath(name, rule);
+          expect(fs.existsSync(rulePath), `Missing: ${rulePath}`).toBe(true);
+        }
+      }
+    });
   });
 
   describe('SHARED_RULES', () => {
@@ -715,104 +731,151 @@ describe('Install/Remove/Reset Operations', () => {
   });
 
   describe('install', () => {
-    it('should create .cursorrules directory', () => {
-      install(tempDir, ['web-frontend'], false, false, ['cursor']);
-      
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules'))).toBe(true);
+    it('should create .cursor/rules directory', async () => {
+      await install(tempDir, ['web-frontend'], false, false, ['cursor']);
+
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules'))).toBe(true);
     });
 
-    it('should install shared rules', () => {
-      install(tempDir, ['web-frontend'], false, false, ['cursor']);
-      
+    it('should install shared rules', async () => {
+      await install(tempDir, ['web-frontend'], false, false, ['cursor']);
+
       for (const rule of SHARED_RULES) {
-        expect(fs.existsSync(path.join(tempDir, '.cursorrules', rule))).toBe(true);
+        expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', rule))).toBe(true);
       }
     });
 
-    it('should install template-specific rules with prefix', () => {
-      install(tempDir, ['web-frontend'], false, false, ['cursor']);
-      
+    it('should install template-specific rules with prefix', async () => {
+      await install(tempDir, ['web-frontend'], false, false, ['cursor']);
+
       for (const rule of TEMPLATES['web-frontend'].rules) {
         const prefixedName = `web-frontend-${rule}`;
-        expect(fs.existsSync(path.join(tempDir, '.cursorrules', prefixedName))).toBe(true);
+        expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', prefixedName))).toBe(true);
       }
     });
 
-    it('should create CLAUDE.md for claude IDE', () => {
-      install(tempDir, ['web-frontend'], false, false, ['claude']);
-      
+    it('should create CLAUDE.md for claude IDE', async () => {
+      await install(tempDir, ['web-frontend'], false, false, ['claude']);
+
       expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
       const content = fs.readFileSync(path.join(tempDir, 'CLAUDE.md'), 'utf8');
       expect(content).toContain('# CLAUDE.md - Development Guide');
     });
 
-    it('should create copilot-instructions.md for codex IDE', () => {
-      install(tempDir, ['web-frontend'], false, false, ['codex']);
-      
+    it('should create copilot-instructions.md for codex IDE', async () => {
+      await install(tempDir, ['web-frontend'], false, false, ['codex']);
+
       expect(fs.existsSync(path.join(tempDir, '.github', 'copilot-instructions.md'))).toBe(true);
     });
 
-    it('should install for all IDEs by default', () => {
-      install(tempDir, ['web-frontend'], false, false, DEFAULT_IDES);
-      
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules'))).toBe(true);
+    it('should install for all IDEs by default', async () => {
+      await install(tempDir, ['web-frontend'], false, false, DEFAULT_IDES);
+
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules'))).toBe(true);
       expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
       expect(fs.existsSync(path.join(tempDir, '.github', 'copilot-instructions.md'))).toBe(true);
     });
 
-    it('should not write files in dry-run mode', () => {
-      install(tempDir, ['web-frontend'], true, false, ['cursor']);
-      
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules'))).toBe(false);
+    it('should not write files in dry-run mode', async () => {
+      await install(tempDir, ['web-frontend'], true, false, ['cursor']);
+
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules'))).toBe(false);
     });
 
-    it('should install multiple templates', () => {
-      install(tempDir, ['web-frontend', 'web-backend'], false, false, ['cursor']);
-      
+    it('should install multiple templates', async () => {
+      await install(tempDir, ['web-frontend', 'web-backend'], false, false, ['cursor']);
+
       // Check web-frontend rules
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules', 'web-frontend-overview.md'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', 'web-frontend-overview.md'))).toBe(true);
       // Check web-backend rules
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules', 'web-backend-overview.md'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', 'web-backend-overview.md'))).toBe(true);
+    });
+
+    it('should copy legacy .cursorrules/ files to .cursor/rules/ then remove legacy dir when cleanup confirmed', async () => {
+      const legacyDir = path.join(tempDir, LEGACY_CURSORRULES_DIR);
+      const cursorRulesDir = path.join(tempDir, '.cursor', 'rules');
+      fs.mkdirSync(legacyDir, { recursive: true });
+      fs.writeFileSync(path.join(legacyDir, 'old-rule.md'), '# Old rule');
+      fs.writeFileSync(path.join(legacyDir, 'custom-guide.md'), '# Custom guide');
+
+      await install(tempDir, ['web-frontend'], false, false, ['cursor'], true);
+
+      expect(fs.existsSync(legacyDir)).toBe(false);
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', 'web-frontend-overview.md'))).toBe(true);
+      expect(fs.existsSync(path.join(cursorRulesDir, 'old-rule.md'))).toBe(true);
+      expect(fs.readFileSync(path.join(cursorRulesDir, 'old-rule.md'), 'utf8')).toBe('# Old rule');
+      expect(fs.existsSync(path.join(cursorRulesDir, 'custom-guide.md'))).toBe(true);
+      expect(fs.readFileSync(path.join(cursorRulesDir, 'custom-guide.md'), 'utf8')).toBe('# Custom guide');
+    });
+
+    it('should not overwrite existing .cursor/rules/ files when migrating legacy', async () => {
+      const legacyDir = path.join(tempDir, LEGACY_CURSORRULES_DIR);
+      const cursorRulesDir = path.join(tempDir, '.cursor', 'rules');
+      fs.mkdirSync(cursorRulesDir, { recursive: true });
+      fs.writeFileSync(path.join(cursorRulesDir, 'my-rule.md'), '# New structure content');
+      fs.mkdirSync(legacyDir, { recursive: true });
+      fs.writeFileSync(path.join(legacyDir, 'my-rule.md'), '# Legacy content');
+
+      await install(tempDir, ['web-frontend'], false, false, ['cursor'], true);
+
+      expect(fs.readFileSync(path.join(cursorRulesDir, 'my-rule.md'), 'utf8')).toBe('# New structure content');
+      expect(fs.existsSync(legacyDir)).toBe(false);
+    });
+
+    it('should show legacy warning in dry-run mode without prompting', async () => {
+      // Create a legacy .cursorrules/ directory
+      const legacyDir = path.join(tempDir, LEGACY_CURSORRULES_DIR);
+      fs.mkdirSync(legacyDir, { recursive: true });
+      fs.writeFileSync(path.join(legacyDir, 'old-rule.md'), '# Old rule');
+
+      await install(tempDir, ['web-frontend'], true, false, ['cursor']);
+
+      // Legacy dir should still exist (dry-run doesn't modify)
+      expect(fs.existsSync(legacyDir)).toBe(true);
+      // Warning should have been printed
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Deprecated')
+      );
     });
   });
 
   describe('remove', () => {
-    beforeEach(() => {
+    beforeEach(async () => {
       // First install a template
-      install(tempDir, ['web-frontend'], false, false, ['cursor']);
+      await install(tempDir, ['web-frontend'], false, false, ['cursor']);
     });
 
     it('should remove template-specific files', async () => {
       await remove(tempDir, ['web-frontend'], false, false, true, ['cursor']);
-      
+
       for (const rule of TEMPLATES['web-frontend'].rules) {
         const prefixedName = `web-frontend-${rule}`;
-        expect(fs.existsSync(path.join(tempDir, '.cursorrules', prefixedName))).toBe(false);
+        expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', prefixedName))).toBe(false);
       }
     });
 
     it('should keep shared rules when removing template', async () => {
       await remove(tempDir, ['web-frontend'], false, false, true, ['cursor']);
-      
+
       for (const rule of SHARED_RULES) {
-        expect(fs.existsSync(path.join(tempDir, '.cursorrules', rule))).toBe(true);
+        expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', rule))).toBe(true);
       }
     });
 
     it('should not remove files in dry-run mode', async () => {
       await remove(tempDir, ['web-frontend'], true, false, true, ['cursor']);
-      
+
       // Files should still exist
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules', 'web-frontend-overview.md'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', 'web-frontend-overview.md'))).toBe(true);
     });
 
     it('should skip modified files without force', async () => {
       // Modify a file
-      const filePath = path.join(tempDir, '.cursorrules', 'web-frontend-overview.md');
+      const filePath = path.join(tempDir, '.cursor', 'rules', 'web-frontend-overview.md');
       fs.writeFileSync(filePath, '# Modified content');
-      
+
       await remove(tempDir, ['web-frontend'], false, false, true, ['cursor']);
-      
+
       // Modified file should still exist
       expect(fs.existsSync(filePath)).toBe(true);
       expect(fs.readFileSync(filePath, 'utf8')).toBe('# Modified content');
@@ -820,73 +883,107 @@ describe('Install/Remove/Reset Operations', () => {
 
     it('should remove modified files with force', async () => {
       // Modify a file
-      const filePath = path.join(tempDir, '.cursorrules', 'web-frontend-overview.md');
+      const filePath = path.join(tempDir, '.cursor', 'rules', 'web-frontend-overview.md');
       fs.writeFileSync(filePath, '# Modified content');
-      
+
       await remove(tempDir, ['web-frontend'], false, true, true, ['cursor']);
-      
+
       // Modified file should be removed
       expect(fs.existsSync(filePath)).toBe(false);
     });
+
+    it('should also remove files from legacy .cursorrules/ directory', async () => {
+      // Manually create files in legacy location
+      const legacyDir = path.join(tempDir, LEGACY_CURSORRULES_DIR);
+      fs.mkdirSync(legacyDir, { recursive: true });
+      for (const rule of TEMPLATES['web-frontend'].rules) {
+        fs.writeFileSync(path.join(legacyDir, `web-frontend-${rule}`), '# legacy content');
+      }
+
+      await remove(tempDir, ['web-frontend'], false, true, true, ['cursor']);
+
+      // Both new and legacy files should be removed
+      for (const rule of TEMPLATES['web-frontend'].rules) {
+        const prefixedName = `web-frontend-${rule}`;
+        expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', prefixedName))).toBe(false);
+        expect(fs.existsSync(path.join(legacyDir, prefixedName))).toBe(false);
+      }
+    });
   });
 
   describe('reset', () => {
-    beforeEach(() => {
+    beforeEach(async () => {
       // Install templates
-      install(tempDir, ['web-frontend', 'web-backend'], false, false, DEFAULT_IDES);
+      await install(tempDir, ['web-frontend', 'web-backend'], false, false, DEFAULT_IDES);
     });
 
-    it('should remove all template files from .cursorrules', async () => {
+    it('should remove all template files from .cursor/rules', async () => {
       await reset(tempDir, false, false, true, ['cursor']);
-      
+
       // Template files should be removed
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules', 'web-frontend-overview.md'))).toBe(false);
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules', 'web-backend-overview.md'))).toBe(false);
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', 'web-frontend-overview.md'))).toBe(false);
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', 'web-backend-overview.md'))).toBe(false);
     });
 
     it('should remove shared rules', async () => {
       await reset(tempDir, false, false, true, ['cursor']);
-      
+
       for (const rule of SHARED_RULES) {
-        expect(fs.existsSync(path.join(tempDir, '.cursorrules', rule))).toBe(false);
+        expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', rule))).toBe(false);
       }
     });
 
     it('should remove CLAUDE.md', async () => {
       await reset(tempDir, false, false, true, ['claude']);
-      
+
       expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(false);
     });
 
     it('should remove copilot-instructions.md', async () => {
       await reset(tempDir, false, false, true, ['codex']);
-      
+
       expect(fs.existsSync(path.join(tempDir, '.github', 'copilot-instructions.md'))).toBe(false);
     });
 
     it('should not remove files in dry-run mode', async () => {
       await reset(tempDir, true, false, true, DEFAULT_IDES);
-      
+
       // All files should still exist
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules'))).toBe(true);
       expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
     });
 
-    it('should remove empty .cursorrules directory', async () => {
+    it('should remove empty .cursor/rules directory', async () => {
       await reset(tempDir, false, false, true, ['cursor']);
-      
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules'))).toBe(false);
+
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules'))).toBe(false);
     });
 
-    it('should keep .cursorrules if non-template files remain', async () => {
+    it('should keep .cursor/rules if non-template files remain', async () => {
       // Add a custom file
-      fs.writeFileSync(path.join(tempDir, '.cursorrules', 'my-custom-rules.md'), '# Custom');
-      
+      fs.writeFileSync(path.join(tempDir, '.cursor', 'rules', 'my-custom-rules.md'), '# Custom');
+
       await reset(tempDir, false, false, true, ['cursor']);
-      
+
       // Directory should still exist with custom file
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules'))).toBe(true);
-      expect(fs.existsSync(path.join(tempDir, '.cursorrules', 'my-custom-rules.md'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', 'my-custom-rules.md'))).toBe(true);
+    });
+
+    it('should also clean up legacy .cursorrules/ directory', async () => {
+      // Manually create legacy directory with template files
+      const legacyDir = path.join(tempDir, LEGACY_CURSORRULES_DIR);
+      fs.mkdirSync(legacyDir, { recursive: true });
+      for (const rule of SHARED_RULES) {
+        fs.writeFileSync(path.join(legacyDir, rule), '# legacy shared');
+      }
+      fs.writeFileSync(path.join(legacyDir, 'web-frontend-overview.md'), '# legacy template');
+
+      await reset(tempDir, false, true, true, ['cursor']);
+
+      // Both directories should be cleaned up
+      expect(fs.existsSync(path.join(tempDir, '.cursor', 'rules', 'web-frontend-overview.md'))).toBe(false);
+      expect(fs.existsSync(path.join(legacyDir, 'web-frontend-overview.md'))).toBe(false);
     });
   });
 });