claude-code-templates 1.0.0

package/src/templates.js

@@ -0,0 +1,134 @@
+const path = require('path');
+
+const TEMPLATES_CONFIG = {
+  'common': {
+    name: 'Common (Language-agnostic)',
+    description: 'Universal configuration for any project',
+    files: [
+      { source: 'common/CLAUDE.md', destination: 'CLAUDE.md' },
+      { source: 'common/.claude', destination: '.claude' }
+    ]
+  },
+  'javascript-typescript': {
+    name: 'JavaScript/TypeScript',
+    description: 'Optimized for modern JS/TS development',
+    files: [
+      { source: 'javascript-typescript/CLAUDE.md', destination: 'CLAUDE.md' },
+      { source: 'javascript-typescript/.claude', destination: '.claude' }
+    ],
+    frameworks: {
+      'react': {
+        name: 'React',
+        additionalFiles: [
+          { source: 'javascript-typescript/examples/react-app/.claude/commands', destination: '.claude/commands' }
+        ]
+      },
+      'vue': {
+        name: 'Vue.js',
+        additionalFiles: []
+      },
+      'angular': {
+        name: 'Angular',
+        additionalFiles: []
+      },
+      'node': {
+        name: 'Node.js',
+        additionalFiles: [
+          { source: 'javascript-typescript/examples/node-api/.claude/commands', destination: '.claude/commands' }
+        ]
+      }
+    }
+  },
+  'python': {
+    name: 'Python',
+    description: 'Optimized for Python development',
+    files: [
+      { source: 'python/CLAUDE.md', destination: 'CLAUDE.md' },
+      { source: 'python/.claude', destination: '.claude' }
+    ],
+    frameworks: {
+      'django': {
+        name: 'Django',
+        additionalFiles: []
+      },
+      'flask': {
+        name: 'Flask',
+        additionalFiles: []
+      },
+      'fastapi': {
+        name: 'FastAPI',
+        additionalFiles: []
+      }
+    }
+  },
+  'rust': {
+    name: 'Rust',
+    description: 'Configuration for Rust projects (Coming Soon)',
+    files: [
+      { source: 'common/CLAUDE.md', destination: 'CLAUDE.md' },
+      { source: 'common/.claude', destination: '.claude' }
+    ],
+    comingSoon: true
+  },
+  'go': {
+    name: 'Go',
+    description: 'Configuration for Go projects (Coming Soon)',
+    files: [
+      { source: 'common/CLAUDE.md', destination: 'CLAUDE.md' },
+      { source: 'common/.claude', destination: '.claude' }
+    ],
+    comingSoon: true
+  }
+};
+
+function getAvailableLanguages() {
+  return Object.keys(TEMPLATES_CONFIG).map(key => ({
+    value: key,
+    name: TEMPLATES_CONFIG[key].name,
+    description: TEMPLATES_CONFIG[key].description,
+    disabled: TEMPLATES_CONFIG[key].comingSoon ? 'Coming Soon' : false
+  }));
+}
+
+function getFrameworksForLanguage(language) {
+  const config = TEMPLATES_CONFIG[language];
+  if (!config || !config.frameworks) return [];
+  
+  return Object.keys(config.frameworks).map(key => ({
+    value: key,
+    name: config.frameworks[key].name
+  }));
+}
+
+function getTemplateConfig(selections) {
+  const { language, framework } = selections;
+  const baseConfig = TEMPLATES_CONFIG[language];
+  
+  if (!baseConfig) {
+    throw new Error(`Unknown language template: ${language}`);
+  }
+  
+  let files = [...baseConfig.files];
+  
+  // Add framework-specific files
+  if (framework && framework !== 'none' && baseConfig.frameworks && baseConfig.frameworks[framework]) {
+    const frameworkConfig = baseConfig.frameworks[framework];
+    if (frameworkConfig.additionalFiles) {
+      files = files.concat(frameworkConfig.additionalFiles);
+    }
+  }
+  
+  return {
+    language,
+    framework,
+    files,
+    config: baseConfig
+  };
+}
+
+module.exports = {
+  TEMPLATES_CONFIG,
+  getAvailableLanguages,
+  getFrameworksForLanguage,
+  getTemplateConfig
+};

package/src/utils.js

@@ -0,0 +1,172 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+async function detectProject(targetDir) {
+  const detectedLanguages = [];
+  const detectedFrameworks = [];
+  
+  // Check for package.json (JavaScript/TypeScript)
+  const packageJsonPath = path.join(targetDir, 'package.json');
+  if (await fs.pathExists(packageJsonPath)) {
+    try {
+      const packageJson = await fs.readJson(packageJsonPath);
+      detectedLanguages.push('javascript-typescript');
+      
+      // Detect frameworks
+      const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+      
+      if (dependencies.react || dependencies['@types/react']) {
+        detectedFrameworks.push('react');
+      }
+      if (dependencies.vue || dependencies['@vue/cli']) {
+        detectedFrameworks.push('vue');
+      }
+      if (dependencies['@angular/core']) {
+        detectedFrameworks.push('angular');
+      }
+      if (dependencies.express || dependencies.fastify || dependencies.koa) {
+        detectedFrameworks.push('node');
+      }
+    } catch (error) {
+      console.warn('Could not parse package.json');
+    }
+  }
+  
+  // Check for Python files
+  const pythonFiles = await findFilesByExtension(targetDir, ['.py']);
+  if (pythonFiles.length > 0) {
+    detectedLanguages.push('python');
+    
+    // Check for Python frameworks
+    const requirementsPath = path.join(targetDir, 'requirements.txt');
+    const pipfilePath = path.join(targetDir, 'Pipfile');
+    const pyprojectPath = path.join(targetDir, 'pyproject.toml');
+    
+    if (await fs.pathExists(requirementsPath)) {
+      const requirements = await fs.readFile(requirementsPath, 'utf-8');
+      if (requirements.includes('django')) detectedFrameworks.push('django');
+      if (requirements.includes('flask')) detectedFrameworks.push('flask');
+      if (requirements.includes('fastapi')) detectedFrameworks.push('fastapi');
+    }
+    
+    // Check for Django settings
+    if (await findFilesByPattern(targetDir, 'settings.py').length > 0) {
+      detectedFrameworks.push('django');
+    }
+    
+    // Check for Flask app
+    if (await findFilesByPattern(targetDir, 'app.py').length > 0) {
+      detectedFrameworks.push('flask');
+    }
+  }
+  
+  // Check for Rust files
+  const rustFiles = await findFilesByExtension(targetDir, ['.rs']);
+  const cargoPath = path.join(targetDir, 'Cargo.toml');
+  if (rustFiles.length > 0 || await fs.pathExists(cargoPath)) {
+    detectedLanguages.push('rust');
+  }
+  
+  // Check for Go files
+  const goFiles = await findFilesByExtension(targetDir, ['.go']);
+  const goModPath = path.join(targetDir, 'go.mod');
+  if (goFiles.length > 0 || await fs.pathExists(goModPath)) {
+    detectedLanguages.push('go');
+  }
+  
+  return {
+    detectedLanguage: detectedLanguages[0] || null,
+    detectedFramework: detectedFrameworks[0] || null,
+    allLanguages: detectedLanguages,
+    allFrameworks: detectedFrameworks,
+    projectFiles: await getProjectSummary(targetDir)
+  };
+}
+
+async function findFilesByExtension(dir, extensions, maxDepth = 2) {
+  const files = [];
+  
+  async function searchDir(currentDir, currentDepth) {
+    if (currentDepth > maxDepth) return;
+    
+    try {
+      const entries = await fs.readdir(currentDir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        
+        if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+          await searchDir(fullPath, currentDepth + 1);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (extensions.includes(ext)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch (error) {
+      // Directory might not be accessible
+    }
+  }
+  
+  await searchDir(dir, 0);
+  return files;
+}
+
+async function findFilesByPattern(dir, pattern, maxDepth = 2) {
+  const files = [];
+  
+  async function searchDir(currentDir, currentDepth) {
+    if (currentDepth > maxDepth) return;
+    
+    try {
+      const entries = await fs.readdir(currentDir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        
+        if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+          await searchDir(fullPath, currentDepth + 1);
+        } else if (entry.isFile() && entry.name.includes(pattern)) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      // Directory might not be accessible
+    }
+  }
+  
+  await searchDir(dir, 0);
+  return files;
+}
+
+async function getProjectSummary(targetDir) {
+  const summary = {
+    hasGit: await fs.pathExists(path.join(targetDir, '.git')),
+    hasNodeModules: await fs.pathExists(path.join(targetDir, 'node_modules')),
+    hasVenv: await fs.pathExists(path.join(targetDir, 'venv')) || await fs.pathExists(path.join(targetDir, '.venv')),
+    configFiles: []
+  };
+  
+  // Check for common config files
+  const configFiles = [
+    'package.json', 'tsconfig.json', 'webpack.config.js', 'vite.config.js',
+    'requirements.txt', 'setup.py', 'pyproject.toml', 'Pipfile',
+    'Cargo.toml', 'go.mod', '.gitignore', 'README.md'
+  ];
+  
+  for (const configFile of configFiles) {
+    if (await fs.pathExists(path.join(targetDir, configFile))) {
+      summary.configFiles.push(configFile);
+    }
+  }
+  
+  return summary;
+}
+
+module.exports = {
+  detectProject,
+  findFilesByExtension,
+  findFilesByPattern,
+  getProjectSummary
+};

package/templates/common/CLAUDE.md

@@ -0,0 +1,109 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Universal Development Guidelines
+
+### Code Quality Standards
+- Write clean, readable, and maintainable code
+- Follow consistent naming conventions across the project
+- Use meaningful variable and function names
+- Keep functions focused and single-purpose
+- Add comments for complex logic and business rules
+
+### Git Workflow
+- Use descriptive commit messages following conventional commits format
+- Create feature branches for new development
+- Keep commits atomic and focused on single changes
+- Use pull requests for code review before merging
+- Maintain a clean commit history
+
+### Documentation
+- Keep README.md files up to date
+- Document public APIs and interfaces
+- Include usage examples for complex features
+- Maintain inline code documentation
+- Update documentation when making changes
+
+### Testing Approach
+- Write tests for new features and bug fixes
+- Maintain good test coverage
+- Use descriptive test names that explain the expected behavior
+- Organize tests logically by feature or module
+- Run tests before committing changes
+
+### Security Best Practices
+- Never commit sensitive information (API keys, passwords, tokens)
+- Use environment variables for configuration
+- Validate input data and sanitize outputs
+- Follow principle of least privilege
+- Keep dependencies updated
+
+## Project Structure Guidelines
+
+### File Organization
+- Group related files in logical directories
+- Use consistent file and folder naming conventions
+- Separate source code from configuration files
+- Keep build artifacts out of version control
+- Organize assets and resources appropriately
+
+### Configuration Management
+- Use configuration files for environment-specific settings
+- Centralize configuration in dedicated files
+- Use environment variables for sensitive or environment-specific data
+- Document configuration options and their purposes
+- Provide example configuration files
+
+## Development Workflow
+
+### Before Starting Work
+1. Pull latest changes from main branch
+2. Create a new feature branch
+3. Review existing code and architecture
+4. Plan the implementation approach
+
+### During Development
+1. Make incremental commits with clear messages
+2. Run tests frequently to catch issues early
+3. Follow established coding standards
+4. Update documentation as needed
+
+### Before Submitting
+1. Run full test suite
+2. Check code quality and formatting
+3. Update documentation if necessary
+4. Create clear pull request description
+
+## Common Patterns
+
+### Error Handling
+- Use appropriate error handling mechanisms for the language
+- Provide meaningful error messages
+- Log errors appropriately for debugging
+- Handle edge cases gracefully
+- Don't expose sensitive information in error messages
+
+### Performance Considerations
+- Profile code for performance bottlenecks
+- Optimize database queries and API calls
+- Use caching where appropriate
+- Consider memory usage and resource management
+- Monitor and measure performance metrics
+
+### Code Reusability
+- Extract common functionality into reusable modules
+- Use dependency injection for better testability
+- Create utility functions for repeated operations
+- Design interfaces for extensibility
+- Follow DRY (Don't Repeat Yourself) principle
+
+## Review Checklist
+
+Before marking any task as complete:
+- [ ] Code follows established conventions
+- [ ] Tests are written and passing
+- [ ] Documentation is updated
+- [ ] Security considerations are addressed
+- [ ] Performance impact is considered
+- [ ] Code is reviewed for maintainability

package/templates/common/README.md

@@ -0,0 +1,96 @@
+# Common Claude Code Templates
+
+This folder contains language-agnostic templates and configurations that can be used across different programming languages and project types.
+
+## What's Included
+
+### Core Files
+- `CLAUDE.md` - Base configuration for Claude Code with universal best practices
+- `.claude/commands/` - Custom commands for common development tasks
+
+### Common Custom Commands
+- `git-workflow.md` - Git operations and workflow automation
+- `code-review.md` - Code review and quality assurance tasks
+- `project-setup.md` - Project initialization and configuration
+- `documentation.md` - Documentation generation and maintenance
+
+## How to Use
+
+### For New Projects
+Copy the entire `common/` folder contents to your project root:
+
+```bash
+cp -r claude-code-templates/common/* your-project/
+```
+
+### For Existing Projects
+Merge the relevant files with your existing Claude Code configuration:
+
+```bash
+# Copy custom commands
+cp -r claude-code-templates/common/.claude/commands/* your-project/.claude/commands/
+
+# Review and merge CLAUDE.md content
+cat claude-code-templates/common/CLAUDE.md >> your-project/CLAUDE.md
+```
+
+## Customization
+
+### CLAUDE.md
+The base CLAUDE.md file includes:
+- Universal development best practices
+- Common project patterns and conventions
+- Git workflow guidelines
+- Code quality standards
+
+Customize it by:
+- Adding project-specific information
+- Modifying coding standards to match your team's preferences
+- Including technology-specific guidelines
+
+### Custom Commands
+The included commands are designed to be generic and widely applicable. You can:
+- Modify existing commands to match your workflow
+- Add new commands for project-specific tasks
+- Remove commands that don't apply to your project
+
+## Language-Specific Integration
+
+This common template is designed to work alongside language-specific templates:
+
+1. Start with the common template
+2. Add language-specific configurations from the appropriate folder
+3. Customize both to match your project needs
+
+## Examples
+
+### Multi-language Projects
+For projects using multiple programming languages:
+
+```bash
+# Copy common base
+cp -r claude-code-templates/common/* your-project/
+
+# Add language-specific configurations
+cp -r claude-code-templates/javascript-typescript/.claude/commands/* your-project/.claude/commands/
+cp -r claude-code-templates/python/.claude/commands/* your-project/.claude/commands/
+```
+
+### Team Standardization
+Organizations can use this as a base template and customize it for their specific needs:
+
+1. Fork this repository
+2. Modify the common templates to match your standards
+3. Distribute to development teams
+4. Keep synchronized with updates
+
+## Best Practices
+
+- **Start Simple**: Begin with the common template and add complexity as needed
+- **Document Changes**: Keep track of customizations in your project's documentation
+- **Regular Updates**: Periodically review and update your Claude Code configuration
+- **Team Alignment**: Ensure all team members understand the custom commands and workflows
+
+## Contributing
+
+If you create useful generic commands or improvements to the common template, consider contributing them back to this repository to help other developers.

package/templates/javascript-typescript/.claude/commands/api-endpoint.md

@@ -0,0 +1 @@
+# API Endpoint Command

package/templates/javascript-typescript/.claude/commands/debug.md

@@ -0,0 +1 @@
+# Debug Command

package/templates/javascript-typescript/.claude/commands/lint.md

@@ -0,0 +1 @@
+# Lint Command

package/templates/javascript-typescript/.claude/commands/npm-scripts.md

@@ -0,0 +1 @@
+# NPM Scripts Command

package/templates/javascript-typescript/.claude/commands/react-component.md

@@ -0,0 +1 @@
+# React Component Command

package/templates/javascript-typescript/.claude/commands/refactor.md

@@ -0,0 +1 @@
+# Refactor Command

package/templates/javascript-typescript/.claude/commands/test.md

@@ -0,0 +1 @@
+# Test Command

package/templates/javascript-typescript/.claude/commands/typescript-migrate.md

@@ -0,0 +1 @@
+# TypeScript Migrate Command

package/templates/javascript-typescript/.claude/hooks/format-on-save.json

@@ -0,0 +1 @@
+{}

package/templates/javascript-typescript/.claude/hooks/lint-on-save.json

@@ -0,0 +1 @@
+{}

package/templates/javascript-typescript/.claude/hooks/typescript-check.json

@@ -0,0 +1 @@
+{}

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

@@ -0,0 +1,103 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash",
+      "Edit",
+      "MultiEdit",
+      "Write",
+      "Bash(npm:*)",
+      "Bash(yarn:*)",
+      "Bash(npx:*)",
+      "Bash(node:*)",
+      "Bash(git:*)",
+      "Bash(eslint:*)",
+      "Bash(prettier:*)",
+      "Bash(tsc:*)",
+      "Bash(jest:*)",
+      "Bash(vitest:*)",
+      "Bash(webpack:*)",
+      "Bash(vite:*)"
+    ],
+    "deny": [
+      "Bash(curl:*)",
+      "Bash(wget:*)",
+      "Bash(rm -rf:*)"
+    ],
+    "defaultMode": "allowEdits"
+  },
+  "env": {
+    "BASH_DEFAULT_TIMEOUT_MS": "30000",
+    "BASH_MAX_OUTPUT_LENGTH": "10000",
+    "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR": "1",
+    "NODE_ENV": "development"
+  },
+  "includeCoAuthoredBy": true,
+  "cleanupPeriodDays": 30,
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "jq -r '\"\\(.tool_input.command) - \\(.tool_input.description // \"No description\")\"' >> ~/.claude/bash-command-log.txt"
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [[ \"$(jq -r '.tool_input.file_path' | grep -E '\\.js$|\\.jsx$|\\.ts$|\\.tsx$')\" != \"\" && $(jq -r '.tool_input.content' | grep -E 'console\\.log') != \"\" ]]; then echo 'Warning: console.log statements should be removed before committing' >&2; fi"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.(js|jsx|ts|tsx)$ ]]; then npx prettier --write \"$FILE\"; fi",
+            "timeout": 30
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.(ts|tsx)$ ]]; then npx tsc --noEmit; fi",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo \"Claude Code notification: $(date)\" >> ~/.claude/notifications.log"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [[ -f package.json && $(git status --porcelain | grep -E '\\.js$|\\.jsx$|\\.ts$|\\.tsx$') ]]; then echo 'Running linter on changed files...'; npx eslint $(git diff --name-only --diff-filter=ACMR | grep -E '\\.js$|\\.jsx$|\\.ts$|\\.tsx$'); fi",
+            "timeout": 60
+          }
+        ]
+      }
+    ]
+  }
+}