agentic-team-templates 0.17.0 → 0.19.0

package/src/index.js

@@ -10,6 +10,10 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
 
+// Cursor rules directory paths
+const CURSOR_RULES_DIR = '.cursor/rules';          // New path (Cursor IDE)
+const LEGACY_CURSORRULES_DIR = '.cursorrules';      // Deprecated path
+
 // Read package.json for version info
 const packageJsonPath = path.join(__dirname, '..', 'package.json');
 const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
@@ -18,109 +22,146 @@ const CURRENT_VERSION = packageJson.version;
 const REPO_URL = 'https://github.com/djm204/agentic-team-templates';
 const CHANGELOG_URL = `${REPO_URL}/releases/tag/${PACKAGE_NAME}-v${CURRENT_VERSION}`;
 
+// Template categories (storage-only, not exposed to CLI users)
+const CATEGORIES = [
+  'engineering',
+  'languages',
+  'creative',
+  'business',
+  'professional',
+  'education',
+  'agents',
+];
+
 // Available templates
 const TEMPLATES = {
   'blockchain': {
+    category: 'engineering',
     description: 'Smart contracts, DeFi protocols, and Web3 applications (Solidity, Foundry, Viem)',
     rules: ['defi-patterns.md', 'gas-optimization.md', 'overview.md', 'security.md', 'smart-contracts.md', 'testing.md', 'web3-integration.md']
   },
   'cpp-expert': {
+    category: 'languages',
     description: 'Principal-level C++ engineering (modern C++, RAII, concurrency, templates, performance)',
     rules: ['concurrency.md', 'error-handling.md', 'memory-and-ownership.md', 'modern-cpp.md', 'overview.md', 'performance.md', 'testing.md', 'tooling.md']
   },
   'csharp-expert': {
+    category: 'languages',
     description: 'Principal-level C# engineering (async, DI, EF Core, ASP.NET Core, testing)',
     rules: ['aspnet-core.md', 'async-patterns.md', 'dependency-injection.md', 'error-handling.md', 'language-features.md', 'overview.md', 'performance.md', 'testing.md', 'tooling.md']
   },
   'cli-tools': {
+    category: 'engineering',
     description: 'Command-line applications and developer tools (Cobra, Commander, Click)',
     rules: ['architecture.md', 'arguments.md', 'distribution.md', 'error-handling.md', 'overview.md', 'testing.md', 'user-experience.md']
   },
   'data-engineering': {
+    category: 'engineering',
     description: 'Data platforms and pipelines (ETL, data modeling, data quality)',
     rules: ['data-modeling.md', 'data-quality.md', 'overview.md', 'performance.md', 'pipeline-design.md', 'security.md', 'testing.md']
   },
   'devops-sre': {
+    category: 'engineering',
     description: 'DevOps and SRE practices (incident management, observability, SLOs, chaos engineering)',
     rules: ['capacity-planning.md', 'change-management.md', 'chaos-engineering.md', 'disaster-recovery.md', 'incident-management.md', 'observability.md', 'overview.md', 'postmortems.md', 'runbooks.md', 'slo-sli.md', 'toil-reduction.md']
   },
   'documentation': {
+    category: 'professional',
     description: 'Technical documentation standards (READMEs, API docs, ADRs, code comments)',
     rules: ['adr.md', 'api-documentation.md', 'code-comments.md', 'maintenance.md', 'overview.md', 'readme-standards.md']
   },
   'educator': {
+    category: 'education',
     description: 'World-class pedagogy with evidence-based teaching, learning retention, gamification, and assessment design',
     rules: ['accessibility.md', 'assessment.md', 'curriculum.md', 'engagement.md', 'instructional-design.md', 'overview.md', 'retention.md']
   },
   'fullstack': {
+    category: 'engineering',
     description: 'Full-stack web applications (Next.js, Nuxt, SvelteKit, Remix)',
     rules: ['api-contracts.md', 'architecture.md', 'overview.md', 'shared-types.md', 'testing.md']
   },
   'golang-expert': {
+    category: 'languages',
     description: 'Principal-level Go engineering (concurrency, stdlib, production patterns, testing)',
     rules: ['concurrency.md', 'error-handling.md', 'interfaces-and-types.md', 'overview.md', 'performance.md', 'production-patterns.md', 'stdlib-and-tooling.md', 'testing.md']
   },
   'java-expert': {
+    category: 'languages',
     description: 'Principal-level Java engineering (JVM, Spring Boot, concurrency, JPA, testing)',
     rules: ['concurrency.md', 'error-handling.md', 'modern-java.md', 'overview.md', 'performance.md', 'persistence.md', 'spring-boot.md', 'testing.md', 'tooling.md']
   },
   'javascript-expert': {
+    category: 'languages',
     description: 'Principal-level JavaScript & TypeScript engineering (Node.js, React, type system, testing)',
     rules: ['language-deep-dive.md', 'node-patterns.md', 'overview.md', 'performance.md', 'react-patterns.md', 'testing.md', 'tooling.md', 'typescript-deep-dive.md']
   },
   'kotlin-expert': {
+    category: 'languages',
     description: 'Principal-level Kotlin engineering (coroutines, multiplatform, Ktor, Spring Boot, testing)',
     rules: ['coroutines.md', 'error-handling.md', 'frameworks.md', 'language-features.md', 'overview.md', 'performance.md', 'testing.md', 'tooling.md']
   },
   'ml-ai': {
+    category: 'engineering',
     description: 'Machine learning and AI systems (model development, deployment, monitoring)',
     rules: ['data-engineering.md', 'deployment.md', 'model-development.md', 'monitoring.md', 'overview.md', 'security.md', 'testing.md']
   },
   'mobile': {
+    category: 'engineering',
     description: 'Mobile applications (React Native, Flutter, native iOS/Android)',
     rules: ['navigation.md', 'offline-first.md', 'overview.md', 'performance.md', 'testing.md']
   },
   'platform-engineering': {
+    category: 'engineering',
     description: 'Internal developer platforms, infrastructure automation, and reliability engineering',
     rules: ['ci-cd.md', 'developer-experience.md', 'infrastructure-as-code.md', 'kubernetes.md', 'observability.md', 'overview.md', 'security.md', 'testing.md']
   },
   'product-manager': {
+    category: 'business',
     description: 'Product management with customer-centric discovery, prioritization, and execution',
     rules: ['communication.md', 'discovery.md', 'metrics.md', 'overview.md', 'prioritization.md', 'requirements.md']
   },
   'python-expert': {
+    category: 'languages',
     description: 'Principal-level Python engineering (type system, async, testing, FastAPI, Django)',
     rules: ['async-python.md', 'overview.md', 'patterns-and-idioms.md', 'performance.md', 'testing.md', 'tooling.md', 'type-system.md', 'web-and-apis.md']
   },
   'qa-engineering': {
+    category: 'engineering',
     description: 'Quality assurance programs for confident, rapid software delivery',
     rules: ['automation.md', 'metrics.md', 'overview.md', 'quality-gates.md', 'test-design.md', 'test-strategy.md']
   },
   'rust-expert': {
+    category: 'languages',
     description: 'Principal-level Rust engineering (ownership, concurrency, unsafe, traits, async)',
     rules: ['concurrency.md', 'ecosystem-and-tooling.md', 'error-handling.md', 'overview.md', 'ownership-and-borrowing.md', 'performance-and-unsafe.md', 'testing.md', 'traits-and-generics.md']
   },
   'swift-expert': {
+    category: 'languages',
     description: 'Principal-level Swift engineering (concurrency, SwiftUI, protocols, testing, Apple platforms)',
     rules: ['concurrency.md', 'error-handling.md', 'language-features.md', 'overview.md', 'performance.md', 'swiftui.md', 'testing.md', 'tooling.md']
   },
   'testing': {
+    category: 'engineering',
     description: 'Comprehensive testing practices (TDD, test design, CI/CD integration, performance testing)',
     rules: ['advanced-techniques.md', 'ci-cd-integration.md', 'overview.md', 'performance-testing.md', 'quality-metrics.md', 'reliability.md', 'tdd-methodology.md', 'test-data.md', 'test-design.md', 'test-types.md']
   },
   'utility-agent': {
+    category: 'agents',
     description: 'AI agent utilities with context management and hallucination prevention',
     rules: ['action-control.md', 'context-management.md', 'hallucination-prevention.md', 'overview.md', 'token-optimization.md']
   },
   'ux-designer': {
+    category: 'creative',
     description: 'Principal-level UX design with user research, interaction design, design systems, accessibility, and emotional design',
     rules: ['accessibility.md', 'emotional-design.md', 'handoff.md', 'information-architecture.md', 'interaction-design.md', 'overview.md', 'research.md', 'visual-design.md']
   },
   'web-backend': {
+    category: 'engineering',
     description: 'Backend APIs and services (REST, GraphQL, microservices)',
     rules: ['api-design.md', 'authentication.md', 'database-patterns.md', 'error-handling.md', 'overview.md', 'security.md', 'testing.md']
   },
   'web-frontend': {
+    category: 'engineering',
     description: 'Frontend web applications (SPAs, SSR, static sites, PWAs)',
     rules: ['accessibility.md', 'component-patterns.md', 'overview.md', 'performance.md', 'state-management.md', 'styling.md', 'testing.md']
   }
@@ -162,6 +203,17 @@ function resolveTemplateAlias(name) {
   return TEMPLATE_ALIASES[name] || name;
 }
 
+/**
+ * Get the source path for a template's rule files
+ * @param {string} template - Template name
+ * @param {string} rule - Rule filename
+ * @returns {string} Full path to the rule file in templates/<category>/<template>/.cursor/rules/
+ */
+function getTemplateRulePath(template, rule) {
+  const { category } = TEMPLATES[template];
+  return path.join(TEMPLATES_DIR, category, template, '.cursor', 'rules', rule);
+}
+
 const SHARED_RULES = [
   'code-quality.md',
   'communication.md', 
@@ -255,7 +307,7 @@ ${colors.yellow('Removal Options:')}
   --reset        Remove ALL installed content (shared rules, templates, generated files)
 
 ${colors.yellow('IDE Targets:')}
-  cursor         .cursorrules/ directory (Cursor IDE)
+  cursor         .cursor/rules/ directory (Cursor IDE)
   claude         CLAUDE.md file (Claude Code, Cursor with Claude)
   codex          .github/copilot-instructions.md (GitHub Copilot)
 
@@ -306,11 +358,25 @@ function printTemplates() {
 
   console.log(colors.yellow('Available Templates:\n'));
 
+  // Group templates by category
+  const byCategory = {};
   for (const [name, info] of Object.entries(TEMPLATES)) {
-    const aliases = aliasesByTemplate[name];
-    const aliasSuffix = aliases ? ` ${colors.dim(`(aliases: ${aliases.join(', ')})`)}` : '';
-    console.log(`  ${colors.green(name)}${aliasSuffix}`);
-    console.log(`    ${info.description}\n`);
+    const cat = info.category;
+    if (!byCategory[cat]) byCategory[cat] = [];
+    byCategory[cat].push({ name, info });
+  }
+
+  for (const category of CATEGORIES) {
+    const templates = byCategory[category];
+    if (!templates || templates.length === 0) continue;
+    const label = category.charAt(0).toUpperCase() + category.slice(1);
+    console.log(colors.blue(`  ${label}:`));
+    for (const { name, info } of templates) {
+      const aliases = aliasesByTemplate[name];
+      const aliasSuffix = aliases ? ` ${colors.dim(`(aliases: ${aliases.join(', ')})`)}` : '';
+      console.log(`    ${colors.green(name)}${aliasSuffix}`);
+      console.log(`      ${info.description}\n`);
+    }
   }
 
   console.log(colors.blue('Shared rules (always included):'));
@@ -574,7 +640,7 @@ ${rules}`;
 
   return `# CLAUDE.md - Development Guide
 
-This project uses AI-assisted development with Cursor. The rules in \`.cursorrules/\` provide domain-specific guidance for the AI assistant.
+This project uses AI-assisted development with Cursor. The rules in \`.cursor/rules/\` provide domain-specific guidance for the AI assistant.
 
 ---
 
@@ -587,7 +653,7 @@ ${templateList}
 
 ### Rule Files
 
-All rules are in \`.cursorrules/\`. The AI assistant automatically reads these when working on your project.
+All rules are in \`.cursor/rules/\`. The AI assistant automatically reads these when working on your project.
 
 #### Shared Rules (Apply to All Code)
 
@@ -650,13 +716,13 @@ A feature is complete when:
 
 ### Adding Project-Specific Rules
 
-1. Create new \`.md\` files in \`.cursorrules/\`
+1. Create new \`.md\` files in \`.cursor/rules/\`
 2. Follow the existing naming convention
 3. Include clear examples and anti-patterns
 
 ### Modifying Existing Rules
 
-Edit files directly in \`.cursorrules/\`. Changes take effect immediately.
+Edit files directly in \`.cursor/rules/\`. Changes take effect immediately.
 
 ### Updating Templates
 
@@ -705,7 +771,7 @@ function generateCopilotInstructionsContent(installedTemplates) {
   // Read and concatenate template-specific rules
   const templateRulesContent = installedTemplates.map(template => {
     return TEMPLATES[template].rules.map(rule => {
-      const rulePath = path.join(TEMPLATES_DIR, template, '.cursorrules', rule);
+      const rulePath = getTemplateRulePath(template, rule);
       try {
         return fs.readFileSync(rulePath, 'utf8');
       } catch {
@@ -772,7 +838,7 @@ A feature is complete when:
 `;
 }
 
-function install(targetDir, templates, dryRun = false, force = false, ides = DEFAULT_IDES) {
+async function install(targetDir, templates, dryRun = false, force = false, ides = DEFAULT_IDES, skipConfirm = false) {
   const stats = { copied: 0, skipped: 0, updated: 0, renamed: 0 };
   const renamedFiles = [];
   const installedFor = [];
@@ -784,20 +850,20 @@ function install(targetDir, templates, dryRun = false, force = false, ides = DEF
   }
   console.log();
 
-  // 1. Install .cursorrules/ for Cursor IDE
+  // 1. Install .cursor/rules/ for Cursor IDE
   if (ides.includes('cursor')) {
     installedFor.push('cursor');
-    const cursorrules = path.join(targetDir, '.cursorrules');
-    
-    if (!dryRun && !fs.existsSync(cursorrules)) {
-      fs.mkdirSync(cursorrules, { recursive: true });
+    const cursorRulesDir = path.join(targetDir, CURSOR_RULES_DIR);
+
+    if (!dryRun && !fs.existsSync(cursorRulesDir)) {
+      fs.mkdirSync(cursorRulesDir, { recursive: true });
     }
 
     // Install shared rules
-    console.log(colors.green('► Installing shared rules (.cursorrules/)...'));
+    console.log(colors.green(`► Installing shared rules (${CURSOR_RULES_DIR}/)...`));
     for (const rule of SHARED_RULES) {
       const src = path.join(TEMPLATES_DIR, '_shared', rule);
-      const dest = path.join(cursorrules, rule);
+      const dest = path.join(cursorRulesDir, rule);
       
       if (dryRun) {
         const exists = fs.existsSync(dest);
@@ -829,11 +895,11 @@ function install(targetDir, templates, dryRun = false, force = false, ides = DEF
 
     // Install template-specific rules
     for (const template of templates) {
-      console.log(colors.green(`► Installing ${template} template (.cursorrules/)...`));
-      
+      console.log(colors.green(`► Installing ${template} template (${CURSOR_RULES_DIR}/)...`));
+
       for (const rule of TEMPLATES[template].rules) {
-        const src = path.join(TEMPLATES_DIR, template, '.cursorrules', rule);
-        const dest = path.join(cursorrules, `${template}-${rule}`);
+        const src = getTemplateRulePath(template, rule);
+        const dest = path.join(cursorRulesDir, `${template}-${rule}`);
         const destName = `${template}-${rule}`;
         
         if (dryRun) {
@@ -864,6 +930,63 @@ function install(targetDir, templates, dryRun = false, force = false, ides = DEF
       }
       console.log();
     }
+
+    // Legacy .cursorrules/ detection and cleanup
+    const legacyDir = path.join(targetDir, LEGACY_CURSORRULES_DIR);
+    if (fs.existsSync(legacyDir)) {
+      console.log(colors.yellow(`⚠  Deprecated ${LEGACY_CURSORRULES_DIR}/ directory detected.`));
+      console.log(colors.yellow(`   Cursor now uses ${CURSOR_RULES_DIR}/ for rule files.`));
+      console.log(colors.yellow(`   New rules have been installed to ${CURSOR_RULES_DIR}/.`));
+      console.log();
+      console.log(colors.yellow(`   Your existing ${LEGACY_CURSORRULES_DIR}/ files are still present.`));
+      console.log(colors.yellow(`   Support for ${LEGACY_CURSORRULES_DIR}/ will be removed in a future version.`));
+      console.log();
+
+      if (!dryRun) {
+        const shouldCleanup = skipConfirm || await confirm(
+          colors.yellow(`? Would you like to remove the deprecated ${LEGACY_CURSORRULES_DIR}/ directory?`)
+        );
+
+        if (shouldCleanup) {
+          // Copy legacy rule files to .cursor/rules/ before removing (don't overwrite existing)
+          const legacyEntries = fs.readdirSync(legacyDir, { withFileTypes: true });
+          let copiedCount = 0;
+          for (const entry of legacyEntries) {
+            if (!entry.isFile()) continue;
+            const name = entry.name;
+            const legacyPath = path.join(legacyDir, name);
+            const destPath = path.join(cursorRulesDir, name);
+            if (!fs.existsSync(destPath)) {
+              fs.copyFileSync(legacyPath, destPath);
+              console.log(colors.dim(`  ${colors.green('[migrated]')} ${name} → ${CURSOR_RULES_DIR}/`));
+              copiedCount++;
+            }
+          }
+          if (copiedCount > 0) {
+            console.log(colors.green(`  ✓ Migrated ${copiedCount} file(s) from ${LEGACY_CURSORRULES_DIR}/ to ${CURSOR_RULES_DIR}/.`));
+          }
+          fs.rmSync(legacyDir, { recursive: true });
+          console.log(colors.green(`  ✓ Removed deprecated ${LEGACY_CURSORRULES_DIR}/ directory.`));
+        } else {
+          // Create reference file so Cursor AI knows about legacy rules
+          const noticePath = path.join(cursorRulesDir, 'legacy-cursorrules-notice.md');
+          const noticeContent = `# Legacy Rules Notice
+
+This project contains additional rule files in the deprecated \`.cursorrules/\` directory
+at the project root. Those rules are still active and should be consulted alongside the
+rules in this directory.
+
+The \`.cursorrules/\` directory will be removed in a future version.
+To clean up manually, move any custom rules to \`.cursor/rules/\` and delete \`.cursorrules/\`.
+`;
+          fs.writeFileSync(noticePath, noticeContent);
+          console.log(colors.dim(`  Created ${CURSOR_RULES_DIR}/legacy-cursorrules-notice.md as a reference.`));
+        }
+      } else {
+        console.log(colors.dim('  (dry-run: skipping cleanup prompt)'));
+      }
+      console.log();
+    }
   }
 
   // 2. Generate CLAUDE.md for Claude Code
@@ -990,7 +1113,7 @@ function install(targetDir, templates, dryRun = false, force = false, ides = DEF
   console.log(colors.yellow('Installed for:'));
   for (const ide of installedFor) {
     const ideInfo = {
-      cursor: '.cursorrules/ (Cursor IDE)',
+      cursor: '.cursor/rules/ (Cursor IDE)',
       claude: 'CLAUDE.md (Claude Code)',
       codex: '.github/copilot-instructions.md (GitHub Copilot)'
     };
@@ -1071,52 +1194,76 @@ async function remove(targetDir, templates, dryRun = false, force = false, skipC
   console.log(`${colors.blue('Templates:')} ${templates.join(', ')}`);
   console.log();
 
-  // 1. Collect files to remove from .cursorrules/
+  // 1. Collect files to remove from .cursor/rules/ (and legacy .cursorrules/)
   if (ides.includes('cursor')) {
-    const cursorrules = path.join(targetDir, '.cursorrules');
-    
-    if (fs.existsSync(cursorrules)) {
+    const cursorRulesDir = path.join(targetDir, CURSOR_RULES_DIR);
+    const legacyDir = path.join(targetDir, LEGACY_CURSORRULES_DIR);
+    const dirsToScan = [];
+
+    if (fs.existsSync(cursorRulesDir)) dirsToScan.push({ dir: cursorRulesDir, label: CURSOR_RULES_DIR });
+    if (fs.existsSync(legacyDir)) dirsToScan.push({ dir: legacyDir, label: LEGACY_CURSORRULES_DIR });
+
+    if (dirsToScan.length > 0) {
       for (const template of templates) {
         console.log(colors.yellow(`► Scanning ${template} template files...`));
-        
-        for (const rule of TEMPLATES[template].rules) {
-          const destName = `${template}-${rule}`;
-          const destPath = path.join(cursorrules, destName);
-          const srcPath = path.join(TEMPLATES_DIR, template, '.cursorrules', rule);
-          
-          if (!fs.existsSync(destPath)) {
-            console.log(`  ${colors.dim('[not found]')} ${destName}`);
-            stats.notFound++;
-            continue;
+
+        for (const { dir, label } of dirsToScan) {
+          for (const rule of TEMPLATES[template].rules) {
+            const destName = `${template}-${rule}`;
+            const destPath = path.join(dir, destName);
+            const srcPath = getTemplateRulePath(template, rule);
+
+            if (!fs.existsSync(destPath)) {
+              continue;
+            }
+
+            const isUnmodified = isOurFile(destPath, srcPath);
+            const displayName = `${destName} (${label}/)`;
+
+            if (!isUnmodified && !force) {
+              console.log(`  ${colors.yellow('[modified]')} ${displayName} (use --force to remove)`);
+              modifiedFiles.push(displayName);
+              stats.skipped++;
+            } else {
+              console.log(`  ${colors.red('[remove]')} ${displayName}${!isUnmodified ? ' (modified, --force)' : ''}`);
+              filesToRemove.push({ path: destPath, name: displayName });
+            }
           }
-          
-          const isUnmodified = isOurFile(destPath, srcPath);
-          
-          if (!isUnmodified && !force) {
-            console.log(`  ${colors.yellow('[modified]')} ${destName} (use --force to remove)`);
-            modifiedFiles.push(destName);
-            stats.skipped++;
-          } else {
-            console.log(`  ${colors.red('[remove]')} ${destName}${!isUnmodified ? ' (modified, --force)' : ''}`);
-            filesToRemove.push({ path: destPath, name: destName });
+
+          // Also check for -1 variant files
+          for (const rule of TEMPLATES[template].rules) {
+            const altName = `${template}-${rule.replace('.md', '-1.md')}`;
+            const altPath = path.join(dir, altName);
+
+            if (fs.existsSync(altPath)) {
+              console.log(`  ${colors.red('[remove]')} ${altName} (${label}/, alternate file)`);
+              filesToRemove.push({ path: altPath, name: altName });
+            }
           }
         }
-        
-        // Also check for -1 variant files
+
+        // Check for legacy-cursorrules-notice.md in new dir
+        const noticePath = path.join(cursorRulesDir, 'legacy-cursorrules-notice.md');
+        if (fs.existsSync(noticePath)) {
+          console.log(`  ${colors.red('[remove]')} legacy-cursorrules-notice.md`);
+          filesToRemove.push({ path: noticePath, name: 'legacy-cursorrules-notice.md' });
+        }
+
+        // Log not-found for templates that weren't in either dir
         for (const rule of TEMPLATES[template].rules) {
-          const altName = `${template}-${rule.replace('.md', '-1.md')}`;
-          const altPath = path.join(cursorrules, altName);
-          
-          if (fs.existsSync(altPath)) {
-            console.log(`  ${colors.red('[remove]')} ${altName} (alternate file)`);
-            filesToRemove.push({ path: altPath, name: altName });
+          const destName = `${template}-${rule}`;
+          const inNew = fs.existsSync(path.join(cursorRulesDir, destName));
+          const inLegacy = fs.existsSync(path.join(legacyDir, destName));
+          if (!inNew && !inLegacy) {
+            console.log(`  ${colors.dim('[not found]')} ${destName}`);
+            stats.notFound++;
           }
         }
-        
+
         console.log();
       }
     } else {
-      console.log(colors.dim('No .cursorrules/ directory found.\n'));
+      console.log(colors.dim(`No ${CURSOR_RULES_DIR}/ or ${LEGACY_CURSORRULES_DIR}/ directory found.\n`));
     }
   }
 
@@ -1194,86 +1341,105 @@ async function reset(targetDir, dryRun = false, force = false, skipConfirm = fal
   console.log(`${colors.blue('Target IDEs:')} ${ides.join(', ')}`);
   console.log();
 
-  // 1. Remove .cursorrules/ contents for Cursor
+  // 1. Remove .cursor/rules/ and legacy .cursorrules/ contents for Cursor
   if (ides.includes('cursor')) {
-    const cursorrules = path.join(targetDir, '.cursorrules');
-    
-    if (fs.existsSync(cursorrules)) {
-      console.log(colors.yellow('► Scanning .cursorrules/ directory...'));
-      
-      // Check shared rules
-      for (const rule of SHARED_RULES) {
-        const destPath = path.join(cursorrules, rule);
-        const srcPath = path.join(TEMPLATES_DIR, '_shared', rule);
-        
-        if (!fs.existsSync(destPath)) continue;
-        
-        const isUnmodified = isOurFile(destPath, srcPath);
-        
-        if (!isUnmodified && !force) {
-          console.log(`  ${colors.yellow('[modified]')} ${rule} (use --force to remove)`);
-          modifiedFiles.push(rule);
-          stats.skipped++;
-        } else {
-          console.log(`  ${colors.red('[remove]')} ${rule}${!isUnmodified ? ' (modified, --force)' : ''}`);
-          filesToRemove.push({ path: destPath, name: rule });
-        }
-        
-        // Check for -1 variant
-        const altPath = path.join(cursorrules, rule.replace('.md', '-1.md'));
-        if (fs.existsSync(altPath)) {
-          console.log(`  ${colors.red('[remove]')} ${rule.replace('.md', '-1.md')} (alternate file)`);
-          filesToRemove.push({ path: altPath, name: rule.replace('.md', '-1.md') });
-        }
-      }
-      
-      // Check template-specific rules
-      for (const [templateName, templateInfo] of Object.entries(TEMPLATES)) {
-        for (const rule of templateInfo.rules) {
-          const destName = `${templateName}-${rule}`;
-          const destPath = path.join(cursorrules, destName);
-          const srcPath = path.join(TEMPLATES_DIR, templateName, '.cursorrules', rule);
-          
+    const cursorRulesDir = path.join(targetDir, CURSOR_RULES_DIR);
+    const legacyDir = path.join(targetDir, LEGACY_CURSORRULES_DIR);
+    const dirsToScan = [];
+
+    if (fs.existsSync(cursorRulesDir)) dirsToScan.push({ dir: cursorRulesDir, label: CURSOR_RULES_DIR });
+    if (fs.existsSync(legacyDir)) dirsToScan.push({ dir: legacyDir, label: LEGACY_CURSORRULES_DIR });
+
+    if (dirsToScan.length > 0) {
+      for (const { dir, label } of dirsToScan) {
+        console.log(colors.yellow(`► Scanning ${label}/ directory...`));
+
+        // Check shared rules
+        for (const rule of SHARED_RULES) {
+          const destPath = path.join(dir, rule);
+          const srcPath = path.join(TEMPLATES_DIR, '_shared', rule);
+
           if (!fs.existsSync(destPath)) continue;
-          
+
           const isUnmodified = isOurFile(destPath, srcPath);
-          
+
           if (!isUnmodified && !force) {
-            console.log(`  ${colors.yellow('[modified]')} ${destName} (use --force to remove)`);
-            modifiedFiles.push(destName);
+            console.log(`  ${colors.yellow('[modified]')} ${rule} (use --force to remove)`);
+            modifiedFiles.push(`${rule} (${label}/)`);
             stats.skipped++;
           } else {
-            console.log(`  ${colors.red('[remove]')} ${destName}${!isUnmodified ? ' (modified, --force)' : ''}`);
-            filesToRemove.push({ path: destPath, name: destName });
+            console.log(`  ${colors.red('[remove]')} ${rule}${!isUnmodified ? ' (modified, --force)' : ''}`);
+            filesToRemove.push({ path: destPath, name: `${rule} (${label}/)` });
           }
-          
+
           // Check for -1 variant
-          const altName = destName.replace('.md', '-1.md');
-          const altPath = path.join(cursorrules, altName);
+          const altPath = path.join(dir, rule.replace('.md', '-1.md'));
           if (fs.existsSync(altPath)) {
-            console.log(`  ${colors.red('[remove]')} ${altName} (alternate file)`);
-            filesToRemove.push({ path: altPath, name: altName });
+            console.log(`  ${colors.red('[remove]')} ${rule.replace('.md', '-1.md')} (alternate file)`);
+            filesToRemove.push({ path: altPath, name: rule.replace('.md', '-1.md') });
           }
         }
+
+        // Check template-specific rules
+        for (const [templateName, templateInfo] of Object.entries(TEMPLATES)) {
+          for (const rule of templateInfo.rules) {
+            const destName = `${templateName}-${rule}`;
+            const destPath = path.join(dir, destName);
+            const srcPath = getTemplateRulePath(templateName, rule);
+
+            if (!fs.existsSync(destPath)) continue;
+
+            const isUnmodified = isOurFile(destPath, srcPath);
+
+            if (!isUnmodified && !force) {
+              console.log(`  ${colors.yellow('[modified]')} ${destName} (use --force to remove)`);
+              modifiedFiles.push(`${destName} (${label}/)`);
+              stats.skipped++;
+            } else {
+              console.log(`  ${colors.red('[remove]')} ${destName}${!isUnmodified ? ' (modified, --force)' : ''}`);
+              filesToRemove.push({ path: destPath, name: `${destName} (${label}/)` });
+            }
+
+            // Check for -1 variant
+            const altName = destName.replace('.md', '-1.md');
+            const altPath = path.join(dir, altName);
+            if (fs.existsSync(altPath)) {
+              console.log(`  ${colors.red('[remove]')} ${altName} (alternate file)`);
+              filesToRemove.push({ path: altPath, name: altName });
+            }
+          }
+        }
+
+        // Check for legacy-cursorrules-notice.md
+        const noticePath = path.join(dir, 'legacy-cursorrules-notice.md');
+        if (fs.existsSync(noticePath)) {
+          console.log(`  ${colors.red('[remove]')} legacy-cursorrules-notice.md`);
+          filesToRemove.push({ path: noticePath, name: 'legacy-cursorrules-notice.md' });
+        }
+
+        // Check if we should remove the directory itself (only if it would be empty)
+        const remainingFiles = fs.readdirSync(dir).filter(f => {
+          const fullPath = path.join(dir, f);
+          const willBeRemoved = filesToRemove.some(fr => fr.path === fullPath);
+          return !willBeRemoved;
+        });
+
+        if (remainingFiles.length === 0 || force) {
+          console.log(`  ${colors.red('[remove]')} ${label}/ directory`);
+          dirsToRemove.push(dir);
+          // If removing .cursor/rules/, also check if .cursor/ would be empty
+          if (label === CURSOR_RULES_DIR) {
+            const cursorDir = path.join(targetDir, '.cursor');
+            dirsToRemove.push(cursorDir);
+          }
+        } else if (remainingFiles.length > 0) {
+          console.log(colors.dim(`  ${label}/ will be kept (${remainingFiles.length} non-template file(s) remain)`));
+        }
+
+        console.log();
       }
-      
-      // Check if we should remove the directory itself (only if it would be empty)
-      const remainingFiles = fs.readdirSync(cursorrules).filter(f => {
-        const fullPath = path.join(cursorrules, f);
-        const willBeRemoved = filesToRemove.some(fr => fr.path === fullPath);
-        return !willBeRemoved;
-      });
-      
-      if (remainingFiles.length === 0 || force) {
-        console.log(`  ${colors.red('[remove]')} .cursorrules/ directory`);
-        dirsToRemove.push(cursorrules);
-      } else if (remainingFiles.length > 0) {
-        console.log(colors.dim(`  .cursorrules/ will be kept (${remainingFiles.length} non-template file(s) remain)`));
-      }
-      
-      console.log();
     } else {
-      console.log(colors.dim('No .cursorrules/ directory found.\n'));
+      console.log(colors.dim(`No ${CURSOR_RULES_DIR}/ or ${LEGACY_CURSORRULES_DIR}/ directory found.\n`));
     }
   }
 
@@ -1286,8 +1452,8 @@ async function reset(targetDir, dryRun = false, force = false, skipConfirm = fal
       
       // Check if it contains our signature content
       const content = fs.readFileSync(claudePath, 'utf8');
-      const isOurs = content.includes('# CLAUDE.md - Development Guide') && 
-                     content.includes('.cursorrules/');
+      const isOurs = content.includes('# CLAUDE.md - Development Guide') &&
+                     (content.includes('.cursor/rules/') || content.includes('.cursorrules/'));
       
       if (!isOurs && !force) {
         console.log(`  ${colors.yellow('[modified]')} CLAUDE.md (doesn't match template, use --force)`);
@@ -1532,7 +1698,7 @@ export async function run(args) {
   }
 
   // Install to current directory
-  install(process.cwd(), resolvedTemplates, dryRun, force, targetIdes);
+  await install(process.cwd(), resolvedTemplates, dryRun, force, targetIdes, skipConfirm);
 }
 
 // Export internals for testing
@@ -1541,6 +1707,9 @@ export const _internals = {
   CURRENT_VERSION,
   REPO_URL,
   CHANGELOG_URL,
+  CURSOR_RULES_DIR,
+  LEGACY_CURSORRULES_DIR,
+  CATEGORIES,
   TEMPLATES,
   TEMPLATE_ALIASES,
   SHARED_RULES,
@@ -1549,6 +1718,7 @@ export const _internals = {
   compareVersions,
   checkForUpdates,
   resolveTemplateAlias,
+  getTemplateRulePath,
   filesMatch,
   parseMarkdownSections,
   generateSectionSignature,