claude-code-templates 1.1.7 → 1.2.0

package/README.md

@@ -30,8 +30,9 @@ npx claude-code-templates
 The installer will:
 1. 🔍 **Auto-detect** your project type (JavaScript, Python, etc.)
 2. 🎯 **Ask about frameworks** (React, Django, Flask, etc.)
-3. ⚙️ **Let you choose features** (testing, linting, debugging)
-4. ✅ **Confirm before installing**
+3. 📋 **Let you choose commands** (testing, linting, debugging)
+4. 🔧 **Let you select automation hooks** (formatting, type checking, etc.)
+5. ✅ **Confirm before installing**
 
 ### Step 4: Start Using Claude Code
 ```bash
@@ -110,8 +111,8 @@ create-claude-config
 - **Common** - Universal configuration for any project
 - **JavaScript/TypeScript** - Modern JS/TS development with frameworks
 - **Python** - Python development with popular frameworks
-- **Rust** - Coming soon
-- **Go** - Coming soon
+- **Rust** - Rust development with Cargo and clippy
+- **Go** - Go development with modules and testing
 
 ## Supported Frameworks
 
@@ -130,22 +131,63 @@ create-claude-config
 
 - 🔍 **Auto-detection** - Automatically detects your project type
 - 🎯 **Framework-specific** - Includes framework-specific commands and configurations
+- 🔧 **Selective automation hooks** - Choose which automation features to enable
 - 💾 **Backup existing files** - Safely backs up existing CLAUDE.md and .claude directories
-- ⚙️ **Customizable** - Interactive prompts for feature selection
+- ⚙️ **Customizable** - Interactive prompts for command and hook selection
 - 🚀 **Quick setup** - Get started with Claude Code in seconds
 
+## 🔧 Automation Hooks
+
+The CLI allows you to selectively enable automation hooks that enhance your development workflow:
+
+### JavaScript/TypeScript Hooks
+- **Console.log Detection** - Prevents committing debug statements
+- **Prettier Auto-formatting** - Automatically formats code on save
+- **TypeScript Type Checking** - Validates types after each edit
+- **Import Validation** - Warns about performance-impacting wildcard imports
+- **Auto-testing** - Runs relevant tests when files change
+- **ESLint Integration** - Lints code before session ends
+
+### Python Hooks
+- **Print Statement Detection** - Warns about debug print statements
+- **Black Auto-formatting** - Formats Python code automatically
+- **Import Sorting** - Organizes imports with isort
+- **Flake8 Linting** - Checks code quality standards
+- **MyPy Type Checking** - Validates type hints
+- **Security Auditing** - Scans for vulnerabilities with bandit
+
+### Go Hooks
+- **Print Statement Detection** - Warns about fmt.Print statements
+- **Auto-formatting** - Formats code with gofmt and goimports
+- **Go Vet Analysis** - Runs static analysis checks
+- **Dependency Checking** - Lists and validates dependencies
+- **Auto-testing** - Runs tests for modified files
+
+### Rust Hooks
+- **Print Macro Detection** - Warns about println! statements
+- **Rustfmt Formatting** - Automatically formats Rust code
+- **Cargo Check** - Validates code compilation
+- **Clippy Linting** - Runs Rust's built-in linter
+- **Security Auditing** - Checks for vulnerable dependencies
+
 ## What Gets Installed
 
 ### Core Files
 - `CLAUDE.md` - Main configuration file for Claude Code
-- `.claude/settings.json` - Language-specific settings
+- `.claude/settings.json` - Language-specific settings with selected automation hooks
 - `.claude/commands/` - Custom commands for common tasks
-- `.claude/hooks/` - Automated hooks for development workflow
+
+### Automation Hooks
+Each language template includes selectable automation hooks for:
+- **PreToolUse**: Code quality checks before actions (e.g., detecting console.log statements)
+- **PostToolUse**: Automatic formatting and validation after edits (e.g., Prettier, ESLint, type checking)
+- **Stop**: Final checks before session ends (e.g., linting changed files, bundle analysis)
+- **Notification**: Logging and monitoring of Claude Code activities
 
 ### Language-Specific Commands
 Each language template includes optimized commands for:
-- Testing
-- Linting and formatting
+- Testing (Jest, pytest, Cargo test, Go test)
+- Linting and formatting (ESLint/Prettier, Black/flake8, clippy/rustfmt, gofmt/go vet)
 - Building and deployment
 - Debugging
 - Framework-specific operations
@@ -213,28 +255,40 @@ Target directory: /path/to/your/project
    - Shows relevant frameworks for your language
    - Auto-detected from dependencies
 
-4. **Feature Selection** ⚙️
+4. **Command Selection** 📋
    ```
-   ⚙️ Select additional features: 
+   📋 Select commands to include (use space to select):
    ◉ Enhanced testing commands
    ◉ Code linting and formatting  
    ◯ Git hooks integration
    ◯ Debugging helpers
    ```
 
-5. **Final Confirmation** 🚀
+5. **Hook Selection** 🔧
+   ```
+   🔧 Select automation hooks to include (use space to select):
+   ◉ PreToolUse: Block files containing console.log statements
+   ◉ PostToolUse: Auto-format JavaScript/TypeScript files with Prettier
+   ◉ PostToolUse: Run TypeScript type checking after edits
+   ◯ PostToolUse: Run tests automatically for modified files
+   ◉ Stop: Run ESLint on changed files before stopping
+   ```
+
+6. **Final Confirmation** 🚀
    ```
-   🚀 Setup Claude Code for javascript-typescript with react? (Y/n)
+   🚀 Setup Claude Code for javascript-typescript with react (5 commands) (9 hooks)? (Y/n)
    ```
-   - Review your choices
+   - Review your choices including selected commands and hooks
    - Type 'n' to cancel, 'y' or Enter to proceed
 
-6. **Installation** 📁
+7. **Installation** 📁
    ```
    📋 Existing CLAUDE.md backed up to CLAUDE.md.backup
    ✓ Copied javascript-typescript/CLAUDE.md → CLAUDE.md
-   ✓ Copied javascript-typescript/.claude → .claude
+   ✓ Copied javascript-typescript/.claude → .claude (with selected hooks)
    ✓ Copied react-specific commands → .claude/commands
+   📋 Installed 5 commands
+   🔧 Installed 9 automation hooks
    ✅ Claude Code configuration setup complete!
    ```
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-code-templates",
-  "version": "1.1.7",
-  "description": "CLI tool to setup Claude Code configurations for different programming languages",
+  "version": "1.2.0",
+  "description": "CLI tool to setup Claude Code configurations with selective automation hooks for different programming languages",
   "main": "src/index.js",
   "bin": {
     "create-claude-config": "bin/create-claude-config.js",
@@ -11,11 +11,19 @@
   },
   "scripts": {
     "start": "node bin/create-claude-config.js",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "./test-commands.sh",
+    "test:detailed": "./test-detailed.sh",
+    "test:react": "make test-react",
+    "test:vue": "make test-vue", 
+    "test:node": "make test-node",
+    "test:all": "make test",
+    "dev:link": "npm link",
+    "dev:unlink": "npm unlink -g claude-code-templates",
+    "pretest": "npm run dev:link",
     "sync": "node scripts/sync-templates.js",
     "presync": "echo \"🔄 Starting template synchronization...\"",
     "postsync": "echo \"✅ Synchronization completed. Ready to publish!\"",
-    "prepublishOnly": "npm run sync"
+    "prepublishOnly": "npm run sync && npm run test"
   },
   "keywords": [
     "claude",
@@ -24,7 +32,14 @@
     "configuration",
     "template",
     "setup",
-    "cli"
+    "cli",
+    "hooks",
+    "automation",
+    "javascript",
+    "typescript",
+    "python",
+    "rust",
+    "go"
   ],
   "author": "Claude Code Templates",
   "license": "MIT",

package/src/file-operations.js

@@ -1,6 +1,7 @@
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
+const { getHooksForLanguage, filterHooksBySelection } = require('./hook-scanner');
 
 async function copyTemplateFiles(templateConfig, targetDir) {
   const templateDir = path.join(__dirname, '../templates');
@@ -74,6 +75,10 @@ async function copyTemplateFiles(templateConfig, targetDir) {
         }
         
         console.log(chalk.green(`✓ Copied base configuration and commands ${file.source} → ${file.destination}`));
+      } else if (file.source.includes('settings.json') && templateConfig.selectedHooks) {
+        // Handle settings.json with hook filtering
+        await processSettingsFile(sourcePath, destPath, templateConfig);
+        console.log(chalk.green(`✓ Copied ${file.source} → ${file.destination} (with selected hooks)`));
       } else {
         // Copy regular files (CLAUDE.md, settings.json, etc.)
         await fs.copy(sourcePath, destPath, { 
@@ -111,6 +116,43 @@ async function copyTemplateFiles(templateConfig, targetDir) {
     
     console.log(chalk.cyan(`📋 Installed ${templateConfig.selectedCommands.length} commands`));
   }
+  
+  // Report hook selection
+  if (templateConfig.selectedHooks && templateConfig.selectedHooks.length > 0) {
+    console.log(chalk.magenta(`🔧 Installed ${templateConfig.selectedHooks.length} automation hooks`));
+  }
+}
+
+async function processSettingsFile(sourcePath, destPath, templateConfig) {
+  try {
+    // Read the original settings file
+    const originalSettings = JSON.parse(await fs.readFile(sourcePath, 'utf8'));
+    
+    // If hooks are selected, filter them
+    if (templateConfig.selectedHooks && templateConfig.selectedHooks.length > 0) {
+      const availableHooks = getHooksForLanguage(templateConfig.language);
+      const filteredSettings = filterHooksBySelection(
+        originalSettings,
+        templateConfig.selectedHooks,
+        availableHooks
+      );
+      
+      // Write the filtered settings
+      await fs.ensureDir(path.dirname(destPath));
+      await fs.writeFile(destPath, JSON.stringify(filteredSettings, null, 2));
+    } else {
+      // No hooks selected, copy original without hooks
+      const settingsWithoutHooks = { ...originalSettings };
+      delete settingsWithoutHooks.hooks;
+      
+      await fs.ensureDir(path.dirname(destPath));
+      await fs.writeFile(destPath, JSON.stringify(settingsWithoutHooks, null, 2));
+    }
+  } catch (error) {
+    console.error(chalk.red(`Failed to process settings file: ${error.message}`));
+    // Fallback to copying original file
+    await fs.copy(sourcePath, destPath);
+  }
 }
 
 async function ensureDirectoryExists(dirPath) {
@@ -137,5 +179,6 @@ async function checkWritePermissions(targetDir) {
 module.exports = {
   copyTemplateFiles,
   ensureDirectoryExists,
-  checkWritePermissions
+  checkWritePermissions,
+  processSettingsFile
 };

package/src/hook-scanner.js

@@ -0,0 +1,271 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Extracts and describes hooks from a settings.json file
+ * @param {string} settingsPath - Path to the settings.json file
+ * @returns {Array} Array of hook descriptions
+ */
+function getHooksFromSettings(settingsPath) {
+  if (!fs.existsSync(settingsPath)) {
+    return [];
+  }
+
+  try {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    const hooks = [];
+
+    if (settings.hooks) {
+      // Process PreToolUse hooks
+      if (settings.hooks.PreToolUse) {
+        settings.hooks.PreToolUse.forEach((hookGroup, index) => {
+          hookGroup.hooks.forEach((hook, hookIndex) => {
+            const hookId = `pre-${index}-${hookIndex}`;
+            const description = getHookDescription(hook, hookGroup.matcher, 'PreToolUse');
+            hooks.push({
+              id: hookId,
+              type: 'PreToolUse',
+              matcher: hookGroup.matcher,
+              description,
+              originalHook: hook,
+              originalGroup: hookGroup,
+              checked: true // Default to checked
+            });
+          });
+        });
+      }
+
+      // Process PostToolUse hooks
+      if (settings.hooks.PostToolUse) {
+        settings.hooks.PostToolUse.forEach((hookGroup, index) => {
+          hookGroup.hooks.forEach((hook, hookIndex) => {
+            const hookId = `post-${index}-${hookIndex}`;
+            const description = getHookDescription(hook, hookGroup.matcher, 'PostToolUse');
+            hooks.push({
+              id: hookId,
+              type: 'PostToolUse',
+              matcher: hookGroup.matcher,
+              description,
+              originalHook: hook,
+              originalGroup: hookGroup,
+              checked: true // Default to checked
+            });
+          });
+        });
+      }
+
+      // Process Notification hooks
+      if (settings.hooks.Notification) {
+        settings.hooks.Notification.forEach((hookGroup, index) => {
+          hookGroup.hooks.forEach((hook, hookIndex) => {
+            const hookId = `notification-${index}-${hookIndex}`;
+            const description = getHookDescription(hook, hookGroup.matcher, 'Notification');
+            hooks.push({
+              id: hookId,
+              type: 'Notification',
+              matcher: hookGroup.matcher,
+              description,
+              originalHook: hook,
+              originalGroup: hookGroup,
+              checked: false // Default to unchecked for notifications
+            });
+          });
+        });
+      }
+
+      // Process Stop hooks
+      if (settings.hooks.Stop) {
+        settings.hooks.Stop.forEach((hookGroup, index) => {
+          hookGroup.hooks.forEach((hook, hookIndex) => {
+            const hookId = `stop-${index}-${hookIndex}`;
+            const description = getHookDescription(hook, hookGroup.matcher, 'Stop');
+            hooks.push({
+              id: hookId,
+              type: 'Stop',
+              matcher: hookGroup.matcher,
+              description,
+              originalHook: hook,
+              originalGroup: hookGroup,
+              checked: true // Default to checked
+            });
+          });
+        });
+      }
+    }
+
+    return hooks;
+  } catch (error) {
+    console.error(`Error parsing settings file ${settingsPath}:`, error.message);
+    return [];
+  }
+}
+
+/**
+ * Generates a human-readable description for a hook
+ * @param {Object} hook - The hook object
+ * @param {string} matcher - The matcher pattern
+ * @param {string} type - The hook type
+ * @returns {string} Human-readable description
+ */
+function getHookDescription(hook, matcher, type) {
+  const command = hook.command || '';
+  
+  // Pre-defined descriptions for common hooks
+  const descriptions = {
+    // PreToolUse hooks
+    'jq -r': 'Log Bash commands to ~/.claude/bash-command-log.txt',
+    'console\\.log': 'Block files containing console.log statements',
+    'print(': 'Block Python files containing print statements',
+    'fmt.Print': 'Block Go files containing fmt.Print statements',
+    'println!': 'Block Rust files containing println! statements',
+    'npm audit': 'Check for vulnerable dependencies when modifying package.json',
+    'pip-audit': 'Check for vulnerable Python dependencies',
+    'cargo audit': 'Check for vulnerable Rust dependencies',
+    'go list': 'Check Go dependencies',
+    
+    // PostToolUse hooks
+    'prettier --write': 'Auto-format JavaScript/TypeScript files with Prettier',
+    'black': 'Auto-format Python files with Black',
+    'isort': 'Sort Python imports with isort',
+    'gofmt': 'Auto-format Go files with gofmt',
+    'goimports': 'Auto-format Go imports with goimports',
+    'rustfmt': 'Auto-format Rust files with rustfmt',
+    'tsc --noEmit': 'Run TypeScript type checking after edits',
+    'flake8': 'Run Python code quality checks with flake8',
+    'mypy': 'Run Python type checking with mypy',
+    'go vet': 'Run Go code analysis with go vet',
+    'cargo check': 'Run Rust code checking with cargo check',
+    'cargo clippy': 'Run Rust linting with clippy',
+    'import \\* from': 'Warn about wildcard imports (bad for tree-shaking)',
+    'npx jest': 'Run JavaScript/TypeScript tests automatically',
+    'pytest': 'Run Python tests automatically',
+    'go test': 'Run Go tests automatically',
+    'cargo test': 'Run Rust tests automatically',
+    
+    // Stop hooks
+    'eslint': 'Run ESLint on changed files before stopping',
+    'flake8.*git diff': 'Run Python linting on changed files',
+    'bandit': 'Run Python security analysis',
+    'go vet.*git diff': 'Run Go analysis on changed files',
+    'staticcheck': 'Run Go static analysis',
+    'cargo clippy.*git diff': 'Run Rust linting on changed files',
+    'bundlesize': 'Analyze bundle size impact of changes',
+    
+    // Notification hooks
+    'notifications.log': 'Log Claude Code notifications'
+  };
+
+  // Try to match command with known descriptions
+  for (const [pattern, description] of Object.entries(descriptions)) {
+    if (command.includes(pattern)) {
+      return description;
+    }
+  }
+
+  // Generate description based on command analysis
+  if (command.includes('eslint')) {
+    return 'Run ESLint linting';
+  } else if (command.includes('prettier')) {
+    return 'Format code with Prettier';
+  } else if (command.includes('tsc')) {
+    return 'TypeScript type checking';
+  } else if (command.includes('jest') || command.includes('vitest')) {
+    return 'Run tests automatically';
+  } else if (command.includes('audit')) {
+    return 'Security audit for dependencies';
+  } else if (command.includes('bundlesize') || command.includes('bundle')) {
+    return 'Bundle size analysis';
+  } else if (command.includes('console.log')) {
+    return 'Detect console.log statements';
+  } else if (command.includes('import')) {
+    return 'Import statement validation';
+  } else if (command.includes('log')) {
+    return 'Logging functionality';
+  } else {
+    // Fallback: use type and matcher
+    const matcherDesc = matcher || 'all tools';
+    return `${type} hook for ${matcherDesc}`;
+  }
+}
+
+/**
+ * Gets hooks for a specific language
+ * @param {string} language - The programming language
+ * @returns {Array} Array of available hooks for the language
+ */
+function getHooksForLanguage(language) {
+  const templateDir = path.join(__dirname, '..', 'templates', language);
+  const settingsPath = path.join(templateDir, '.claude', 'settings.json');
+  
+  return getHooksFromSettings(settingsPath);
+}
+
+/**
+ * Filters hooks based on user selection
+ * @param {Object} originalSettings - Original settings object
+ * @param {Array} selectedHookIds - Array of selected hook IDs
+ * @param {Array} availableHooks - Array of available hooks
+ * @returns {Object} Filtered settings object
+ */
+function filterHooksBySelection(originalSettings, selectedHookIds, availableHooks) {
+  if (!originalSettings.hooks) {
+    return originalSettings;
+  }
+
+  const filteredSettings = JSON.parse(JSON.stringify(originalSettings));
+  filteredSettings.hooks = {};
+
+  // Create a map of selected hooks for quick lookup
+  const selectedHooks = new Map();
+  availableHooks.forEach(hook => {
+    if (selectedHookIds.includes(hook.id)) {
+      selectedHooks.set(hook.id, hook);
+    }
+  });
+
+  // Group selected hooks by type
+  const hooksByType = {
+    PreToolUse: [],
+    PostToolUse: [],
+    Notification: [],
+    Stop: []
+  };
+
+  selectedHooks.forEach(hook => {
+    if (hooksByType[hook.type]) {
+      hooksByType[hook.type].push(hook);
+    }
+  });
+
+  // Rebuild hook structure
+  Object.keys(hooksByType).forEach(type => {
+    if (hooksByType[type].length > 0) {
+      filteredSettings.hooks[type] = [];
+      
+      // Group hooks by matcher and originalGroup
+      const groupMap = new Map();
+      
+      hooksByType[type].forEach(hook => {
+        const groupKey = `${hook.matcher}-${JSON.stringify(hook.originalGroup.matcher)}`;
+        if (!groupMap.has(groupKey)) {
+          groupMap.set(groupKey, {
+            matcher: hook.originalGroup.matcher,
+            hooks: []
+          });
+        }
+        groupMap.get(groupKey).hooks.push(hook.originalHook);
+      });
+      
+      filteredSettings.hooks[type] = Array.from(groupMap.values());
+    }
+  });
+
+  return filteredSettings;
+}
+
+module.exports = {
+  getHooksFromSettings,
+  getHooksForLanguage,
+  filterHooksBySelection,
+  getHookDescription
+};

package/src/index.js

@@ -7,6 +7,7 @@ const { detectProject } = require('./utils');
 const { getTemplateConfig } = require('./templates');
 const { createPrompts, interactivePrompts } = require('./prompts');
 const { copyTemplateFiles } = require('./file-operations');
+const { getHooksForLanguage } = require('./hook-scanner');
 
 async function createClaudeConfig(options = {}) {
   const targetDir = options.directory || process.cwd();
@@ -22,10 +23,15 @@ async function createClaudeConfig(options = {}) {
   let config;
   if (options.yes) {
     // Use defaults
+    const selectedLanguage = options.language || projectInfo.detectedLanguage || 'common';
+    const availableHooks = getHooksForLanguage(selectedLanguage);
+    const defaultHooks = availableHooks.filter(hook => hook.checked).map(hook => hook.id);
+    
     config = {
-      language: options.language || projectInfo.detectedLanguage || 'common',
+      language: selectedLanguage,
       framework: options.framework || projectInfo.detectedFramework || 'none',
-      features: []
+      features: [],
+      hooks: defaultHooks
     };
   } else {
     // Interactive prompts with back navigation
@@ -41,6 +47,12 @@ async function createClaudeConfig(options = {}) {
   // Get template configuration
   const templateConfig = getTemplateConfig(config);
   
+  // Add selected hooks to template config
+  if (config.hooks) {
+    templateConfig.selectedHooks = config.hooks;
+    templateConfig.language = config.language; // Ensure language is available for hook filtering
+  }
+  
   if (options.dryRun) {
     console.log(chalk.yellow('🔍 Dry run - showing what would be copied:'));
     templateConfig.files.forEach(file => {
@@ -73,6 +85,10 @@ async function createClaudeConfig(options = {}) {
   if (config.framework !== 'none') {
     console.log(chalk.yellow(`🎯 Framework-specific commands for ${config.framework} are available`));
   }
+  
+  if (config.hooks && config.hooks.length > 0) {
+    console.log(chalk.magenta(`🔧 ${config.hooks.length} automation hooks have been configured`));
+  }
 }
 
 module.exports = createClaudeConfig;

package/src/prompts.js

@@ -13,6 +13,7 @@ class CustomCheckboxPrompt extends inquirer.prompt.prompts.checkbox {
 inquirer.registerPrompt('checkbox', CustomCheckboxPrompt);
 const { getAvailableLanguages, getFrameworksForLanguage } = require('./templates');
 const { getCommandsForLanguageAndFramework } = require('./command-scanner');
+const { getHooksForLanguage } = require('./hook-scanner');
 
 async function interactivePrompts(projectInfo, options = {}) {
   const state = {
@@ -24,7 +25,7 @@ async function interactivePrompts(projectInfo, options = {}) {
   // Build steps array based on options
   if (!options.language) state.steps.push('language');
   if (!options.framework) state.steps.push('framework');
-  state.steps.push('commands', 'confirm');
+  state.steps.push('commands', 'hooks', 'confirm');
 
   while (state.currentStep < state.steps.length) {
     const stepName = state.steps[state.currentStep];
@@ -143,10 +144,37 @@ function getStepConfig(stepName, currentAnswers, projectInfo, options) {
         pageSize: 10
       };
 
+    case 'hooks':
+      const hookLanguage = currentAnswers.language || options.language;
+      
+      if (!hookLanguage || hookLanguage === 'common') {
+        return null; // Skip hooks selection for common templates
+      }
+      
+      const availableHooks = getHooksForLanguage(hookLanguage);
+      
+      if (availableHooks.length === 0) {
+        return null; // Skip if no hooks available
+      }
+      
+      return {
+        type: 'checkbox',
+        name: 'hooks',
+        message: 'Select automation hooks to include (use space to select):',
+        choices: availableHooks.map(hook => ({
+          value: hook.id,
+          name: `${hook.type}: ${hook.description}`,
+          checked: hook.checked
+        })),
+        prefix: chalk.magenta('🔧'),
+        pageSize: 15
+      };
+
     case 'confirm':
       const confirmLanguage = currentAnswers.language || options.language || 'common';
       const confirmFramework = currentAnswers.framework || options.framework || 'none';
       const commandCount = currentAnswers.commands ? currentAnswers.commands.length : 0;
+      const hookCount = currentAnswers.hooks ? currentAnswers.hooks.length : 0;
       
       let message = `Setup Claude Code for ${chalk.cyan(confirmLanguage)}`;
       if (confirmFramework !== 'none') {
@@ -155,6 +183,9 @@ function getStepConfig(stepName, currentAnswers, projectInfo, options) {
       if (commandCount > 0) {
         message += ` (${chalk.yellow(commandCount)} commands)`;
       }
+      if (hookCount > 0) {
+        message += ` (${chalk.magenta(hookCount)} hooks)`;
+      }
       message += '?';
       
       return {
@@ -250,6 +281,37 @@ function createPrompts(projectInfo, options = {}) {
     }
   });
 
+  // Hook selection
+  prompts.push({
+    type: 'checkbox',
+    name: 'hooks',
+    message: 'Select automation hooks to include (use space to select):',
+    choices: (answers) => {
+      const selectedLanguage = answers.language || options.language;
+      
+      if (!selectedLanguage || selectedLanguage === 'common') {
+        return [];
+      }
+      
+      const availableHooks = getHooksForLanguage(selectedLanguage);
+      
+      return availableHooks.map(hook => ({
+        value: hook.id,
+        name: `${hook.type}: ${hook.description}`,
+        checked: hook.checked
+      }));
+    },
+    prefix: chalk.magenta('🔧'),
+    pageSize: 15,
+    when: (answers) => {
+      const selectedLanguage = answers.language || options.language;
+      if (!selectedLanguage || selectedLanguage === 'common') {
+        return false;
+      }
+      const availableHooks = getHooksForLanguage(selectedLanguage);
+      return availableHooks.length > 0;
+    }
+  });
   
   // Confirmation
   prompts.push({
@@ -259,6 +321,7 @@ function createPrompts(projectInfo, options = {}) {
       const language = answers.language || options.language || 'common';
       const framework = answers.framework || options.framework || 'none';
       const commandCount = answers.commands ? answers.commands.length : 0;
+      const hookCount = answers.hooks ? answers.hooks.length : 0;
       
       let message = `Setup Claude Code for ${chalk.cyan(language)}`;
       if (framework !== 'none') {
@@ -267,6 +330,9 @@ function createPrompts(projectInfo, options = {}) {
       if (commandCount > 0) {
         message += ` (${chalk.yellow(commandCount)} commands)`;
       }
+      if (hookCount > 0) {
+        message += ` (${chalk.magenta(hookCount)} hooks)`;
+      }
       message += '?';
       
       return message;

package/src/templates.js

@@ -47,30 +47,27 @@ const TEMPLATES_CONFIG = {
   },
   'python': {
     name: 'Python',
-    description: 'Configuration for Python projects (Coming Soon)',
+    description: 'Optimized for Python development',
     files: [
-      { source: 'common/CLAUDE.md', destination: 'CLAUDE.md' },
-      { source: 'common/.claude', destination: '.claude' }
-    ],
-    comingSoon: true
+      { source: 'python/CLAUDE.md', destination: 'CLAUDE.md' },
+      { source: 'python/.claude', destination: '.claude' }
+    ]
   },
   'rust': {
     name: 'Rust',
-    description: 'Configuration for Rust projects (Coming Soon)',
+    description: 'Optimized for Rust development',
     files: [
-      { source: 'common/CLAUDE.md', destination: 'CLAUDE.md' },
-      { source: 'common/.claude', destination: '.claude' }
-    ],
-    comingSoon: true
+      { source: 'rust/CLAUDE.md', destination: 'CLAUDE.md' },
+      { source: 'rust/.claude', destination: '.claude' }
+    ]
   },
   'go': {
     name: 'Go',
-    description: 'Configuration for Go projects (Coming Soon)',
+    description: 'Optimized for Go development',
     files: [
-      { source: 'common/CLAUDE.md', destination: 'CLAUDE.md' },
-      { source: 'common/.claude', destination: '.claude' }
-    ],
-    comingSoon: true
+      { source: 'go/CLAUDE.md', destination: 'CLAUDE.md' },
+      { source: 'go/.claude', destination: '.claude' }
+    ]
   }
 };
 

package/templates/javascript-typescript/.claude/settings.json

@@ -26,8 +26,8 @@
     "defaultMode": "allowEdits"
   },
   "env": {
-    "BASH_DEFAULT_TIMEOUT_MS": "30000",
-    "BASH_MAX_OUTPUT_LENGTH": "10000",
+    "BASH_DEFAULT_TIMEOUT_MS": "60000",
+    "BASH_MAX_OUTPUT_LENGTH": "20000",
     "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR": "1",
     "NODE_ENV": "development"
   },
@@ -49,7 +49,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [[ \"$(echo $STDIN_JSON | jq -r '.tool_input.file_path' | grep -E '\\.js$|\\.jsx$|\\.ts$|\\.tsx$')\" != \"\" && $(echo $STDIN_JSON | jq -r '.tool_input.content' | grep -E 'console\\.log') != \"\" ]]; then echo 'Warning: console.log statements should be removed before committing' >&2; exit 2; fi"
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"); CONTENT=$(echo $STDIN_JSON | jq -r '.tool_input.content // \"\"); if [[ \"$FILE\" =~ \\.(js|jsx|ts|tsx)$ ]] && echo \"$CONTENT\" | grep -q 'console\\.log'; then echo 'Warning: console.log statements should be removed before committing' >&2; exit 2; fi"
           }
         ]
       },
@@ -58,7 +58,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" == \"package.json\" ]]; then echo 'Checking for vulnerable dependencies...'; npx audit-ci --moderate; fi",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" == \"package.json\" ]]; then echo 'Checking for vulnerable dependencies...'; npm audit --audit-level=moderate; fi",
             "timeout": 60
           }
         ]
@@ -90,7 +90,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.(ts|tsx)$ ]] && grep -q 'import.*from.*\\*' \"$FILE\"; then echo 'Warning: Avoid wildcard imports for better tree-shaking' >&2; exit 2; fi"
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.(js|jsx|ts|tsx)$ ]] && grep -q 'import \\* from' \"$FILE\"; then echo 'Warning: Avoid wildcard imports for better tree-shaking' >&2; exit 2; fi"
           }
         ]
       },
@@ -99,7 +99,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.(js|jsx|ts|tsx)$ && \"$FILE\" != *\".test.\"* && \"$FILE\" != *\".spec.\"* ]]; then TEST_FILE=$(echo \"$FILE\" | sed -E 's/\\.(js|jsx|ts|tsx)$/.test.\\1/'); if [ -f \"$TEST_FILE\" ]; then echo \"Running tests for modified file...\"; npx jest \"$TEST_FILE\" --passWithNoTests; fi; fi",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.(js|jsx|ts|tsx)$ && \"$FILE\" != *\".test.\"* && \"$FILE\" != *\".spec.\"* ]]; then DIR=$(dirname \"$FILE\"); BASENAME=$(basename \"$FILE\" | sed -E 's/\\.(js|jsx|ts|tsx)$//'); for TEST_FILE in \"$DIR/$BASENAME.test.\"* \"$DIR/$BASENAME.spec.\"*; do if [ -f \"$TEST_FILE\" ]; then echo \"Running tests for $TEST_FILE...\"; if command -v jest >/dev/null 2>&1; then npx jest \"$TEST_FILE\" --passWithNoTests; elif command -v vitest >/dev/null 2>&1; then npx vitest run \"$TEST_FILE\"; fi; break; fi; done; fi",
             "timeout": 60
           }
         ]
@@ -132,7 +132,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [[ -f package.json && $(git status --porcelain | grep -E '\\.js$|\\.jsx$|\\.ts$|\\.tsx$') ]]; then echo 'Analyzing bundle size impact...'; npx bundlesize; fi",
+            "command": "if [[ -f package.json && $(git status --porcelain | grep -E '\\.js$|\\.jsx$|\\.ts$|\\.tsx$') ]]; then echo 'Analyzing bundle size impact...'; if command -v bundlesize >/dev/null 2>&1; then npx bundlesize; elif npm list webpack-bundle-analyzer >/dev/null 2>&1; then echo 'Use: npx webpack-bundle-analyzer build/static/js/*.js'; else echo 'No bundle analysis tool found'; fi; fi",
             "timeout": 60
           }
         ]