clauderc 1.0.0 → 1.0.1

package/README.md

@@ -12,14 +12,17 @@
 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/npm/v/clauderc?color=blue" alt="npm version">
+  <a href="https://www.npmjs.com/package/clauderc"><img src="https://img.shields.io/npm/v/clauderc?color=blue" alt="npm version"></a>
   <img src="https://img.shields.io/badge/platform-macOS%20%7C%20Linux%20%7C%20Windows-lightgrey" alt="platform">
   <img src="https://img.shields.io/badge/node-%3E%3D16.7-green" alt="node version">
+  <a href="https://github.com/matheuskindrazki/clauderc/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="license"></a>
+  <a href="https://github.com/matheuskindrazki/clauderc/blob/main/CONTRIBUTING.md"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs Welcome"></a>
+  <a href="https://github.com/matheuskindrazki/clauderc/blob/main/CODE_OF_CONDUCT.md"><img src="https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg" alt="Contributor Covenant"></a>
 </p>
 
 ---
 
-Based on tips from [Boris Cherny](https://twitter.com/bcherny) (Claude Code creator) and official documentation.
+Based on my experiences and tips from [ Boris Cherny ](https://twitter.com/bcherny) (creator of the Claude Code) and official documentation.
 
 ## Quick Start
 
@@ -198,10 +201,18 @@ After installation:
 
 ## Contributing
 
-Contributions are welcome! Feel free to:
+Contributions are welcome! Please read our guidelines before contributing:
+
+- **[Contributing Guide](CONTRIBUTING.md)** - How to contribute to the project
+- **[Code of Conduct](CODE_OF_CONDUCT.md)** - Community guidelines
+- **[Security Policy](SECURITY.md)** - How to report vulnerabilities
+
+Ways to contribute:
 - Add new commands, skills, or agents
+- Add support for new stacks/languages
 - Improve existing templates
-- Report issues or suggest features
+- Report bugs or suggest features
+- Improve documentation
 
 ## Author
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderc",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Setup Claude Code with best practices - agents, skills, commands, and templates",
   "type": "module",
   "bin": {

package/src/detector.js

@@ -4,8 +4,293 @@
 
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
+import { execSync } from 'child_process';
 import { STACKS, MONOREPO_TOOLS, CI_PLATFORMS } from './stacks.js';
 
+/**
+ * Files to read for LLM analysis
+ */
+const ANALYSIS_FILES = [
+  'package.json',
+  'pyproject.toml',
+  'requirements.txt',
+  'go.mod',
+  'Cargo.toml',
+  'composer.json',
+  'Gemfile',
+  'pom.xml',
+  'build.gradle',
+  'build.gradle.kts',
+  'mix.exs',
+  'pubspec.yaml',
+  'Package.swift',
+  '*.csproj',
+  'turbo.json',
+  'nx.json',
+  'pnpm-workspace.yaml',
+  'lerna.json',
+  '.github/workflows/*.yml',
+  '.gitlab-ci.yml',
+  'Jenkinsfile',
+  'biome.json',
+  'biome.jsonc',
+  '.eslintrc*',
+  '.prettierrc*',
+  'tsconfig.json',
+  'vite.config.*',
+  'next.config.*',
+  'nuxt.config.*',
+];
+
+/**
+ * Read relevant project files for analysis
+ */
+function readProjectFiles(projectPath) {
+  const files = {};
+
+  for (const pattern of ANALYSIS_FILES) {
+    if (pattern.includes('*')) {
+      // Handle glob patterns
+      const parts = pattern.split('/');
+      let searchPath = projectPath;
+      let filePattern = pattern;
+
+      if (parts.length > 1) {
+        searchPath = join(projectPath, ...parts.slice(0, -1));
+        filePattern = parts[parts.length - 1];
+      }
+
+      if (existsSync(searchPath)) {
+        const dirFiles = safeReadDir(searchPath);
+        const regex = new RegExp('^' + filePattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+        for (const file of dirFiles) {
+          if (regex.test(file)) {
+            const fullPath = join(searchPath, file);
+            const relativePath = fullPath.replace(projectPath + '/', '');
+            const content = safeReadFile(fullPath);
+            if (content && content.length < 10000) { // Limit file size
+              files[relativePath] = content;
+            }
+          }
+        }
+      }
+    } else {
+      const fullPath = join(projectPath, pattern);
+      if (existsSync(fullPath)) {
+        const content = safeReadFile(fullPath);
+        if (content && content.length < 10000) {
+          files[pattern] = content;
+        }
+      }
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Analyze project using Claude LLM
+ * @param {string} projectPath - Path to the project
+ * @returns {Object} - Detection result compatible with detectStack output
+ */
+export function analyzeWithClaude(projectPath = process.cwd()) {
+  const files = readProjectFiles(projectPath);
+
+  if (Object.keys(files).length === 0) {
+    console.warn('  ⚠ No project files found for analysis');
+    return null;
+  }
+
+  const filesContent = Object.entries(files)
+    .map(([name, content]) => `=== ${name} ===\n${content}`)
+    .join('\n\n');
+
+  const prompt = `Analyze this project and return a JSON configuration for Claude Code setup.
+
+PROJECT FILES:
+${filesContent}
+
+Return ONLY valid JSON (no markdown, no explanation) with this exact structure:
+{
+  "stack": {
+    "language": "Node.js|Python|Go|Rust|Java|PHP|Ruby|.NET|Elixir|Dart|Swift",
+    "framework": "Next.js|Nuxt|React|Vue|FastAPI|Django|Flask|Express|Gin|Rails|Laravel|Phoenix|etc or null",
+    "packageManager": "npm|pnpm|bun|yarn|pip|poetry|uv|cargo|go|maven|gradle|composer|bundler|mix|etc",
+    "monorepo": "turborepo|nx|lerna|pnpm-workspaces|yarn-workspaces or null",
+    "testFramework": "vitest|jest|pytest|go test|cargo test|phpunit|rspec|etc or null",
+    "linter": "eslint|biome|ruff|golangci-lint|clippy|rubocop|etc or null",
+    "formatter": "prettier|biome|black|ruff|gofmt|rustfmt|etc or null",
+    "ci": "github-actions|gitlab-ci|jenkins|circleci or null"
+  },
+  "commands": {
+    "setup": "command to install dependencies",
+    "dev": "command to run dev server",
+    "test": "command to run tests",
+    "lint": "command to lint code",
+    "format": "command to format code",
+    "typecheck": "command to check types or null",
+    "build": "command to build or null",
+    "verify": "combined lint + test + build command"
+  },
+  "preferences": {
+    "notes": "any special preferences detected (e.g., prefers bun over npm, uses specific conventions)"
+  }
+}
+
+IMPORTANT:
+- Detect ACTUAL tools being used, not defaults
+- If bun.lockb exists, use bun commands
+- If pnpm-lock.yaml exists, use pnpm commands
+- If uv.lock exists, use uv commands
+- Look at scripts in package.json for exact command names
+- Return commands that will actually work for this project`;
+
+  try {
+    // Escape the prompt for shell
+    const escapedPrompt = prompt
+      .replace(/\\/g, '\\\\')
+      .replace(/"/g, '\\"')
+      .replace(/\$/g, '\\$')
+      .replace(/`/g, '\\`');
+
+    const result = execSync(
+      `claude -p --model haiku "${escapedPrompt}"`,
+      {
+        encoding: 'utf-8',
+        maxBuffer: 1024 * 1024 * 10,
+        timeout: 120000, // 2 minute timeout
+        cwd: projectPath,
+      }
+    );
+
+    // Extract JSON from response
+    const jsonMatch = result.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      console.warn('  ⚠ Could not parse Claude response');
+      return null;
+    }
+
+    const analysis = JSON.parse(jsonMatch[0]);
+
+    // Convert to detectStack compatible format
+    return {
+      analysis,
+      stack: convertToStackFormat(analysis.stack),
+      commands: analysis.commands,
+      preferences: analysis.preferences,
+    };
+  } catch (error) {
+    console.warn('  ⚠ Claude analysis failed:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Convert LLM analysis to detectStack format
+ */
+function convertToStackFormat(llmStack) {
+  const result = {
+    stacks: [],
+    packageManager: null,
+    framework: null,
+    monorepo: null,
+    ci: null,
+    testFramework: null,
+    linter: null,
+    formatter: null,
+    typechecker: null,
+  };
+
+  // Map language to stack
+  const languageMap = {
+    'Node.js': 'node',
+    'Python': 'python',
+    'Go': 'go',
+    'Rust': 'rust',
+    'Java': 'java',
+    'PHP': 'php',
+    'Ruby': 'ruby',
+    '.NET': 'dotnet',
+    'Elixir': 'elixir',
+    'Dart': 'dart',
+    'Swift': 'swift',
+  };
+
+  const stackId = languageMap[llmStack.language];
+  if (stackId && STACKS[stackId]) {
+    result.stacks.push({ id: stackId, name: llmStack.language, ...STACKS[stackId] });
+  }
+
+  // Package manager
+  if (llmStack.packageManager) {
+    result.packageManager = {
+      name: llmStack.packageManager,
+      install: getInstallCommand(llmStack.packageManager),
+      run: getRunCommand(llmStack.packageManager),
+    };
+  }
+
+  // Framework
+  if (llmStack.framework) {
+    result.framework = { name: llmStack.framework };
+  }
+
+  // Monorepo
+  if (llmStack.monorepo) {
+    result.monorepo = { name: llmStack.monorepo };
+  }
+
+  // CI
+  if (llmStack.ci) {
+    result.ci = { name: llmStack.ci };
+  }
+
+  // Tools
+  result.testFramework = llmStack.testFramework;
+  result.linter = llmStack.linter;
+  result.formatter = llmStack.formatter;
+
+  return result;
+}
+
+/**
+ * Get install command for package manager
+ */
+function getInstallCommand(pm) {
+  const commands = {
+    npm: 'npm install',
+    pnpm: 'pnpm install',
+    bun: 'bun install',
+    yarn: 'yarn install',
+    pip: 'pip install -r requirements.txt',
+    poetry: 'poetry install',
+    uv: 'uv sync',
+    cargo: 'cargo build',
+    go: 'go mod download',
+    maven: 'mvn install -DskipTests',
+    gradle: 'gradle build -x test',
+    composer: 'composer install',
+    bundler: 'bundle install',
+    mix: 'mix deps.get',
+  };
+  return commands[pm] || `${pm} install`;
+}
+
+/**
+ * Get run command prefix for package manager
+ */
+function getRunCommand(pm) {
+  const commands = {
+    npm: 'npm run',
+    pnpm: 'pnpm',
+    bun: 'bun run',
+    yarn: 'yarn',
+    poetry: 'poetry run',
+    uv: 'uv run',
+  };
+  return commands[pm] || '';
+}
+
 /**
  * Detect project stack from current directory
  */
@@ -384,4 +669,4 @@ export function generateCommands(detection) {
   return commands;
 }
 
-export default { detectStack, generateCommands };
+export default { detectStack, generateCommands, analyzeWithClaude };

package/src/project.js

@@ -5,7 +5,74 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
 import { join, basename } from 'path';
 import { createInterface } from 'readline';
-import { detectStack, generateCommands } from './detector.js';
+import { execSync } from 'child_process';
+import { detectStack, generateCommands, analyzeWithClaude } from './detector.js';
+
+/**
+ * Use Claude CLI to intelligently merge existing and new content
+ * @param {string} existingContent - The current file content
+ * @param {string} newContent - The proposed new content
+ * @param {string} fileType - Type of file for context (e.g., 'CLAUDE.md', 'settings.json')
+ * @returns {string} - The merged content
+ */
+function mergeWithClaude(existingContent, newContent, fileType) {
+  const prompt = `You are merging two versions of a ${fileType} configuration file.
+
+EXISTING content (user's current configuration - PRESERVE user preferences and customizations):
+---
+${existingContent}
+---
+
+NEW content (auto-generated with updated stack detection):
+---
+${newContent}
+---
+
+IMPORTANT RULES:
+1. PRESERVE any custom rules, preferences, or configurations the user added in EXISTING
+2. UPDATE commands and stack info from NEW if they are more accurate
+3. MERGE sections intelligently - don't duplicate, combine them
+4. Keep user's custom sections that don't exist in NEW
+5. If EXISTING has custom hooks, permissions, or rules - KEEP THEM
+6. Output ONLY the merged content, no explanations
+
+Output the merged ${fileType}:`;
+
+  try {
+    // Use Claude CLI in print mode for non-interactive merge
+    const result = execSync(
+      `claude -p --model haiku "${prompt.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`,
+      {
+        encoding: 'utf-8',
+        maxBuffer: 1024 * 1024 * 10, // 10MB buffer
+        timeout: 60000, // 60 second timeout
+      }
+    );
+    return result.trim();
+  } catch (error) {
+    // If Claude CLI fails, return new content with a warning
+    console.warn('  ⚠ Could not use Claude for merge, using new content');
+    return newContent;
+  }
+}
+
+/**
+ * Smart write that merges with existing content if file exists
+ * @param {string} filePath - Path to the file
+ * @param {string} newContent - New content to write
+ * @param {string} fileType - Type of file for merge context
+ * @param {boolean} useMerge - Whether to use Claude merge
+ */
+function smartWrite(filePath, newContent, fileType, useMerge = true) {
+  if (useMerge && existsSync(filePath)) {
+    const existingContent = readFileSync(filePath, 'utf-8');
+    const mergedContent = mergeWithClaude(existingContent, newContent, fileType);
+    writeFileSync(filePath, mergedContent);
+    return { merged: true, path: filePath };
+  }
+  writeFileSync(filePath, newContent);
+  return { merged: false, path: filePath };
+}
 
 /**
  * Interactive prompt helper
@@ -307,11 +374,37 @@ export async function runProjectWizard(options = {}) {
   const prompt = createPrompt();
 
   try {
-    log('\n  Analyzing project...\n');
-
-    // Detect stack
-    const stack = detectStack(projectPath);
-    const commands = generateCommands(stack);
+    log('\n  Claude Code Project Setup\n');
+    log('  This wizard will configure Claude Code for your project.\n');
+
+    // Ask about AI analysis
+    const useAI = await prompt.confirm('  Use Claude AI for smarter detection? (recommended)');
+
+    let stack;
+    let commands;
+    let aiAnalysis = null;
+
+    if (useAI) {
+      log('\n  Analyzing project with Claude AI...\n');
+      aiAnalysis = analyzeWithClaude(projectPath);
+
+      if (aiAnalysis) {
+        stack = aiAnalysis.stack;
+        commands = aiAnalysis.commands;
+
+        if (aiAnalysis.preferences?.notes) {
+          log(`  Notes: ${aiAnalysis.preferences.notes}\n`);
+        }
+      } else {
+        log('  AI analysis failed, falling back to deterministic detection...\n');
+        stack = detectStack(projectPath);
+        commands = generateCommands(stack);
+      }
+    } else {
+      log('\n  Analyzing project...\n');
+      stack = detectStack(projectPath);
+      commands = generateCommands(stack);
+    }
 
     // Show detection results
     log('  Detected configuration:\n');
@@ -375,20 +468,35 @@ export async function runProjectWizard(options = {}) {
     // Check existing .claude directory
     const claudeDir = join(projectPath, '.claude');
     const hasExisting = existsSync(claudeDir);
-
-    if (hasExisting) {
-      const overwrite = await prompt.confirm('\n  .claude/ already exists. Overwrite?');
-      if (!overwrite) {
+    const hasExistingClaudeMd = existsSync(join(projectPath, 'CLAUDE.md'));
+    let useMerge = false;
+
+    if (hasExisting || hasExistingClaudeMd) {
+      log('\n  Existing configuration detected.\n');
+      const mergeChoice = await prompt.select('  How would you like to proceed?', [
+        { label: 'Merge', description: 'Use Claude to intelligently merge with existing config (recommended)' },
+        { label: 'Overwrite', description: 'Replace all existing configuration' },
+        { label: 'Cancel', description: 'Keep existing configuration unchanged' },
+      ]);
+
+      if (mergeChoice.label === 'Cancel') {
         log('\n  Setup cancelled.\n');
         prompt.close();
         return null;
       }
+
+      useMerge = mergeChoice.label === 'Merge';
+
+      if (useMerge) {
+        log('\n  Will use Claude to merge configurations intelligently.\n');
+      }
     }
 
     prompt.close();
 
     if (dryRun) {
-      log('\n  DRY RUN - Would create:\n');
+      const action = useMerge ? 'merge with' : 'create';
+      log(`\n  DRY RUN - Would ${action}:\n`);
       log('    .claude/');
       log('    ├── commands/test.md');
       log('    ├── commands/lint.md');
@@ -396,30 +504,39 @@ export async function runProjectWizard(options = {}) {
       log('    ├── commands/setup.md');
       log('    ├── commands/pr.md');
       log('    ├── settings.json');
-      log('    CLAUDE.md\n');
+      log('    CLAUDE.md');
+      if (useMerge) {
+        log('\n  Note: Claude will intelligently merge with existing files.\n');
+      }
       return config;
     }
 
     // Create directories
     mkdirSync(join(claudeDir, 'commands'), { recursive: true });
 
-    // Write files
+    // Write files with smart merge
     const files = [
-      { path: join(projectPath, 'CLAUDE.md'), content: generateClaudeMd(config) },
-      { path: join(claudeDir, 'settings.json'), content: JSON.stringify(generateSettings(config), null, 2) },
-      { path: join(claudeDir, 'commands', 'test.md'), content: generateCommandFile('test', config) },
-      { path: join(claudeDir, 'commands', 'lint.md'), content: generateCommandFile('lint', config) },
-      { path: join(claudeDir, 'commands', 'verify.md'), content: generateCommandFile('verify', config) },
-      { path: join(claudeDir, 'commands', 'setup.md'), content: generateCommandFile('setup', config) },
-      { path: join(claudeDir, 'commands', 'pr.md'), content: generateCommandFile('pr', config) },
+      { path: join(projectPath, 'CLAUDE.md'), content: generateClaudeMd(config), type: 'CLAUDE.md' },
+      { path: join(claudeDir, 'settings.json'), content: JSON.stringify(generateSettings(config), null, 2), type: 'settings.json' },
+      { path: join(claudeDir, 'commands', 'test.md'), content: generateCommandFile('test', config), type: 'command file' },
+      { path: join(claudeDir, 'commands', 'lint.md'), content: generateCommandFile('lint', config), type: 'command file' },
+      { path: join(claudeDir, 'commands', 'verify.md'), content: generateCommandFile('verify', config), type: 'command file' },
+      { path: join(claudeDir, 'commands', 'setup.md'), content: generateCommandFile('setup', config), type: 'command file' },
+      { path: join(claudeDir, 'commands', 'pr.md'), content: generateCommandFile('pr', config), type: 'command file' },
     ];
 
     for (const file of files) {
-      writeFileSync(file.path, file.content);
-      log(`  + ${file.path.replace(projectPath, '.')}`);
+      const result = smartWrite(file.path, file.content, file.type, useMerge);
+      const symbol = result.merged ? '~' : '+';
+      const action = result.merged ? 'merged' : 'created';
+      log(`  ${symbol} ${file.path.replace(projectPath, '.')} (${action})`);
     }
 
     log('\n  Project setup complete!\n');
+    if (useMerge) {
+      log('  Files were merged with existing configuration.');
+      log('  Your custom settings and preferences were preserved.\n');
+    }
     log('  Next steps:');
     log('    1. Review CLAUDE.md and adjust as needed');
     log('    2. Commit .claude/ to your repository');