claude-code-templates 1.21.13 → 1.22.0

package/ROADMAP.md

@@ -1,278 +0,0 @@
-# 🚀 Claude Code Templates - Roadmap
-
-```
- ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗     ██████╗ ██████╗ ██████╗ ███████╗
-██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝    ██╔════╝██╔═══██╗██╔══██╗██╔════╝
-██║     ██║     ███████║██║   ██║██║  ██║█████╗      ██║     ██║   ██║██║  ██║█████╗  
-██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝      ██║     ██║   ██║██║  ██║██╔══╝  
-╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗    ╚██████╗╚██████╔╝██████╔╝███████╗
- ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
-
-████████╗███████╗███╗   ███╗██████╗ ██╗      █████╗ ████████╗███████╗███████╗
-╚══██╔══╝██╔════╝████╗ ████║██╔══██╗██║     ██╔══██╗╚══██╔══╝██╔════╝██╔════╝
-   ██║   █████╗  ██╔████╔██║██████╔╝██║     ███████║   ██║   █████╗  ███████╗
-   ██║   ██╔══╝  ██║╚██╔╝██║██╔═══╝ ██║     ██╔══██║   ██║   ██╔══╝  ╚════██║
-   ██║   ███████╗██║ ╚═╝ ██║██║     ███████╗██║  ██║   ██║   ███████╗███████║
-   ╚═╝   ╚══════╝╚═╝     ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝
-```
-
-## 📋 Development Roadmap 
-
-> **Mission**: Transform Claude Code Templates into the definitive marketplace for AI-powered development tools and workflows.
-
----
-
-## 🎯 Phase 1: Component Installation & Configuration System
-**Status**: 🚧 In Development  
-**Branch**: `feature/enhanced-search-functionality`
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│ 📦 INSTALLATION & CONFIGURATION ENGINE                                     │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  ┌─ 🔧 Enhanced CLI Tool                                                    │
-│  │   ├── Interactive component selection with preview                      │
-│  │   ├── Batch installation with dependency resolution                     │
-│  │   ├── Configuration validation and health checks                        │
-│  │   └── Rollback and version management                                   │
-│  │                                                                         │
-│  ┌─ 🎯 Smart Installation Locations                                        │
-│  │   ├── User (~/.claude/settings.json) - Global preferences              │
-│  │   ├── Project (.claude/settings.json) - Team shared                    │
-│  │   ├── Local (.claude/settings.local.json) - Personal                   │
-│  │   └── Enterprise (system-wide) - Organization policies                 │
-│  │                                                                         │
-│  ┌─ 🧬 Component Compatibility Matrix                                      │
-│  │   ├── Cross-component dependency detection                             │
-│  │   ├── Version compatibility checks                                     │
-│  │   ├── Conflict resolution algorithms                                   │
-│  │   └── Automated optimization suggestions                               │
-│  │                                                                         │
-│  └─ ⚡ Real-time Configuration Sync                                        │
-│      ├── Live preview of configuration changes                            │
-│      ├── Hot-reload for development environments                          │
-│      ├── Backup and restore functionality                                 │
-│      └── Configuration templates and presets                              │
-│                                                                             │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
-**Deliverables:**
-- ✅ Enhanced search functionality with real-time filtering
-- ⏳ Advanced CLI with interactive installation flows
-- ⏳ Configuration validation and conflict resolution
-- ⏳ Component dependency management system
-
----
-
-## 📊 Phase 2: Analytics & Usage Tracking System
-**Status**: 🔜 Planned  
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│ 📈 TRACKING & ANALYTICS ENGINE                                             │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  ┌─ 📡 Installation Tracking                                               │
-│  │   ├── Download counters with geographic data                           │
-│  │   ├── Usage patterns and frequency analysis                            │
-│  │   ├── Component popularity rankings                                    │
-│  │   └── Success/failure rate monitoring                                  │
-│  │                                                                         │
-│  ┌─ 🏆 Component Ranking System                                           │
-│  │   ├── Multi-factor scoring algorithm:                                  │
-│  │   │   ├─ Download count (40%)                                          │
-│  │   │   ├─ User ratings (30%)                                            │
-│  │   │   ├─ Community feedback (20%)                                      │
-│  │   │   └─ Maintenance activity (10%)                                    │
-│  │   ├── Trending components dashboard                                    │
-│  │   ├── Category-specific leaderboards                                   │
-│  │   └── Personalized recommendations                                     │
-│  │                                                                         │
-│  ┌─ 📊 Real-time Analytics Dashboard                                       │
-│  │   ├── Live download statistics                                         │
-│  │   ├── Component performance metrics                                    │
-│  │   ├── User engagement analytics                                        │
-│  │   └── Community growth insights                                        │
-│  │                                                                         │
-│  └─ 🎯 Smart Recommendations                                               │
-│      ├── AI-powered component suggestions                                 │
-│      ├── "Users who installed X also installed Y"                         │
-│      ├── Technology stack recommendations                                 │
-│      └── Workflow optimization suggestions                                │
-│                                                                             │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
-**Features:**
-- Download tracking with privacy-first approach
-- Component popularity rankings and trending
-- User-driven rating and review system
-- Analytics dashboard for maintainers
-- Smart recommendation engine
-
----
-
-## 🔄 Phase 3: Workflow Creation & Automation
-**Status**: 🔮 Future  
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│ 🔄 WORKFLOW CREATION ENGINE                                                │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  ┌─ 🎨 Visual Workflow Builder                                             │
-│  │   ├── Drag-and-drop component composer                                 │
-│  │   ├── Flow-based programming interface                                 │
-│  │   ├── Real-time workflow validation                                    │
-│  │   └── Version control for workflows                                    │
-│  │                                                                         │
-│  ┌─ 🧩 Component Orchestration                                            │
-│  │   ├── Agents → Commands → MCPs → Hooks pipeline                        │
-│  │   ├── Conditional logic and branching                                  │
-│  │   ├── Error handling and retry mechanisms                              │
-│  │   └── Parallel execution and scheduling                                │
-│  │                                                                         │
-│  ┌─ 📋 Workflow Templates                                                  │
-│  │   ├── Pre-built workflow patterns:                                     │
-│  │   │   ├─ Code Review → Test → Deploy                                   │
-│  │   │   ├─ Research → Document → Share                                   │
-│  │   │   ├─ Debug → Fix → Validate                                        │
-│  │   │   └─ Analyze → Optimize → Monitor                                  │
-│  │   ├── Industry-specific workflows                                      │
-│  │   ├── Customizable workflow skeletons                                  │
-│  │   └── Community-contributed patterns                                   │
-│  │                                                                         │
-│  └─ ⚡ Auto-workflow Generation                                            │
-│      ├── AI-powered workflow suggestions                                  │
-│      ├── Learning from user patterns                                      │
-│      ├── Optimization recommendations                                     │
-│      └── Automated testing and validation                                 │
-│                                                                             │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
-**Capabilities:**
-- Visual workflow designer with node-based interface
-- Component orchestration with conditional logic
-- Pre-built workflow templates for common patterns
-- AI-powered workflow optimization
-- Community workflow sharing and collaboration
-
----
-
-## 🏗️ Phase 4: Technology Stacks & Ecosystems
-**Status**: 🌟 Vision  
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│ 🏗️ TECHNOLOGY STACKS & ECOSYSTEMS                                         │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  ┌─ 🌐 Technology Stack Marketplace                                        │
-│  │   ├── Pre-configured development environments:                         │
-│  │   │   ├─ 🚀 Frontend: React + Next.js + Tailwind                       │
-│  │   │   ├─ 🔧 Backend: Node.js + Express + MongoDB                       │
-│  │   │   ├─ 🐍 Python: Django + PostgreSQL + Redis                        │
-│  │   │   ├─ 🦀 Rust: Actix + Diesel + PostgreSQL                          │
-│  │   │   └─ ☁️ Cloud: AWS + Terraform + Docker                            │
-│  │   ├── One-command stack deployment                                     │
-│  │   ├── Stack health monitoring                                          │
-│  │   └── Version upgrade automation                                       │
-│  │                                                                         │
-│  └─ 🌐 Ecosystem Integrations                               │
-│  │   │                                                                    │
-│  │   ├── 🧠 Anthropic Ecosystem                                           │
-│  │   │   ├─ Claude Code enhanced agents                                   │
-│  │   │   ├─ Constitutional AI workflows                                   │
-│  │   │   ├─ Advanced reasoning patterns                                   │
-│  │   │   └─ Safety-first development tools                                │
-│  │   │                                                                    │
-│  │   ├── 💳 Stripe Commerce Stack                                         │
-│  │   │   ├─ Payment processing agents                                     │
-│  │   │   ├─ Subscription management workflows                             │
-│  │   │   ├─ Financial reporting automation                                │
-│  │   │   └─ Compliance monitoring hooks                                   │
-│  │   │                                                                    │
-│  │   └── ☁️ AWS Enterprise Stack                                          │
-│  │       ├─ Infrastructure as code agents                                 │
-│  │       ├─ Serverless deployment workflows                               │
-│  │       ├─ Cost optimization automation                                  │
-│  │       └─ Security compliance hooks                                     │
-│  │                                                                         │
-│  ┌─ 🎯 Language-Specific Optimization                                      │
-│  │   ├── JavaScript/TypeScript ecosystem                                  │
-│  │   ├── Python data science and web development                          │
-│  │   ├── Rust systems programming tools                                   │
-│  │   ├── Go microservices and cloud tools                                 │
-│  │   └── Swift iOS/macOS development kits                                 │
-│  │                                                                         │
-│  └─ 🌍 Community Ecosystem Hub                                            │
-│      ├── Community-curated stack collections                             │
-│      ├── Stack rating and review system                                  │
-│      ├── Collaborative stack development                                 │
-│      └── Stack marketplace with monetization                             │
-│                                                                             │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
-**Ecosystem Categories:**
-- **By Technology**: React, Vue, Python, Rust, Go ecosystems
-- **By Company**: OpenAI, Anthropic, AWS, Stripe, GitHub integrations  
-- **By Use Case**: E-commerce, Data Science, DevOps, Security stacks
-- **By Industry**: Finance, Healthcare, Education, Gaming verticals
-
----
-
-## 🎯 Success Metrics & KPIs
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│ 📊 SUCCESS METRICS                                                         │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│  🎯 User Engagement                    📈 Growth Metrics                   │
-│  ├─ Monthly Active Users: 10K+        ├─ Component Library: 500+           │
-│  ├─ Daily Installations: 1K+          ├─ Community Contributors: 100+      │
-│  ├─ User Retention Rate: 80%+         ├─ GitHub Stars: 5K+                 │
-│  └─ Session Duration: 15min+          └─ NPM Weekly Downloads: 50K+        │
-│                                                                             │
-│  💡 Quality Indicators                 🌟 Community Health                 │
-│  ├─ Component Success Rate: 95%+      ├─ Pull Requests/Month: 50+          │
-│  ├─ User Satisfaction: 4.8/5          ├─ Issue Response Time: <24h         │
-│  ├─ Documentation Coverage: 100%      ├─ Community Events: Monthly         │
-│  └─ Zero Critical Bugs                └─ Knowledge Base: 200+ Articles     │
-│                                                                             │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 🛠️ Technical Architecture Evolution
-
-```
-Current State:          Phase 1:              Phase 2:              Phase 4:
-                                                                              
-┌─────────────┐        ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
-│   Static    │   →    │  Enhanced   │   →   │  Analytics  │   →   │ Marketplace │
-│  Templates  │        │    CLI      │       │  Dashboard  │       │  Ecosystem  │
-└─────────────┘        └─────────────┘       └─────────────┘       └─────────────┘
-      │                        │                       │                   │
-      │                        │                       │                   │
-      ▼                        ▼                       ▼                   ▼
-┌─────────────┐        ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
-│  components │        │   Search &  │       │  Tracking & │       │   AI-Powered│
-│   .json     │        │   Install   │       │  Rankings   │       │  Workflows  │
-└─────────────┘        └─────────────┘       └─────────────┘       └─────────────┘
-                               │                       │                   │
-                               │                       │                   │
-                               ▼                       ▼                   ▼
-                       ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
-                       │ Real-time   │       │   Smart     │       │ Community   │
-                       │  Preview    │       │Recommenda-  │       │ Marketplace │
-                       │             │       │    tions    │       │             │
-                       └─────────────┘       └─────────────┘       └─────────────┘
-```
-
----

package/SECURITY.md

@@ -1,65 +0,0 @@
-# Security Policy
-
-Thank you for helping us keep Claude Code Templates and the systems they interact with secure.
-
-## Reporting Security Issues
-
-This project is maintained by Daniel Avila.
-
-The security of our CLI tool and the templates it generates is our top priority. We appreciate the work of security researchers acting in good faith in identifying and reporting potential vulnerabilities.
-
-## How to Report a Vulnerability
-
-If you discover a security vulnerability in Claude Code Templates, please report it to us in one of the following ways:
-
-### Email
-Send details of the vulnerability to [dan.avila7@gmail.com](mailto:dan.avila7@gmail.com) with the subject line "SECURITY: Claude Code Templates Vulnerability Report"
-
-### GitHub Security Advisories
-You can also report vulnerabilities through [GitHub Security Advisories](https://github.com/davila7/claude-code-templates/security/advisories/new) for this repository.
-
-## What to Include in Your Report
-
-To help us understand and resolve the issue quickly, please include:
-
-- **Description**: A clear description of the vulnerability
-- **Impact**: What an attacker could achieve by exploiting this vulnerability
-- **Steps to Reproduce**: Detailed steps to reproduce the vulnerability
-- **Affected Versions**: Which versions of the CLI tool are affected
-- **Environment**: Operating system, Node.js version, and any other relevant details
-- **Proof of Concept**: If possible, include a minimal example demonstrating the vulnerability
-
-## Security Best Practices
-
-When using Claude Code Templates:
-
-### For Users
-- **Keep Updated**: Always use the latest version via `npx claude-code-templates@latest`
-- **Review Templates**: Check generated files before committing to your repository
-- **Audit Hooks**: Review automation hooks before enabling them
-- **Secure Environment**: Use the tool in a secure development environment
-
-### For Contributors
-- **Dependency Scanning**: Run `npm audit` before submitting changes
-- **Input Validation**: Validate all user inputs and file paths
-- **Secure Defaults**: Choose secure defaults for all template configurations
-- **Code Review**: All changes undergo security-focused code review
-
-## Contact Information
-
-- **Maintainer**: Daniel Avila
-- **Website**: [danielavila.me](https://danielavila.me)
-- **Email**: [dan.avila7@gmail.com](mailto:dan.avila7@gmail.com)
-- **GitHub**: [@davila7](https://github.com/davila7)
-
-## Legal
-
-This security policy is designed to encourage responsible security research. We will not pursue legal action against researchers who:
-
-- Act in good faith
-- Follow responsible disclosure practices
-- Do not access or modify user data
-- Do not perform testing on systems they do not own
-- Report vulnerabilities through the channels described above
-
-Thank you for helping keep Claude Code Templates secure!

package/api/index.html

@@ -1 +0,0 @@
-<h1>AITMPL.COM</h1>

package/api/package.json

@@ -1,7 +0,0 @@
-{
-  "type": "module",
-  "dependencies": {
-    "@vercel/postgres": "^0.10.0",
-    "@supabase/supabase-js": "^2.45.0"
-  }
-}

package/api/track-download-supabase.js

@@ -1,150 +0,0 @@
-// Download tracking API endpoint using Supabase client
-import { createClient } from '@supabase/supabase-js';
-
-// Initialize Supabase client
-function getSupabaseClient() {
-  const supabaseUrl = process.env.SUPABASE_URL;
-  const supabaseServiceKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
-  
-  if (!supabaseUrl || !supabaseServiceKey) {
-    throw new Error('Missing Supabase configuration');
-  }
-  
-  return createClient(supabaseUrl, supabaseServiceKey);
-}
-
-// Validate component data
-function validateComponentData(data) {
-  const { type, name, path, category } = data;
-  
-  if (!type || !name) {
-    return { valid: false, error: 'Component type and name are required' };
-  }
-  
-  const validTypes = ['agent', 'command', 'setting', 'hook', 'mcp', 'template'];
-  if (!validTypes.includes(type)) {
-    return { valid: false, error: 'Invalid component type' };
-  }
-  
-  if (name.length > 255) {
-    return { valid: false, error: 'Component name too long' };
-  }
-  
-  return { valid: true };
-}
-
-// Get IP address from request
-function getClientIP(req) {
-  return req.headers['x-forwarded-for']?.split(',')[0] ||
-         req.headers['x-real-ip'] ||
-         req.connection?.remoteAddress ||
-         req.socket?.remoteAddress ||
-         '127.0.0.1';
-}
-
-// Get country from Vercel geo headers
-function getCountry(req) {
-  return req.headers['x-vercel-ip-country'] || null;
-}
-
-export default async function handler(req, res) {
-  // Set CORS headers
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, User-Agent');
-  
-  // Handle preflight requests
-  if (req.method === 'OPTIONS') {
-    return res.status(200).json({ ok: true });
-  }
-  
-  // Only accept POST requests
-  if (req.method !== 'POST') {
-    return res.status(405).json({ 
-      error: 'Method not allowed', 
-      allowed: ['POST'] 
-    });
-  }
-  
-  try {
-    // Validate request body
-    const { type, name, path, category, cliVersion } = req.body;
-    const validation = validateComponentData({ type, name, path, category });
-    
-    if (!validation.valid) {
-      return res.status(400).json({ error: validation.error });
-    }
-    
-    // Get client information
-    const ipAddress = getClientIP(req);
-    const country = getCountry(req);
-    const userAgent = req.headers['user-agent'];
-    
-    // Initialize Supabase client
-    const supabase = getSupabaseClient();
-    
-    // Insert download record
-    const { data: insertData, error: insertError } = await supabase
-      .from('component_downloads')
-      .insert({
-        component_type: type,
-        component_name: name,
-        component_path: path,
-        category: category,
-        user_agent: userAgent,
-        ip_address: ipAddress,
-        country: country,
-        cli_version: cliVersion,
-        download_timestamp: new Date().toISOString(),
-        created_at: new Date().toISOString()
-      });
-    
-    if (insertError) {
-      console.error('Supabase insert error:', insertError);
-      throw new Error(`Database insert failed: ${insertError.message}`);
-    }
-    
-    // Update aggregated stats (upsert)
-    const { error: upsertError } = await supabase
-      .from('download_stats')
-      .upsert(
-        {
-          component_type: type,
-          component_name: name,
-          total_downloads: 1,
-          last_download: new Date().toISOString(),
-          updated_at: new Date().toISOString()
-        },
-        {
-          onConflict: 'component_type,component_name',
-          ignoreDuplicates: false
-        }
-      );
-    
-    if (upsertError) {
-      console.error('Supabase upsert error:', upsertError);
-      // Don't fail the request for stats update errors
-    }
-    
-    // Return success response
-    res.status(200).json({
-      success: true,
-      message: 'Download tracked successfully',
-      data: {
-        type,
-        name,
-        timestamp: new Date().toISOString()
-      }
-    });
-    
-  } catch (error) {
-    console.error('Download tracking error:', error);
-    
-    // Return error response
-    res.status(500).json({
-      error: 'Internal server error',
-      message: 'Failed to track download',
-      details: process.env.NODE_ENV === 'development' ? error.message : undefined
-    });
-  }
-}

package/cli-tool/Makefile

@@ -1,102 +0,0 @@
-# Makefile for claude-code-templates testing
-
-.PHONY: test test-basic test-detailed test-interactive install-dev uninstall-dev help
-
-# Install package locally for testing
-install-dev:
-	@echo "🔗 Linking package for local development..."
-	npm link
-
-# Uninstall local package
-uninstall-dev:
-	@echo "🔗 Unlinking package..."
-	npm unlink -g claude-code-templates
-
-# Run basic tests
-test-basic: install-dev
-	@echo "🧪 Running basic tests..."
-	./test-commands.sh
-
-# Run detailed tests
-test-detailed: install-dev
-	@echo "🔬 Running detailed tests..."
-	./test-detailed.sh
-
-# Test specific scenario
-test-react: install-dev
-	@echo "⚛️ Testing React scenario..."
-	@mkdir -p /tmp/test-react
-	@cd /tmp/test-react && claude-code-templates --language javascript-typescript --framework react --dry-run --yes
-	@echo "✅ React test completed"
-	@rm -rf /tmp/test-react
-
-test-vue: install-dev
-	@echo "💚 Testing Vue scenario..."
-	@mkdir -p /tmp/test-vue
-	@cd /tmp/test-vue && claude-code-templates --language javascript-typescript --framework vue --dry-run --yes
-	@echo "✅ Vue test completed"
-	@rm -rf /tmp/test-vue
-
-test-node: install-dev
-	@echo "🟢 Testing Node scenario..."
-	@mkdir -p /tmp/test-node
-	@cd /tmp/test-node && claude-code-templates --language javascript-typescript --framework node --dry-run --yes
-	@echo "✅ Node test completed"
-	@rm -rf /tmp/test-node
-
-test-hooks: install-dev
-	@echo "🔧 Testing Hooks functionality..."
-	@mkdir -p /tmp/test-hooks
-	@cd /tmp/test-hooks && claude-code-templates --language javascript-typescript --yes
-	@echo "Checking hooks installation..."
-	@cd /tmp/test-hooks && [ -f ".claude/settings.json" ] && echo "✅ settings.json created"
-	@cd /tmp/test-hooks && jq '.hooks' ".claude/settings.json" > /dev/null && echo "✅ Hooks structure valid"
-	@cd /tmp/test-hooks && [ $$(jq '.hooks | keys | length' ".claude/settings.json") -gt 0 ] && echo "✅ Hooks configured"
-	@rm -rf /tmp/test-hooks
-
-test-python-hooks: install-dev
-	@echo "🐍 Testing Python hooks..."
-	@mkdir -p /tmp/test-python-hooks
-	@cd /tmp/test-python-hooks && claude-code-templates --language python --yes
-	@cd /tmp/test-python-hooks && jq -r '.hooks.PostToolUse[].hooks[].command' ".claude/settings.json" | grep -q "black" && echo "✅ Python Black hook found"
-	@rm -rf /tmp/test-python-hooks
-
-test-all-hooks: test-hooks test-python-hooks
-	@echo "✅ All hooks tests completed"
-
-# Interactive test (manual)
-test-interactive: install-dev
-	@echo "🎯 Starting interactive test (you'll need to interact)..."
-	@mkdir -p /tmp/test-interactive
-	@cd /tmp/test-interactive && claude-code-templates --dry-run
-	@rm -rf /tmp/test-interactive
-
-# Run all tests
-test: test-basic test-detailed test-all-hooks
-	@echo "🎉 All automated tests completed!"
-
-# Check version works
-test-version:
-	@echo "📝 Testing version command..."
-	@claude-code-templates --version
-
-# Test before publish
-pre-publish: test test-version
-	@echo "✅ Ready for publishing!"
-
-# Help
-help:
-	@echo "Available commands:"
-	@echo "  make install-dev    - Install package locally for testing"
-	@echo "  make test-basic     - Run basic test suite"
-	@echo "  make test-detailed  - Run detailed test suite"
-	@echo "  make test-react     - Test React scenario"
-	@echo "  make test-vue       - Test Vue scenario"
-	@echo "  make test-node      - Test Node scenario"
-	@echo "  make test-hooks     - Test hooks functionality"
-	@echo "  make test-python-hooks - Test Python-specific hooks"
-	@echo "  make test-all-hooks - Test all hooks functionality"
-	@echo "  make test-interactive - Manual interactive test"
-	@echo "  make test           - Run all automated tests"
-	@echo "  make pre-publish    - Full test before publishing"
-	@echo "  make uninstall-dev  - Uninstall local package"