claude-init 1.0.21 → 1.0.23

package/.claude/settings.json

@@ -7,8 +7,9 @@
       "Read(**/.env*)",
       "Edit(**/.env*)",
       "Write(**/.env*)",
-      "Bash(**:.env*)"
-    ]
+      "Bash(*.env*)"
+    ],
+    "defaultMode": "acceptEdits"
   },
   "statusLine": {
     "type": "command",

package/README.md

@@ -5,9 +5,11 @@ A CLI tool to initialize Claude development environment with standardized config
 ## Features
 
 - **Smart Setup**: Automatically detects existing files and only creates/updates what's needed
-- **Non-destructive**: Never overwrites existing files, only adds missing content
+- **Interactive Prompts**: Asks before overwriting existing command files or installing agents
+- **Non-destructive by Default**: Preserves existing files unless you choose to overwrite
 - **Progress Feedback**: Clear visual indicators of what's being created, updated, or skipped
 - **Cross-platform**: Works on Windows, macOS, and Linux
+- **CI-friendly**: Non-interactive mode with sensible defaults when not running in a TTY
 
 ## Requirements
 
@@ -57,12 +59,87 @@ Running `npx claude-init` sets up your current directory with:
 - **If missing**: Creates with default Claude settings
 - **If exists**: Skips to preserve your custom settings
 
-#### 📋 .claude/commands & .claude/agents
+#### 📋 .claude/commands
 - **If missing**: Creates with all template files
-- **If exists**: Only adds missing files, preserves existing ones
+- **If exists**: Only adds missing files by default
+- **Interactive prompt**: If existing `.md` files are detected, you'll be asked whether to overwrite them with template versions
+  - Answer **Yes** to replace your customized `.md` files with fresh templates (while still adding any missing files)
+  - Answer **No** (default) to keep your existing `.md` files and only add missing files
+
+#### 🤖 .claude/agents
+- **Interactive prompt**: You'll be asked whether to install `.claude/agents` files
+  - Answer **Yes** (default) to install/update agent files
+  - Answer **No** to skip agents entirely
+
+### Interactive Prompts
+
+When running interactively (in a terminal), `claude-init` will ask you:
+
+1. **Overwrite existing .claude/commands/\*.md?** (only if you have existing `.md` files that match templates)
+   - Prompt: `Overwrite existing .claude/commands/*.md with template versions? (y/N):`
+   - Default: **No** (preserves your customizations)
+   - If **Yes**: Replaces existing `.md` files with templates, still adds missing files
+   - If **No**: Keeps your existing files, only adds missing files
+
+2. **Install .claude/agents?**
+   - Prompt: `Install .claude/agents files? (Y/n):`
+   - Default: **Yes** (installs agents)
+   - If **Yes**: Installs/updates agents as normal
+   - If **No**: Skips agents entirely (shown in summary)
+
+**Non-interactive mode (CI/scripts)**: When `process.stdin.isTTY` is false (e.g., in CI pipelines), prompts are skipped and defaults are used:
+- `.claude/commands/*.md` files are **not** overwritten (preserves customizations)
+- `.claude/agents` **is** installed (matches current behavior)
 
 ## Example Output
 
+### Interactive Run (First Time)
+
+```
+🚀 Claude Environment Initializer
+Initializing in: /path/to/your/project
+
+Install .claude/agents files? (Y/n): y
+
+✓ Created new CLAUDE.md
+✓ Created .devcontainer directory
+✓ Created .claude/settings.json
+✓ Created .claude/commands with 5 files
+✓ Created .claude/agents with 3 files
+
+📊 Summary:
+   Created: 5 items
+   Files added: 8
+
+✨ Claude environment is ready!
+```
+
+### Interactive Run (With Existing Files)
+
+```
+🚀 Claude Environment Initializer
+Initializing in: /path/to/your/project
+
+Overwrite existing .claude/commands/*.md with template versions? (y/N): n
+Install .claude/agents files? (Y/n): n
+
+- CLAUDE.md already contains template content
+- Directory .devcontainer already exists
+- File .claude/settings.json already exists
+↻ Added 1 missing files to .claude/commands (added: 1)
+- All files in .claude/agents are up to date
+
+📊 Summary:
+   Updated: 1 items
+   Skipped: 3 items (already exist)
+   Files added: 1
+   - .claude/agents skipped by user
+
+✅ Claude environment is already up to date!
+```
+
+### Non-Interactive Run (Original Output)
+
 ```
 🚀 Claude Environment Initializer
 Initializing in: /path/to/your/project

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-init",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "Initialize Claude development environment with configurations and templates",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -1,23 +1,39 @@
 import chalk from 'chalk';
 import ora from 'ora';
-import { 
+import path from 'path';
+import fs from 'fs-extra';
+import {
   handleClaudeMarkdown,
   handleDirectoryMirror,
   handleSelectiveFileCopy,
   handleSingleFile
 } from './fileManager.js';
+import { promptYesNo } from './prompt.js';
+import { getTemplatesPath, getFilesInDirectory } from './utils.js';
 
 /**
  * Format action result with appropriate colors and icons
  */
 function formatResult(result) {
-  const { action, details, filesAdded } = result;
-  
+  const { action, details, filesAdded, filesOverwritten } = result;
+
   switch (action) {
     case 'created':
       return chalk.green(`✓ ${details}`);
     case 'updated':
-      const fileInfo = filesAdded !== undefined ? ` (${filesAdded} files)` : '';
+      let fileInfo = '';
+      if (filesAdded !== undefined || filesOverwritten !== undefined) {
+        const parts = [];
+        if (filesAdded !== undefined && filesAdded > 0) {
+          parts.push(`added: ${filesAdded}`);
+        }
+        if (filesOverwritten !== undefined && filesOverwritten > 0) {
+          parts.push(`overwritten: ${filesOverwritten}`);
+        }
+        if (parts.length > 0) {
+          fileInfo = ` (${parts.join(', ')})`;
+        }
+      }
       return chalk.yellow(`↻ ${details}${fileInfo}`);
     case 'skipped':
       return chalk.gray(`- ${details}`);
@@ -31,11 +47,38 @@ function formatResult(result) {
  */
 export async function cli() {
   const targetDir = process.cwd();
-  
+
   console.log(chalk.blue.bold('🚀 Claude Environment Initializer'));
   console.log(chalk.gray(`Initializing in: ${targetDir}`));
   console.log();
-  
+
+  // Determine if we should prompt for overwriting .claude/commands/*.md
+  let overwriteCommandsMd = false;
+  const commandsTargetPath = path.join(targetDir, '.claude/commands');
+  const commandsTemplatePath = path.join(getTemplatesPath(), '.claude/commands');
+
+  if (await fs.pathExists(commandsTargetPath) && await fs.pathExists(commandsTemplatePath)) {
+    const templateFiles = await getFilesInDirectory(commandsTemplatePath);
+    const targetFiles = await getFilesInDirectory(commandsTargetPath);
+
+    // Check if there are any overlapping .md files
+    const mdTemplateFiles = templateFiles.filter(f => f.endsWith('.md'));
+    const hasOverlappingMd = mdTemplateFiles.some(f => targetFiles.includes(f));
+
+    if (hasOverlappingMd) {
+      overwriteCommandsMd = await promptYesNo(
+        'Overwrite existing .claude/commands/*.md with template versions?',
+        false
+      );
+    }
+  }
+
+  // Determine if we should install .claude/agents
+  const includeAgents = await promptYesNo(
+    'Install .claude/agents files?',
+    true
+  );
+
   const tasks = [
     {
       name: 'CLAUDE.md',
@@ -51,13 +94,20 @@ export async function cli() {
     },
     {
       name: '.claude/commands',
-      handler: () => handleSelectiveFileCopy(targetDir, '.claude/commands')
-    },
-    {
-      name: '.claude/agents',
-      handler: () => handleSelectiveFileCopy(targetDir, '.claude/agents')
+      handler: () => handleSelectiveFileCopy(targetDir, '.claude/commands', {
+        overwriteExisting: overwriteCommandsMd,
+        filter: (relPath) => relPath.endsWith('.md')
+      })
     }
   ];
+
+  // Conditionally add .claude/agents task
+  if (includeAgents) {
+    tasks.push({
+      name: '.claude/agents',
+      handler: () => handleSelectiveFileCopy(targetDir, '.claude/agents')
+    });
+  }
   
   let totalActions = { created: 0, updated: 0, skipped: 0, filesAdded: 0 };
   
@@ -99,9 +149,13 @@ export async function cli() {
   if (totalActions.filesAdded > 0) {
     console.log(chalk.cyan(`   Files added: ${totalActions.filesAdded}`));
   }
-  
+
+  if (!includeAgents) {
+    console.log(chalk.gray(`   - .claude/agents skipped by user`));
+  }
+
   console.log();
-  
+
   if (totalActions.created > 0 || totalActions.updated > 0) {
     console.log(chalk.green.bold('✨ Claude environment is ready!'));
   } else {

package/src/fileManager.js

@@ -70,53 +70,84 @@ export async function handleDirectoryMirror(targetDir, relativePath) {
 }
 
 /**
- * Handle selective file copying (add missing files only)
+ * Handle selective file copying (add missing files only, optionally overwrite existing)
+ * @param {string} targetDir - The target directory
+ * @param {string} relativePath - The relative path to copy
+ * @param {Object} options - Options for the copy operation
+ * @param {boolean} options.overwriteExisting - Whether to overwrite existing files (default: false)
+ * @param {function} options.filter - Function to filter which files to overwrite (default: all files)
  */
-export async function handleSelectiveFileCopy(targetDir, relativePath) {
+export async function handleSelectiveFileCopy(targetDir, relativePath, options = {}) {
+  const { overwriteExisting = false, filter = () => true } = options;
   const targetPath = path.join(targetDir, relativePath);
   const templatePath = path.join(getTemplatesPath(), relativePath);
-  
+
   if (!(await fs.pathExists(targetPath))) {
     // Directory doesn't exist, create it with all template files
     await fs.copy(templatePath, targetPath);
     const files = await getFilesInDirectory(templatePath);
-    return { 
-      action: 'created', 
+    return {
+      action: 'created',
       details: `Created ${relativePath} with ${files.length} files`,
       filesAdded: files.length
     };
   }
-  
-  // Directory exists, check for missing files
+
+  // Directory exists, check for missing files and optionally overwrite existing
   const templateFiles = await getFilesInDirectory(templatePath);
   const targetFiles = await getFilesInDirectory(targetPath);
   const missingFiles = templateFiles.filter(file => !targetFiles.includes(file));
-  
-  if (missingFiles.length === 0) {
-    return { 
-      action: 'skipped', 
-      details: `All files in ${relativePath} are up to date`,
-      filesAdded: 0
-    };
-  }
-  
+
+  let filesAdded = 0;
+  let filesOverwritten = 0;
+
   // Copy missing files
-  let copiedCount = 0;
   for (const missingFile of missingFiles) {
     const sourcePath = path.join(templatePath, missingFile);
     const destPath = path.join(targetPath, missingFile);
-    
+
     // Ensure destination directory exists
     await fs.ensureDir(path.dirname(destPath));
     await fs.copy(sourcePath, destPath);
-    copiedCount++;
+    filesAdded++;
   }
-  
-  return { 
-    action: 'updated', 
-    details: `Added ${copiedCount} missing files to ${relativePath}`,
-    filesAdded: copiedCount
+
+  // Optionally overwrite existing files that match filter
+  if (overwriteExisting) {
+    const existingFiles = templateFiles.filter(file => targetFiles.includes(file) && filter(file));
+
+    for (const existingFile of existingFiles) {
+      const sourcePath = path.join(templatePath, existingFile);
+      const destPath = path.join(targetPath, existingFile);
+
+      // Ensure destination directory exists
+      await fs.ensureDir(path.dirname(destPath));
+      await fs.copy(sourcePath, destPath);
+      filesOverwritten++;
+    }
+  }
+
+  if (filesAdded === 0 && filesOverwritten === 0) {
+    return {
+      action: 'skipped',
+      details: `All files in ${relativePath} are up to date`,
+      filesAdded: 0
+    };
+  }
+
+  const result = {
+    action: 'updated',
+    filesAdded
   };
+
+  if (overwriteExisting && filesOverwritten > 0) {
+    result.filesOverwritten = filesOverwritten;
+    result.details = `Added ${filesAdded} missing files, overwritten ${filesOverwritten} files in ${relativePath}`;
+  } else {
+    result.details = `Added ${filesAdded} missing files to ${relativePath}`;
+  }
+
+  return result;
 }
 
 /**

package/src/prompt.js

@@ -0,0 +1,44 @@
+import readline from 'readline';
+
+/**
+ * Prompts the user for a yes/no answer.
+ * @param {string} question - The question to ask
+ * @param {boolean} defaultAnswer - The default answer if user presses Enter or if non-TTY
+ * @returns {Promise<boolean>} - True for yes, false for no
+ */
+export async function promptYesNo(question, defaultAnswer) {
+  // If not TTY, return default immediately
+  if (!process.stdin.isTTY) {
+    return defaultAnswer;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    const defaultHint = defaultAnswer ? 'Y/n' : 'y/N';
+    rl.question(`${question} (${defaultHint}): `, (answer) => {
+      rl.close();
+
+      const normalized = answer.trim().toLowerCase();
+
+      // Empty answer uses default
+      if (normalized === '') {
+        resolve(defaultAnswer);
+        return;
+      }
+
+      // Accept y, yes, n, no
+      if (normalized === 'y' || normalized === 'yes') {
+        resolve(true);
+      } else if (normalized === 'n' || normalized === 'no') {
+        resolve(false);
+      } else {
+        // Invalid input, use default
+        resolve(defaultAnswer);
+      }
+    });
+  });
+}