claude-code-templates 1.0.0

package/README.md

@@ -0,0 +1,291 @@
+# Claude Code Templates Installer
+
+A CLI tool to quickly setup Claude Code configurations for different programming languages and frameworks. No installation required - just use `npx`!
+
+## 🚀 Quick Start
+
+The fastest way to get started is with `npx` (no installation required):
+
+```bash
+# Navigate to your project directory
+cd your-project
+
+# Run the installer
+npx create-claude-config
+```
+
+## 📋 How to Use
+
+### Step 1: Navigate to Your Project
+```bash
+cd your-project-directory
+```
+
+### Step 2: Run the Installer
+```bash
+npx create-claude-config
+```
+
+### Step 3: Follow the Interactive Setup
+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**
+
+### Step 4: Start Using Claude Code
+```bash
+claude
+```
+
+## 💡 Usage Examples
+
+### Interactive Setup (Recommended)
+```bash
+cd my-react-app
+npx create-claude-config
+# Follow the prompts - it will detect React automatically!
+```
+
+### Quick Setup for Specific Languages
+```bash
+# React project
+cd my-react-app
+npx create-claude-config --language javascript-typescript --framework react
+
+# Python Django project  
+cd my-django-app
+npx create-claude-config --language python --framework django
+
+# Node.js API
+cd my-api
+npx create-claude-config --language javascript-typescript --framework node
+
+# Generic Python project
+cd my-python-project
+npx create-claude-config --language python
+```
+
+### Advanced Options
+```bash
+# Skip all prompts and use defaults
+npx create-claude-config --yes
+
+# See what would be installed without actually installing
+npx create-claude-config --dry-run
+
+# Install to a different directory
+npx create-claude-config --directory /path/to/project
+
+# Get help
+npx create-claude-config --help
+```
+
+## 🔄 Alternative Commands
+
+All these commands work exactly the same way:
+```bash
+npx create-claude-config     # ✅ Recommended (follows npm convention)
+npx claude-code-templates    # Package name
+npx claude-init              # Short alias
+```
+
+## ⚡ No Installation Required
+
+**Why use `npx`?**
+- ✅ Always gets the latest version
+- ✅ No global installation needed
+- ✅ Works on any machine with Node.js
+- ✅ Follows npm best practices
+
+If you prefer global installation:
+```bash
+npm install -g claude-code-templates
+create-claude-config
+```
+
+## Supported Languages
+
+- **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
+
+## Supported Frameworks
+
+### JavaScript/TypeScript
+- React
+- Vue.js
+- Angular
+- Node.js
+
+### Python
+- Django
+- Flask
+- FastAPI
+
+## Features
+
+- 🔍 **Auto-detection** - Automatically detects your project type
+- 🎯 **Framework-specific** - Includes framework-specific commands and configurations
+- 💾 **Backup existing files** - Safely backs up existing CLAUDE.md and .claude directories
+- ⚙️ **Customizable** - Interactive prompts for feature selection
+- 🚀 **Quick setup** - Get started with Claude Code in seconds
+
+## What Gets Installed
+
+### Core Files
+- `CLAUDE.md` - Main configuration file for Claude Code
+- `.claude/settings.json` - Language-specific settings
+- `.claude/commands/` - Custom commands for common tasks
+- `.claude/hooks/` - Automated hooks for development workflow
+
+### Language-Specific Commands
+Each language template includes optimized commands for:
+- Testing
+- Linting and formatting
+- Building and deployment
+- Debugging
+- Framework-specific operations
+
+## 📱 What Happens During Setup
+
+### Interactive Experience
+```bash
+$ npx create-claude-config
+
+ ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗
+██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝
+██║     ██║     ███████║██║   ██║██║  ██║█████╗  
+██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝  
+╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗
+ ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝
+
+ ██████╗ ██████╗ ██████╗ ███████╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝
+██║     ██║   ██║██║  ██║█████╗  
+██║     ██║   ██║██║  ██║██╔══╝  
+╚██████╗╚██████╔╝██████╔╝███████╗
+ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
+
+████████╗███████╗███╗   ███╗██████╗ ██╗      █████╗ ████████╗███████╗███████╗
+╚══██╔══╝██╔════╝████╗ ████║██╔══██╗██║     ██╔══██╗╚══██╔══╝██╔════╝██╔════╝
+   ██║   █████╗  ██╔████╔██║██████╔╝██║     ███████║   ██║   █████╗  ███████╗
+   ██║   ██╔══╝  ██║╚██╔╝██║██╔═══╝ ██║     ██╔══██║   ██║   ██╔══╝  ╚════██║
+   ██║   ███████╗██║ ╚═╝ ██║██║     ███████╗██║  ██║   ██║   ███████╗███████║
+   ╚═╝   ╚══════╝╚═╝     ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝
+
+                    🚀 Setup Claude Code for any project language 🚀
+
+🚀 Setting up Claude Code configuration...
+Target directory: /path/to/your/project
+✔ Project detection complete
+🔤 Select your programming language: (Use arrow keys)
+❯ JavaScript/TypeScript
+  Python  
+  Common (Language-agnostic)
+  Rust (Coming Soon)
+  Go (Coming Soon)
+```
+
+### Step-by-Step Walkthrough
+
+1. **Project Detection** 📡
+   ```
+   ✔ Project detection complete
+   ```
+   - Scans your project for `package.json`, `requirements.txt`, etc.
+   - Auto-suggests the best language template
+
+2. **Language Selection** 🔤
+   ```
+   🔤 Select your programming language: JavaScript/TypeScript
+   ```
+   - Choose from available languages
+   - Auto-selected based on detection
+
+3. **Framework Selection** 🎯
+   ```
+   🎯 Select your framework (optional): React
+   ```
+   - Shows relevant frameworks for your language
+   - Auto-detected from dependencies
+
+4. **Feature Selection** ⚙️
+   ```
+   ⚙️ Select additional features: 
+   ◉ Enhanced testing commands
+   ◉ Code linting and formatting  
+   ◯ Git hooks integration
+   ◯ Debugging helpers
+   ```
+
+5. **Final Confirmation** 🚀
+   ```
+   🚀 Setup Claude Code for javascript-typescript with react? (Y/n)
+   ```
+   - Review your choices
+   - Type 'n' to cancel, 'y' or Enter to proceed
+
+6. **Installation** 📁
+   ```
+   📋 Existing CLAUDE.md backed up to CLAUDE.md.backup
+   ✓ Copied javascript-typescript/CLAUDE.md → CLAUDE.md
+   ✓ Copied javascript-typescript/.claude → .claude
+   ✓ Copied react-specific commands → .claude/commands
+   ✅ Claude Code configuration setup complete!
+   ```
+
+## 🛡️ Safe Installation
+
+- **Backup Protection**: Existing files are safely backed up
+- **Confirmation Required**: Always asks before making changes  
+- **Dry Run Option**: Preview changes with `--dry-run`
+- **Cancel Anytime**: Press Ctrl+C or answer 'No' to cancel
+
+## CLI Options
+
+| Option | Description | Example |
+|--------|-------------|---------|
+| `-l, --language` | Specify programming language | `--language python` |
+| `-f, --framework` | Specify framework | `--framework react` |
+| `-d, --directory` | Target directory | `--directory /path/to/project` |
+| `-y, --yes` | Skip prompts and use defaults | `--yes` |
+| `--dry-run` | Show what would be copied | `--dry-run` |
+| `--help` | Show help information | `--help` |
+
+## Development
+
+### Setup
+```bash
+git clone https://github.com/your-username/claude-code-templates.git
+cd claude-code-templates/cli-tool
+npm install
+```
+
+### Testing
+```bash
+# Test locally
+npm start
+
+# Test with specific options
+npm start -- --language python --framework django
+```
+
+### Publishing
+```bash
+npm publish
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test thoroughly
+5. Submit a pull request
+
+## License
+
+MIT License

package/bin/create-claude-config.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const boxen = require('boxen');
+const createClaudeConfig = require('../src/index');
+
+// ASCII Art for Claude Code Templates
+const banner = chalk.cyan(`
+ ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗
+██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝
+██║     ██║     ███████║██║   ██║██║  ██║█████╗  
+██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝  
+╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗
+ ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝
+
+ ██████╗ ██████╗ ██████╗ ███████╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝
+██║     ██║   ██║██║  ██║█████╗  
+██║     ██║   ██║██║  ██║██╔══╝  
+╚██████╗╚██████╔╝██████╔╝███████╗
+ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
+
+████████╗███████╗███╗   ███╗██████╗ ██╗      █████╗ ████████╗███████╗███████╗
+╚══██╔══╝██╔════╝████╗ ████║██╔══██╗██║     ██╔══██╗╚══██╔══╝██╔════╝██╔════╝
+   ██║   █████╗  ██╔████╔██║██████╔╝██║     ███████║   ██║   █████╗  ███████╗
+   ██║   ██╔══╝  ██║╚██╔╝██║██╔═══╝ ██║     ██╔══██║   ██║   ██╔══╝  ╚════██║
+   ██║   ███████╗██║ ╚═╝ ██║██║     ███████╗██║  ██║   ██║   ███████╗███████║
+   ╚═╝   ╚══════╝╚═╝     ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝
+`) + chalk.yellow(`
+                    🚀 Setup Claude Code for any project language 🚀
+`);
+
+console.log(banner);
+
+program
+  .name('create-claude-config')
+  .description('Setup Claude Code configurations for different programming languages')
+  .version('1.0.0')
+  .option('-l, --language <language>', 'specify programming language')
+  .option('-f, --framework <framework>', 'specify framework')
+  .option('-d, --directory <directory>', 'target directory (default: current directory)')
+  .option('-y, --yes', 'skip prompts and use defaults')
+  .option('--dry-run', 'show what would be copied without actually copying')
+  .action(async (options) => {
+    try {
+      await createClaudeConfig(options);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);
+
+// Show help if no arguments provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "claude-code-templates",
+  "version": "1.0.0",
+  "description": "CLI tool to setup Claude Code configurations for different programming languages",
+  "main": "src/index.js",
+  "bin": {
+    "create-claude-config": "bin/create-claude-config.js",
+    "claude-code-templates": "bin/create-claude-config.js",
+    "claude-init": "bin/create-claude-config.js"
+  },
+  "scripts": {
+    "start": "node bin/create-claude-config.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "configuration",
+    "template",
+    "setup",
+    "cli"
+  ],
+  "author": "Claude Code Templates",
+  "license": "MIT",
+  "dependencies": {
+    "inquirer": "^8.2.6",
+    "chalk": "^4.1.2",
+    "fs-extra": "^11.1.1",
+    "commander": "^11.1.0",
+    "ora": "^5.4.1",
+    "boxen": "^5.1.2"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/danipower/claude-code-templates.git"
+  },
+  "bugs": {
+    "url": "https://github.com/danipower/claude-code-templates/issues"
+  },
+  "homepage": "https://github.com/danipower/claude-code-templates#readme",
+  "files": [
+    "bin/",
+    "src/",
+    "templates/",
+    "README.md"
+  ]
+}

package/src/file-operations.js

@@ -0,0 +1,66 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+async function copyTemplateFiles(templateConfig, targetDir) {
+  const templateDir = path.join(__dirname, '../templates');
+  
+  // Check if CLAUDE.md already exists
+  const claudeFile = path.join(targetDir, 'CLAUDE.md');
+  if (await fs.pathExists(claudeFile)) {
+    // Create backup
+    const backupFile = path.join(targetDir, 'CLAUDE.md.backup');
+    await fs.copy(claudeFile, backupFile);
+    console.log(chalk.yellow(`📋 Existing CLAUDE.md backed up to CLAUDE.md.backup`));
+  }
+  
+  // Check if .claude directory already exists
+  const claudeDir = path.join(targetDir, '.claude');
+  if (await fs.pathExists(claudeDir)) {
+    // Create backup
+    const backupDir = path.join(targetDir, '.claude.backup');
+    await fs.copy(claudeDir, backupDir);
+    console.log(chalk.yellow(`📁 Existing .claude directory backed up to .claude.backup`));
+  }
+  
+  // Copy files
+  for (const file of templateConfig.files) {
+    const sourcePath = path.join(templateDir, file.source);
+    const destPath = path.join(targetDir, file.destination);
+    
+    try {
+      await fs.copy(sourcePath, destPath, { overwrite: true });
+      console.log(chalk.green(`✓ Copied ${file.source} → ${file.destination}`));
+    } catch (error) {
+      console.error(chalk.red(`✗ Failed to copy ${file.source}:`), error.message);
+      throw error;
+    }
+  }
+}
+
+async function ensureDirectoryExists(dirPath) {
+  try {
+    await fs.ensureDir(dirPath);
+    return true;
+  } catch (error) {
+    console.error(chalk.red(`Failed to create directory ${dirPath}:`), error.message);
+    return false;
+  }
+}
+
+async function checkWritePermissions(targetDir) {
+  try {
+    const testFile = path.join(targetDir, '.claude-test-write');
+    await fs.writeFile(testFile, 'test');
+    await fs.remove(testFile);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = {
+  copyTemplateFiles,
+  ensureDirectoryExists,
+  checkWritePermissions
+};

package/src/index.js

@@ -0,0 +1,81 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const ora = require('ora');
+const { detectProject } = require('./utils');
+const { getTemplateConfig } = require('./templates');
+const { createPrompts } = require('./prompts');
+const { copyTemplateFiles } = require('./file-operations');
+
+async function createClaudeConfig(options = {}) {
+  const targetDir = options.directory || process.cwd();
+  
+  console.log(chalk.blue('🚀 Setting up Claude Code configuration...'));
+  console.log(chalk.gray(`Target directory: ${targetDir}`));
+  
+  // Detect existing project
+  const spinner = ora('Detecting project type...').start();
+  const projectInfo = await detectProject(targetDir);
+  spinner.succeed('Project detection complete');
+  
+  // Create interactive prompts
+  const prompts = createPrompts(projectInfo, options);
+  
+  let config;
+  if (options.yes) {
+    // Use defaults
+    config = {
+      language: options.language || projectInfo.detectedLanguage || 'common',
+      framework: options.framework || projectInfo.detectedFramework || 'none',
+      features: []
+    };
+  } else {
+    // Interactive prompts
+    config = await inquirer.prompt(prompts);
+  }
+  
+  // Check if user confirmed the setup
+  if (config.confirm === false) {
+    console.log(chalk.yellow('⏹️  Setup cancelled by user.'));
+    return;
+  }
+  
+  // Get template configuration
+  const templateConfig = getTemplateConfig(config);
+  
+  if (options.dryRun) {
+    console.log(chalk.yellow('🔍 Dry run - showing what would be copied:'));
+    templateConfig.files.forEach(file => {
+      console.log(chalk.gray(`  - ${file.source} → ${file.destination}`));
+    });
+    return;
+  }
+  
+  // Copy template files
+  const copySpinner = ora('Copying template files...').start();
+  try {
+    await copyTemplateFiles(templateConfig, targetDir);
+    copySpinner.succeed('Template files copied successfully');
+  } catch (error) {
+    copySpinner.fail('Failed to copy template files');
+    throw error;
+  }
+  
+  // Show success message
+  console.log(chalk.green('✅ Claude Code configuration setup complete!'));
+  console.log(chalk.cyan('📚 Next steps:'));
+  console.log(chalk.white('  1. Review the generated CLAUDE.md file'));
+  console.log(chalk.white('  2. Customize the configuration for your project'));
+  console.log(chalk.white('  3. Start using Claude Code with: claude'));
+  
+  if (config.language !== 'common') {
+    console.log(chalk.yellow(`💡 Language-specific features for ${config.language} have been configured`));
+  }
+  
+  if (config.framework !== 'none') {
+    console.log(chalk.yellow(`🎯 Framework-specific commands for ${config.framework} are available`));
+  }
+}
+
+module.exports = createClaudeConfig;

package/src/prompts.js

@@ -0,0 +1,110 @@
+const chalk = require('chalk');
+const { getAvailableLanguages, getFrameworksForLanguage } = require('./templates');
+
+function createPrompts(projectInfo, options = {}) {
+  const prompts = [];
+  
+  // Language selection
+  if (!options.language) {
+    const languages = getAvailableLanguages();
+    prompts.push({
+      type: 'list',
+      name: 'language',
+      message: 'Select your programming language:',
+      choices: languages,
+      default: projectInfo.detectedLanguage || 'common',
+      prefix: chalk.blue('🔤')
+    });
+  }
+  
+  // Framework selection (conditional)
+  if (!options.framework) {
+    prompts.push({
+      type: 'list',
+      name: 'framework',
+      message: 'Select your framework (optional):',
+      choices: (answers) => {
+        const selectedLanguage = answers.language || options.language;
+        const frameworks = getFrameworksForLanguage(selectedLanguage);
+        return [
+          { value: 'none', name: 'None / Generic' },
+          ...frameworks
+        ];
+      },
+      default: projectInfo.detectedFramework || 'none',
+      prefix: chalk.green('🎯'),
+      when: (answers) => {
+        const selectedLanguage = answers.language || options.language;
+        const frameworks = getFrameworksForLanguage(selectedLanguage);
+        return frameworks.length > 0;
+      }
+    });
+  }
+  
+  // Features selection
+  prompts.push({
+    type: 'checkbox',
+    name: 'features',
+    message: 'Select additional features:',
+    choices: [
+      {
+        value: 'git-hooks',
+        name: 'Git hooks integration',
+        checked: false
+      },
+      {
+        value: 'testing',
+        name: 'Enhanced testing commands',
+        checked: true
+      },
+      {
+        value: 'linting',
+        name: 'Code linting and formatting',
+        checked: true
+      },
+      {
+        value: 'debugging',
+        name: 'Debugging helpers',
+        checked: false
+      }
+    ],
+    prefix: chalk.yellow('⚙️')
+  });
+  
+  // Confirmation
+  prompts.push({
+    type: 'confirm',
+    name: 'confirm',
+    message: (answers) => {
+      const language = answers.language || options.language || 'common';
+      const framework = answers.framework || options.framework || 'none';
+      return `Setup Claude Code for ${chalk.cyan(language)}${framework !== 'none' ? ` with ${chalk.green(framework)}` : ''}?`;
+    },
+    default: true,
+    prefix: chalk.red('🚀')
+  });
+  
+  return prompts;
+}
+
+function createProjectTypePrompt(detectedTypes) {
+  if (detectedTypes.length === 0) {
+    return null;
+  }
+  
+  return {
+    type: 'list',
+    name: 'projectType',
+    message: 'We detected multiple project types. Which one should we prioritize?',
+    choices: detectedTypes.map(type => ({
+      value: type.language,
+      name: `${type.language} (${type.confidence}% confidence)`
+    })),
+    prefix: chalk.magenta('🔍')
+  };
+}
+
+module.exports = {
+  createPrompts,
+  createProjectTypePrompt
+};