claude-init 1.0.21 → 1.0.24

package/.claude/settings.json

@@ -6,8 +6,11 @@
     "deny": [
       "Read(**/.env*)",
       "Edit(**/.env*)",
-      "Write(**/.env*)",
-      "Bash(**:.env*)"
+      "Write(**/.env*)"
+    ],
+    "defaultMode": "acceptEdits",
+    "additionalDirectories": [
+      "/tmp"
     ]
   },
   "statusLine": {

package/.claude/settings.local.json

@@ -11,7 +11,6 @@
       "Bash(git add:*)"
     ],
     "deny": [],
-    "ask": [],
     "additionalDirectories": [
       "/tmp"
     ]

package/CLAUDE.md

@@ -1,4 +1 @@
-+ During you interaction with the user, if you find anything reusable in this project (e.g. version of a library, model name), especially about a fix to a mistake you made or a correction you received, you should take note in the `Lessons` section in the `CLAUDE.md` file so you will not make the same mistake again. 
-+ You should also use the `CLAUDE.md` file as a scratchpad to organize your thoughts. Especially when you receive a new task, you should first review the content of the scratchpad, clear old different task but keep lessons learned, then explain the task, and plan the steps you need to take to complete the task. You can use todo markers to indicate the progress, e.g.
-[X] Task 1
-[ ] Task 2
++ During you interaction with the user, if you find anything reusable in this project (e.g. version of a library, model name), especially about a fix to a mistake you made or a correction you received, you should take note in the `Lessons` section in the `CLAUDE.md` file so you will not make the same mistake again.

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
 
@@ -55,14 +57,100 @@ Running `npx claude-init` sets up your current directory with:
 
 #### ⚙️ .claude/settings.json
 - **If missing**: Creates with default Claude settings
-- **If exists**: Skips to preserve your custom settings
+- **If exists**: Prompts whether to overwrite with template version
+- **Interactive prompt**: If the file exists, you'll be asked whether to overwrite it
+  - Answer **Yes** to replace with fresh template
+  - Answer **No** (default) 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/settings.json?** (only if the file already exists)
+   - Prompt: `Overwrite existing .claude/settings.json with template version? (y/N):`
+   - Default: **No** (preserves your custom settings)
+   - If **Yes**: Replaces your settings file with fresh template
+   - If **No**: Keeps your existing settings file
+
+2. **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
+
+3. **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/settings.json` is **not** overwritten (preserves custom settings)
+- `.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
+Overwrite existing .claude/settings.json with template version? (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.24",
   "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,48 @@ 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 overwrite .claude/settings.json
+  let overwriteSettings = false;
+  const settingsPath = path.join(targetDir, '.claude/settings.json');
+  if (await fs.pathExists(settingsPath)) {
+    overwriteSettings = await promptYesNo(
+      'Overwrite existing .claude/settings.json with template version?',
+      false
+    );
+  }
+
+  // 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',
@@ -47,17 +100,24 @@ export async function cli() {
     },
     {
       name: '.claude/settings.json',
-      handler: () => handleSingleFile(targetDir, '.claude/settings.json')
+      handler: () => handleSingleFile(targetDir, '.claude/settings.json', { overwrite: overwriteSettings })
     },
     {
       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 +159,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,69 +70,111 @@ 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;
 }
 
 /**
- * Handle single file copying (create if not exists, skip if exists)
+ * Handle single file copying (create if not exists, skip if exists, optionally overwrite)
+ * @param {string} targetDir - The target directory
+ * @param {string} relativePath - The relative path of the file to copy
+ * @param {Object} options - Options for the copy operation
+ * @param {boolean} options.overwrite - Whether to overwrite existing file (default: false)
  */
-export async function handleSingleFile(targetDir, relativePath) {
+export async function handleSingleFile(targetDir, relativePath, options = {}) {
+  const { overwrite = false } = options;
   const targetPath = path.join(targetDir, relativePath);
   const templatePath = path.join(getTemplatesPath(), relativePath);
-  
+
   if (await fs.pathExists(targetPath)) {
-    return { action: 'skipped', details: `File ${relativePath} already exists` };
+    if (!overwrite) {
+      return { action: 'skipped', details: `File ${relativePath} already exists` };
+    }
+
+    // Overwrite existing file
+    await fs.copy(templatePath, targetPath);
+    return { action: 'updated', details: `Overwrote ${relativePath} with template` };
   }
-  
+
   // Ensure target directory exists
   await fs.ensureDir(path.dirname(targetPath));
   await fs.copy(templatePath, targetPath);
-  
+
   return { action: 'created', details: `Created ${relativePath}` };
 }

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);
+      }
+    });
+  });
+}