@kood/claude-code 0.5.3 → 0.5.5

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { Command } from "commander";
 
-// src/utils/logger.ts
+// src/shared/logger.ts
 import pc from "picocolors";
 var logger = {
   info: (msg) => console.log(pc.cyan("\u2139"), msg),
@@ -22,18 +22,14 @@ var banner = () => {
 };
 
 // src/commands/init.ts
-import prompts from "prompts";
-import fs2 from "fs-extra";
+import fs7 from "fs-extra";
 
-// src/utils/copy.ts
-import fs from "fs-extra";
-import path from "path";
+// src/features/templates/template-path-resolver.ts
+import path2 from "path";
 import { fileURLToPath } from "url";
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
-var getTemplatesDir = () => {
-  return path.resolve(__dirname2, "../templates");
-};
+
+// src/shared/validators/path-validators.ts
+import path from "path";
 var validateTemplateName = (template) => {
   const sanitized = path.basename(template);
   if (sanitized !== template || template.includes("..")) {
@@ -66,15 +62,30 @@ var validateTargetDir = (targetDir) => {
     }
   }
 };
+
+// src/features/templates/template-path-resolver.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path2.dirname(__filename2);
+var getTemplatesDir = () => {
+  return path2.resolve(__dirname2, "../templates");
+};
+var getTemplatePath = (template) => {
+  validateTemplateName(template);
+  return path2.join(getTemplatesDir(), template);
+};
+
+// src/features/templates/template-installer.ts
+import fs2 from "fs-extra";
+import path4 from "path";
+
+// src/shared/filesystem/copy-utils.ts
+import fs from "fs-extra";
+import path3 from "path";
 var hasFiles = async (dir) => {
   if (!await fs.pathExists(dir)) return false;
   const items = await fs.readdir(dir);
   return items.length > 0;
 };
-var getTemplatePath = (template) => {
-  validateTemplateName(template);
-  return path.join(getTemplatesDir(), template);
-};
 var copyRecursive = async (src, dest, counter) => {
   const stat = await fs.stat(src);
   if (stat.isDirectory()) {
@@ -82,76 +93,33 @@ var copyRecursive = async (src, dest, counter) => {
     counter.directories++;
     const items = await fs.readdir(src);
     for (const item of items) {
-      await copyRecursive(path.join(src, item), path.join(dest, item), counter);
+      await copyRecursive(path3.join(src, item), path3.join(dest, item), counter);
     }
   } else {
     await fs.copy(src, dest);
     counter.files++;
   }
 };
-var copySingleTemplate = async (template, targetDir) => {
-  validateTargetDir(targetDir);
-  const templatePath = getTemplatePath(template);
-  if (!await fs.pathExists(templatePath)) {
-    throw new Error(`Template "${template}" not found at ${templatePath}`);
-  }
-  const counter = { files: 0, directories: 0 };
-  const claudeMdSrc = path.join(templatePath, "CLAUDE.md");
-  if (await fs.pathExists(claudeMdSrc)) {
-    await fs.copy(claudeMdSrc, path.join(targetDir, "CLAUDE.md"));
-    counter.files++;
-  }
-  const docsSrc = path.join(templatePath, "docs");
-  const docsDest = path.join(targetDir, "docs");
-  if (await fs.pathExists(docsSrc)) {
-    if (await fs.pathExists(docsDest)) {
-      await fs.remove(docsDest);
-    }
-    await copyRecursive(docsSrc, docsDest, counter);
-  }
-  return counter;
-};
-var copyMultipleTemplates = async (templates, targetDir) => {
-  validateTargetDir(targetDir);
-  const counter = { files: 0, directories: 0 };
-  const docsDir = path.join(targetDir, "docs");
-  if (await fs.pathExists(docsDir)) {
-    await fs.remove(docsDir);
-  }
-  for (const template of templates) {
-    const templatePath = getTemplatePath(template);
-    if (!await fs.pathExists(templatePath)) {
-      throw new Error(`Template "${template}" not found at ${templatePath}`);
-    }
-    await copyRecursive(
-      templatePath,
-      path.join(targetDir, "docs", template),
-      counter
-    );
+
+// src/features/templates/template-metadata.ts
+var templateMetadata = {
+  "tanstack-start": {
+    name: "TanStack Start",
+    description: "React + TanStack Router SSR \uD480\uC2A4\uD0DD \uD504\uB85C\uC81D\uD2B8",
+    stack: "React, TanStack Router, Vite, TypeScript"
+  },
+  hono: {
+    name: "Hono",
+    description: "Edge Runtime \uBC31\uC5D4\uB4DC API \uD504\uB85C\uC81D\uD2B8",
+    stack: "Hono, TypeScript, Cloudflare Workers"
+  },
+  npx: {
+    name: "NPX CLI",
+    description: "NPX\uB85C \uC2E4\uD589 \uAC00\uB2A5\uD55C CLI \uB3C4\uAD6C \uD504\uB85C\uC81D\uD2B8",
+    stack: "Node.js, TypeScript, Commander.js"
   }
-  const indexContent = generateIndexClaudeMd(templates);
-  await fs.writeFile(path.join(targetDir, "CLAUDE.md"), indexContent);
-  counter.files++;
-  return counter;
 };
 var generateIndexClaudeMd = (templates) => {
-  const templateMetadata = {
-    "tanstack-start": {
-      name: "TanStack Start",
-      description: "React + TanStack Router SSR \uD480\uC2A4\uD0DD \uD504\uB85C\uC81D\uD2B8",
-      stack: "React, TanStack Router, Vite, TypeScript"
-    },
-    hono: {
-      name: "Hono",
-      description: "Edge Runtime \uBC31\uC5D4\uB4DC API \uD504\uB85C\uC81D\uD2B8",
-      stack: "Hono, TypeScript, Cloudflare Workers"
-    },
-    npx: {
-      name: "NPX CLI",
-      description: "NPX\uB85C \uC2E4\uD589 \uAC00\uB2A5\uD55C CLI \uB3C4\uAD6C \uD504\uB85C\uC81D\uD2B8",
-      stack: "Node.js, TypeScript, Commander.js"
-    }
-  };
   const templateSections = templates.map((template) => {
     const meta = templateMetadata[template] || {
       name: template,
@@ -180,37 +148,94 @@ ${templateSections}
 **\uD604\uC7AC \uD504\uB85C\uC81D\uD2B8\uC5D0 \uB9DE\uB294 \uAC00\uC774\uB4DC\uB97C CLAUDE.md\uC758 \`@\` \uC778\uC2A4\uD2B8\uB7ED\uC158\uC5D0 \uCD94\uAC00\uD558\uC138\uC694.**
 `;
 };
-var checkExistingFiles = async (targetDir) => {
-  const existingFiles = [];
-  const claudeMd = path.join(targetDir, "CLAUDE.md");
-  const docsDir = path.join(targetDir, "docs");
-  if (await fs.pathExists(claudeMd)) {
-    existingFiles.push("CLAUDE.md");
+
+// src/features/templates/template-installer.ts
+var copySingleTemplate = async (template, targetDir) => {
+  validateTargetDir(targetDir);
+  const templatePath = getTemplatePath(template);
+  if (!await fs2.pathExists(templatePath)) {
+    throw new Error(`Template "${template}" not found at ${templatePath}`);
   }
-  if (await fs.pathExists(docsDir)) {
-    existingFiles.push("docs/");
+  const counter = { files: 0, directories: 0 };
+  const claudeMdSrc = path4.join(templatePath, "CLAUDE.md");
+  if (await fs2.pathExists(claudeMdSrc)) {
+    await fs2.copy(claudeMdSrc, path4.join(targetDir, "CLAUDE.md"));
+    counter.files++;
   }
-  return existingFiles;
+  const docsSrc = path4.join(templatePath, "docs");
+  const docsDest = path4.join(targetDir, "docs");
+  if (await fs2.pathExists(docsSrc)) {
+    if (await fs2.pathExists(docsDest)) {
+      await fs2.remove(docsDest);
+    }
+    await copyRecursive(docsSrc, docsDest, counter);
+  }
+  return counter;
+};
+var copyMultipleTemplates = async (templates, targetDir) => {
+  validateTargetDir(targetDir);
+  const counter = { files: 0, directories: 0 };
+  const docsDir = path4.join(targetDir, "docs");
+  if (await fs2.pathExists(docsDir)) {
+    await fs2.remove(docsDir);
+  }
+  for (const template of templates) {
+    const templatePath = getTemplatePath(template);
+    if (!await fs2.pathExists(templatePath)) {
+      throw new Error(`Template "${template}" not found at ${templatePath}`);
+    }
+    await copyRecursive(
+      templatePath,
+      path4.join(targetDir, "docs", template),
+      counter
+    );
+  }
+  const indexContent = generateIndexClaudeMd(templates);
+  await fs2.writeFile(path4.join(targetDir, "CLAUDE.md"), indexContent);
+  counter.files++;
+  return counter;
 };
+
+// src/features/templates/template-discovery.ts
+import fs3 from "fs-extra";
+import path5 from "path";
 var listAvailableTemplates = async () => {
   const templatesDir = getTemplatesDir();
-  if (!await fs.pathExists(templatesDir)) {
+  if (!await fs3.pathExists(templatesDir)) {
     return [];
   }
-  const items = await fs.readdir(templatesDir);
+  const items = await fs3.readdir(templatesDir);
   const templates = [];
   for (const item of items) {
     if (item.startsWith(".")) {
       continue;
     }
-    const itemPath = path.join(templatesDir, item);
-    const stat = await fs.stat(itemPath);
+    const itemPath = path5.join(templatesDir, item);
+    const stat = await fs3.stat(itemPath);
     if (stat.isDirectory()) {
       templates.push(item);
     }
   }
   return templates;
 };
+var checkExistingFiles = async (targetDir) => {
+  const existingFiles = [];
+  const claudeMd = path5.join(targetDir, "CLAUDE.md");
+  const docsDir = path5.join(targetDir, "docs");
+  if (await fs3.pathExists(claudeMd)) {
+    existingFiles.push("CLAUDE.md");
+  }
+  if (await fs3.pathExists(docsDir)) {
+    existingFiles.push("docs/");
+  }
+  return existingFiles;
+};
+
+// src/features/extras/extras-copier.ts
+import fs4 from "fs-extra";
+import path6 from "path";
+
+// src/shared/constants.ts
 var FRAMEWORK_SPECIFIC_SKILLS_MAP = {
   nextjs: ["nextjs-react-best-practices", "korea-uiux-design", "figma-to-code"],
   "tanstack-start": [
@@ -229,14 +254,31 @@ var COMMON_SKILLS = [
   "ralph",
   "execute"
 ];
+
+// src/features/extras/extras-copier.ts
+var createExtrasCopier = (extrasType) => {
+  return async (_templates, targetDir) => {
+    const counter = { files: 0, directories: 0 };
+    const targetExtrasDir = path6.join(targetDir, ".claude", extrasType);
+    const extrasSrc = path6.join(getTemplatesDir(), ".claude", extrasType);
+    if (await fs4.pathExists(extrasSrc)) {
+      await fs4.ensureDir(targetExtrasDir);
+      await copyRecursive(extrasSrc, targetExtrasDir, counter);
+    }
+    return counter;
+  };
+};
+var copyCommands = createExtrasCopier("commands");
+var copyAgents = createExtrasCopier("agents");
+var copyInstructions = createExtrasCopier("instructions");
 var copySkills = async (templates, targetDir) => {
   const counter = { files: 0, directories: 0 };
-  const targetSkillsDir = path.join(targetDir, ".claude", "skills");
-  const skillsSrc = path.join(getTemplatesDir(), ".claude", "skills");
-  if (!await fs.pathExists(skillsSrc)) {
+  const targetSkillsDir = path6.join(targetDir, ".claude", "skills");
+  const skillsSrc = path6.join(getTemplatesDir(), ".claude", "skills");
+  if (!await fs4.pathExists(skillsSrc)) {
     return counter;
   }
-  await fs.ensureDir(targetSkillsDir);
+  await fs4.ensureDir(targetSkillsDir);
   const skillsToCopy = /* @__PURE__ */ new Set();
   const skillTemplateMap = /* @__PURE__ */ new Map();
   COMMON_SKILLS.forEach((skill) => skillsToCopy.add(skill));
@@ -251,11 +293,11 @@ var copySkills = async (templates, targetDir) => {
     });
   }
   for (const skill of skillsToCopy) {
-    const skillSrc = path.join(skillsSrc, skill);
-    const skillDest = path.join(targetSkillsDir, skill);
-    if (await fs.pathExists(skillSrc)) {
-      if (await fs.pathExists(skillDest)) {
-        await fs.remove(skillDest);
+    const skillSrc = path6.join(skillsSrc, skill);
+    const skillDest = path6.join(targetSkillsDir, skill);
+    if (await fs4.pathExists(skillSrc)) {
+      if (await fs4.pathExists(skillDest)) {
+        await fs4.remove(skillDest);
       }
       await copyRecursive(skillSrc, skillDest, counter);
     }
@@ -274,65 +316,35 @@ var copySkills = async (templates, targetDir) => {
     ...duplicateSkills.length > 0 && { duplicateSkills }
   };
 };
-var copyCommands = async (_templates, targetDir) => {
-  const counter = { files: 0, directories: 0 };
-  const targetCommandsDir = path.join(targetDir, ".claude", "commands");
-  const commandsSrc = path.join(getTemplatesDir(), ".claude", "commands");
-  if (await fs.pathExists(commandsSrc)) {
-    await fs.ensureDir(targetCommandsDir);
-    await copyRecursive(commandsSrc, targetCommandsDir, counter);
-  }
-  return counter;
-};
+
+// src/features/extras/extras-checker.ts
+import fs5 from "fs-extra";
+import path7 from "path";
 var checkExistingClaudeFiles = async (targetDir) => {
   const existingFiles = [];
-  const skillsDir = path.join(targetDir, ".claude", "skills");
-  const commandsDir = path.join(targetDir, ".claude", "commands");
-  const agentsDir = path.join(targetDir, ".claude", "agents");
-  const instructionsDir = path.join(targetDir, ".claude", "instructions");
-  if (await fs.pathExists(skillsDir)) {
+  const skillsDir = path7.join(targetDir, ".claude", "skills");
+  const commandsDir = path7.join(targetDir, ".claude", "commands");
+  const agentsDir = path7.join(targetDir, ".claude", "agents");
+  const instructionsDir = path7.join(targetDir, ".claude", "instructions");
+  if (await fs5.pathExists(skillsDir)) {
     existingFiles.push(".claude/skills/");
   }
-  if (await fs.pathExists(commandsDir)) {
+  if (await fs5.pathExists(commandsDir)) {
     existingFiles.push(".claude/commands/");
   }
-  if (await fs.pathExists(agentsDir)) {
+  if (await fs5.pathExists(agentsDir)) {
     existingFiles.push(".claude/agents/");
   }
-  if (await fs.pathExists(instructionsDir)) {
+  if (await fs5.pathExists(instructionsDir)) {
     existingFiles.push(".claude/instructions/");
   }
   return existingFiles;
 };
-var copyAgents = async (_templates, targetDir) => {
-  const counter = { files: 0, directories: 0 };
-  const targetAgentsDir = path.join(targetDir, ".claude", "agents");
-  const agentsSrc = path.join(getTemplatesDir(), ".claude", "agents");
-  if (await fs.pathExists(agentsSrc)) {
-    await fs.ensureDir(targetAgentsDir);
-    await copyRecursive(agentsSrc, targetAgentsDir, counter);
-  }
-  return counter;
-};
-var copyInstructions = async (_templates, targetDir) => {
-  const counter = { files: 0, directories: 0 };
-  const targetInstructionsDir = path.join(targetDir, ".claude", "instructions");
-  const instructionsSrc = path.join(
-    getTemplatesDir(),
-    ".claude",
-    "instructions"
-  );
-  if (await fs.pathExists(instructionsSrc)) {
-    await fs.ensureDir(targetInstructionsDir);
-    await copyRecursive(instructionsSrc, targetInstructionsDir, counter);
-  }
-  return counter;
-};
 var checkAllExtrasExist = async (templates) => {
-  const claudeDir = path.join(getTemplatesDir(), ".claude");
-  const commandsSrc = path.join(claudeDir, "commands");
-  const agentsSrc = path.join(claudeDir, "agents");
-  const instructionsSrc = path.join(claudeDir, "instructions");
+  const claudeDir = path7.join(getTemplatesDir(), ".claude");
+  const commandsSrc = path7.join(claudeDir, "commands");
+  const agentsSrc = path7.join(claudeDir, "agents");
+  const instructionsSrc = path7.join(claudeDir, "instructions");
   const hasFrameworkSkills = templates.some((template) => {
     const skills = FRAMEWORK_SPECIFIC_SKILLS_MAP[template];
     return skills && skills.length > 0;
@@ -344,16 +356,336 @@ var checkAllExtrasExist = async (templates) => {
   return { hasSkills, hasCommands, hasAgents, hasInstructions };
 };
 
+// src/shared/prompts/prompt-helpers.ts
+import prompts from "prompts";
+async function promptConfirm(message, initial = false) {
+  const response = await prompts({
+    type: "confirm",
+    name: "confirmed",
+    message,
+    initial
+  });
+  return { confirmed: response.confirmed ?? false };
+}
+async function promptSelect(message, choices) {
+  const response = await prompts({
+    type: "select",
+    name: "value",
+    message,
+    choices
+  });
+  return { value: response.value };
+}
+async function promptMultiselect(message, choices, options) {
+  const response = await prompts({
+    type: "multiselect",
+    name: "values",
+    message,
+    choices,
+    min: options?.min,
+    hint: options?.hint
+  });
+  return { values: response.values || [] };
+}
+
+// src/shared/prompts/prompt-functions.ts
+async function promptTemplateSelection(options) {
+  const { providedTemplates, availableTemplates, templateDescriptions } = options;
+  let templates = providedTemplates || [];
+  if (templates.length === 0) {
+    const response = await promptMultiselect(
+      "Select templates (space to select, enter to confirm):",
+      availableTemplates.map((t) => ({
+        title: t,
+        description: templateDescriptions[t] || "",
+        value: t
+      })),
+      {
+        min: 1,
+        hint: "- Space to select. Return to submit"
+      }
+    );
+    if (response.values.length === 0) {
+      logger.warn("Operation cancelled.");
+      process.exit(0);
+    }
+    templates = response.values;
+  }
+  const invalidTemplates = templates.filter(
+    (t) => !availableTemplates.includes(t)
+  );
+  if (invalidTemplates.length > 0) {
+    logger.error(`Templates not found: ${invalidTemplates.join(", ")}`);
+    logger.info(`Available templates: ${availableTemplates.join(", ")}`);
+    process.exit(1);
+  }
+  return { templates };
+}
+async function promptOverwrite(options) {
+  const { existingFiles, force } = options;
+  if (existingFiles.length > 0 && !force) {
+    logger.warn("The following files/folders already exist:");
+    existingFiles.forEach((f) => logger.step(f));
+    logger.blank();
+    const result = await promptConfirm("Overwrite existing files?", false);
+    if (!result.confirmed) {
+      logger.info("Operation cancelled.");
+      process.exit(0);
+    }
+  }
+}
+async function promptExtrasSelection(options) {
+  const {
+    skills,
+    commands,
+    agents,
+    instructions,
+    hasSkills,
+    hasCommands,
+    hasAgents,
+    hasInstructions
+  } = options;
+  let installSkills = skills ?? false;
+  let installCommands = commands ?? false;
+  let installAgents = agents ?? hasAgents;
+  let installInstructions = instructions ?? hasInstructions;
+  const noOptionsProvided = skills === void 0 && commands === void 0 && agents === void 0 && instructions === void 0;
+  if (noOptionsProvided && (hasSkills || hasCommands || hasAgents || hasInstructions)) {
+    logger.blank();
+    if (hasSkills) {
+      const result = await promptConfirm(
+        "Install skills to .claude/skills/?",
+        false
+      );
+      installSkills = result.confirmed;
+    }
+    if (hasCommands) {
+      const result = await promptConfirm(
+        "Install commands to .claude/commands/?",
+        false
+      );
+      installCommands = result.confirmed;
+    }
+  }
+  return {
+    installSkills,
+    installCommands,
+    installAgents,
+    installInstructions
+  };
+}
+
+// src/features/extras/extras-installer.ts
+async function handleDuplicateFiles(existingClaudeFiles, force) {
+  if (existingClaudeFiles.length === 0 || force) {
+    return true;
+  }
+  logger.warn("The following .claude files/folders already exist:");
+  existingClaudeFiles.forEach((f) => logger.step(f));
+  logger.blank();
+  const response = await promptConfirm(
+    "Overwrite existing .claude files?",
+    false
+  );
+  return response.confirmed;
+}
+async function handleDuplicateSkills(duplicateSkills, templates, targetDir) {
+  logger.blank();
+  logger.warn("The following skills are included in multiple templates:");
+  duplicateSkills.forEach(({ skill, templates: skillTemplates }) => {
+    logger.step(`${skill} (${skillTemplates.join(", ")})`);
+  });
+  logger.blank();
+  const response = await promptSelect(
+    "Which template's version should be used?",
+    templates.map((t) => ({
+      title: t,
+      value: t
+    }))
+  );
+  if (response.value) {
+    logger.info(`Reinstalling skills with ${response.value} template...`);
+    const reinstallResult = await copySkills([response.value], targetDir);
+    logger.success(
+      `Skills: ${reinstallResult.files} files, ${reinstallResult.directories} directories`
+    );
+    return reinstallResult;
+  } else {
+    logger.warn("No template selected. Using all templates.");
+    return { files: 0, directories: 0 };
+  }
+}
+async function installSkillsIfNeeded(templates, targetDir, shouldInstall, hasSkills) {
+  if (!shouldInstall) {
+    return { files: 0, directories: 0 };
+  }
+  if (!hasSkills) {
+    logger.warn("No skills found in selected templates.");
+    return { files: 0, directories: 0 };
+  }
+  logger.blank();
+  logger.info("Installing skills...");
+  const skillsResult = await copySkills(templates, targetDir);
+  if (skillsResult.duplicateSkills && skillsResult.duplicateSkills.length > 0) {
+    return await handleDuplicateSkills(
+      skillsResult.duplicateSkills,
+      templates,
+      targetDir
+    );
+  }
+  logger.success(
+    `Skills: ${skillsResult.files} files, ${skillsResult.directories} directories`
+  );
+  return skillsResult;
+}
+async function installCommandsIfNeeded(templates, targetDir, shouldInstall, hasCommands) {
+  if (!shouldInstall) {
+    return { files: 0, directories: 0 };
+  }
+  if (!hasCommands) {
+    logger.warn("No commands found in selected templates.");
+    return { files: 0, directories: 0 };
+  }
+  logger.blank();
+  logger.info("Installing commands...");
+  const commandsResult = await copyCommands(templates, targetDir);
+  logger.success(
+    `Commands: ${commandsResult.files} files, ${commandsResult.directories} directories`
+  );
+  return commandsResult;
+}
+async function installAgentsIfNeeded(templates, targetDir, shouldInstall, hasAgents) {
+  if (!shouldInstall) {
+    return { files: 0, directories: 0 };
+  }
+  if (!hasAgents) {
+    logger.warn("No agents found in selected templates.");
+    return { files: 0, directories: 0 };
+  }
+  logger.blank();
+  logger.info("Installing agents...");
+  const agentsResult = await copyAgents(templates, targetDir);
+  logger.success(
+    `Agents: ${agentsResult.files} files, ${agentsResult.directories} directories`
+  );
+  return agentsResult;
+}
+async function installInstructionsIfNeeded(templates, targetDir, shouldInstall, hasInstructions) {
+  if (!shouldInstall) {
+    return { files: 0, directories: 0 };
+  }
+  if (!hasInstructions) {
+    logger.warn("No instructions found in selected templates.");
+    return { files: 0, directories: 0 };
+  }
+  logger.blank();
+  logger.info("Installing instructions...");
+  const instructionsResult = await copyInstructions(templates, targetDir);
+  logger.success(
+    `Instructions: ${instructionsResult.files} files, ${instructionsResult.directories} directories`
+  );
+  return instructionsResult;
+}
+async function installExtras(templates, targetDir, flags, availability, force) {
+  const { installSkills, installCommands, installAgents, installInstructions } = flags;
+  if (!installSkills && !installCommands && !installAgents && !installInstructions) {
+    return { files: 0, directories: 0 };
+  }
+  const existingClaudeFiles = await checkExistingClaudeFiles(targetDir);
+  const shouldProceed = await handleDuplicateFiles(existingClaudeFiles, force);
+  if (!shouldProceed) {
+    logger.info("Skipping extras installation.");
+    return { files: 0, directories: 0 };
+  }
+  const skillsResult = await installSkillsIfNeeded(
+    templates,
+    targetDir,
+    installSkills,
+    availability.hasSkills
+  );
+  const commandsResult = await installCommandsIfNeeded(
+    templates,
+    targetDir,
+    installCommands,
+    availability.hasCommands
+  );
+  const agentsResult = await installAgentsIfNeeded(
+    templates,
+    targetDir,
+    installAgents,
+    availability.hasAgents
+  );
+  const instructionsResult = await installInstructionsIfNeeded(
+    templates,
+    targetDir,
+    installInstructions,
+    availability.hasInstructions
+  );
+  const totalFiles = skillsResult.files + commandsResult.files + agentsResult.files + instructionsResult.files;
+  const totalDirectories = skillsResult.directories + commandsResult.directories + agentsResult.directories + instructionsResult.directories;
+  return { files: totalFiles, directories: totalDirectories };
+}
+
+// src/shared/gitignore-manager.ts
+import fs6 from "fs-extra";
+import path8 from "path";
+var CLAUDE_GENERATED_FOLDERS = [
+  ".claude/plan/",
+  ".claude/ralph/",
+  ".claude/refactor/"
+];
+async function updateGitignore(targetDir) {
+  const gitignorePath = path8.join(targetDir, ".gitignore");
+  const sectionComment = "# Claude Code generated files";
+  let content = "";
+  let hasGitignore = false;
+  try {
+    content = await fs6.readFile(gitignorePath, "utf-8");
+    hasGitignore = true;
+  } catch (error) {
+    content = "";
+  }
+  if (content.includes(sectionComment)) {
+    logger.info(".gitignore already contains Claude Code section");
+    return;
+  }
+  const linesToAdd = [];
+  const existingLines = content.split("\n").map((line) => line.trim());
+  for (const folder of CLAUDE_GENERATED_FOLDERS) {
+    if (!existingLines.includes(folder)) {
+      linesToAdd.push(folder);
+    }
+  }
+  if (linesToAdd.length === 0) {
+    logger.info(".gitignore already contains all Claude Code patterns");
+    return;
+  }
+  let newContent = content;
+  if (newContent && !newContent.endsWith("\n")) {
+    newContent += "\n";
+  }
+  if (newContent) {
+    newContent += "\n";
+  }
+  newContent += sectionComment + "\n";
+  newContent += linesToAdd.join("\n") + "\n";
+  await fs6.writeFile(gitignorePath, newContent, "utf-8");
+  if (hasGitignore) {
+    logger.success(`.gitignore updated with ${linesToAdd.length} patterns`);
+  } else {
+    logger.success(`.gitignore created with ${linesToAdd.length} patterns`);
+  }
+}
+
 // src/commands/init.ts
 var TEMPLATE_DESCRIPTIONS = {
   "tanstack-start": "TanStack Start + React \uD480\uC2A4\uD0DD \uD504\uB85C\uC81D\uD2B8",
   hono: "Hono \uC11C\uBC84 \uD504\uB808\uC784\uC6CC\uD06C \uD504\uB85C\uC81D\uD2B8",
   npx: "NPX CLI \uB3C4\uAD6C \uD504\uB85C\uC81D\uD2B8"
 };
-var init = async (options) => {
-  const targetDir = options.cwd || process.cwd();
+async function validateTargetDirectory(targetDir) {
   try {
-    const stat = await fs2.stat(targetDir);
+    const stat = await fs7.stat(targetDir);
     if (!stat.isDirectory()) {
       logger.error(`Target is not a directory: ${targetDir}`);
       process.exit(1);
@@ -367,60 +699,25 @@ var init = async (options) => {
     process.exit(1);
   }
   try {
-    await fs2.access(targetDir, fs2.constants.W_OK);
+    await fs7.access(targetDir, fs7.constants.W_OK);
   } catch {
     logger.error(`No write permission for: ${targetDir}`);
     process.exit(1);
   }
-  const availableTemplates = await listAvailableTemplates();
-  if (availableTemplates.length === 0) {
-    logger.error("No templates found. Package may be corrupted.");
-    process.exit(1);
-  }
-  let templates = options.templates || [];
-  if (templates.length === 0) {
-    const response = await prompts({
-      type: "multiselect",
-      name: "templates",
-      message: "Select templates (space to select, enter to confirm):",
-      choices: availableTemplates.map((t) => ({
-        title: t,
-        description: TEMPLATE_DESCRIPTIONS[t] || "",
-        value: t
-      })),
-      min: 1,
-      hint: "- Space to select. Return to submit"
-    });
-    if (!response.templates || response.templates.length === 0) {
-      logger.warn("Operation cancelled.");
-      process.exit(0);
-    }
-    templates = response.templates;
-  }
-  const invalidTemplates = templates.filter(
-    (t) => !availableTemplates.includes(t)
-  );
-  if (invalidTemplates.length > 0) {
-    logger.error(`Templates not found: ${invalidTemplates.join(", ")}`);
-    logger.info(`Available templates: ${availableTemplates.join(", ")}`);
-    process.exit(1);
-  }
+}
+async function selectTemplates(options, availableTemplates) {
+  const result = await promptTemplateSelection({
+    providedTemplates: options.templates,
+    availableTemplates,
+    templateDescriptions: TEMPLATE_DESCRIPTIONS
+  });
+  return result.templates;
+}
+async function confirmOverwriteIfNeeded(targetDir, force) {
   const existingFiles = await checkExistingFiles(targetDir);
-  if (existingFiles.length > 0 && !options.force) {
-    logger.warn("The following files/folders already exist:");
-    existingFiles.forEach((f) => logger.step(f));
-    logger.blank();
-    const response = await prompts({
-      type: "confirm",
-      name: "overwrite",
-      message: "Overwrite existing files?",
-      initial: false
-    });
-    if (!response.overwrite) {
-      logger.info("Operation cancelled.");
-      process.exit(0);
-    }
-  }
+  await promptOverwrite({ existingFiles, force });
+}
+async function installTemplates(templates, targetDir) {
   const isSingleTemplate = templates.length === 1;
   let totalFiles = 0;
   let totalDirectories = 0;
@@ -454,154 +751,27 @@ var init = async (options) => {
   }
   logger.blank();
   logger.success(`Total: ${totalFiles} files, ${totalDirectories} directories`);
-  const { hasSkills, hasCommands, hasAgents, hasInstructions } = await checkAllExtrasExist(templates);
-  let installSkills = options.skills ?? false;
-  let installCommands = options.commands ?? false;
-  let installAgents = options.agents ?? false;
-  let installInstructions = options.instructions ?? false;
-  const noOptionsProvided = options.skills === void 0 && options.commands === void 0 && options.agents === void 0 && options.instructions === void 0;
-  if (noOptionsProvided && (hasSkills || hasCommands || hasAgents || hasInstructions)) {
-    logger.blank();
-    if (hasSkills) {
-      const skillsResponse = await prompts({
-        type: "confirm",
-        name: "install",
-        message: "Install skills to .claude/skills/?",
-        initial: false
-      });
-      installSkills = skillsResponse.install ?? false;
-    }
-    if (hasCommands) {
-      const commandsResponse = await prompts({
-        type: "confirm",
-        name: "install",
-        message: "Install commands to .claude/commands/?",
-        initial: false
-      });
-      installCommands = commandsResponse.install ?? false;
-    }
-    if (hasAgents) {
-      installAgents = true;
-    }
-    if (hasInstructions) {
-      installInstructions = true;
-    }
-  }
-  if (installSkills || installCommands || installAgents || installInstructions) {
-    const existingClaudeFiles = await checkExistingClaudeFiles(targetDir);
-    if (existingClaudeFiles.length > 0 && !options.force) {
-      logger.warn("The following .claude files/folders already exist:");
-      existingClaudeFiles.forEach((f) => logger.step(f));
-      logger.blank();
-      const response = await prompts({
-        type: "confirm",
-        name: "overwrite",
-        message: "Overwrite existing .claude files?",
-        initial: false
-      });
-      if (!response.overwrite) {
-        logger.info("Skipping extras installation.");
-        installSkills = false;
-        installCommands = false;
-        installAgents = false;
-        installInstructions = false;
-      }
-    }
-    if (installSkills && hasSkills) {
-      logger.blank();
-      logger.info("Installing skills...");
-      const skillsResult = await copySkills(templates, targetDir);
-      if (skillsResult.duplicateSkills && skillsResult.duplicateSkills.length > 0) {
-        logger.blank();
-        logger.warn("The following skills are included in multiple templates:");
-        skillsResult.duplicateSkills.forEach(
-          ({ skill, templates: skillTemplates }) => {
-            logger.step(`${skill} (${skillTemplates.join(", ")})`);
-          }
-        );
-        logger.blank();
-        const response = await prompts({
-          type: "select",
-          name: "selectedTemplate",
-          message: "Which template's version should be used?",
-          choices: templates.map((t) => ({
-            title: t,
-            value: t
-          }))
-        });
-        if (response.selectedTemplate) {
-          logger.info(
-            `Reinstalling skills with ${response.selectedTemplate} template...`
-          );
-          const reinstallResult = await copySkills(
-            [response.selectedTemplate],
-            targetDir
-          );
-          totalFiles += reinstallResult.files;
-          totalDirectories += reinstallResult.directories;
-          logger.success(
-            `Skills: ${reinstallResult.files} files, ${reinstallResult.directories} directories`
-          );
-        } else {
-          logger.warn("No template selected. Using all templates.");
-          totalFiles += skillsResult.files;
-          totalDirectories += skillsResult.directories;
-          logger.success(
-            `Skills: ${skillsResult.files} files, ${skillsResult.directories} directories`
-          );
-        }
-      } else {
-        totalFiles += skillsResult.files;
-        totalDirectories += skillsResult.directories;
-        logger.success(
-          `Skills: ${skillsResult.files} files, ${skillsResult.directories} directories`
-        );
-      }
-    } else if (installSkills && !hasSkills) {
-      logger.warn("No skills found in selected templates.");
-    }
-    if (installCommands && hasCommands) {
-      logger.blank();
-      logger.info("Installing commands...");
-      const commandsResult = await copyCommands(templates, targetDir);
-      totalFiles += commandsResult.files;
-      totalDirectories += commandsResult.directories;
-      logger.success(
-        `Commands: ${commandsResult.files} files, ${commandsResult.directories} directories`
-      );
-    } else if (installCommands && !hasCommands) {
-      logger.warn("No commands found in selected templates.");
-    }
-    if (installAgents && hasAgents) {
-      logger.blank();
-      logger.info("Installing agents...");
-      const agentsResult = await copyAgents(templates, targetDir);
-      totalFiles += agentsResult.files;
-      totalDirectories += agentsResult.directories;
-      logger.success(
-        `Agents: ${agentsResult.files} files, ${agentsResult.directories} directories`
-      );
-    } else if (installAgents && !hasAgents) {
-      logger.warn("No agents found in selected templates.");
-    }
-    if (installInstructions && hasInstructions) {
-      logger.blank();
-      logger.info("Installing instructions...");
-      const instructionsResult = await copyInstructions(templates, targetDir);
-      totalFiles += instructionsResult.files;
-      totalDirectories += instructionsResult.directories;
-      logger.success(
-        `Instructions: ${instructionsResult.files} files, ${instructionsResult.directories} directories`
-      );
-    } else if (installInstructions && !hasInstructions) {
-      logger.warn("No instructions found in selected templates.");
-    }
-  }
+  return { files: totalFiles, directories: totalDirectories };
+}
+async function promptForExtrasInstallation(options, hasSkills, hasCommands, hasAgents, hasInstructions) {
+  return await promptExtrasSelection({
+    skills: options.skills,
+    commands: options.commands,
+    agents: options.agents,
+    instructions: options.instructions,
+    hasSkills,
+    hasCommands,
+    hasAgents,
+    hasInstructions
+  });
+}
+function showInstallationSummary(templates, flags, hasSkills, hasCommands, hasAgents, hasInstructions) {
   logger.blank();
   logger.success("Claude Code documentation installed!");
   logger.blank();
   logger.info("Installed templates:");
   templates.forEach((t) => logger.step(t));
+  const { installSkills, installCommands, installAgents, installInstructions } = flags;
   if (installSkills && hasSkills || installCommands && hasCommands || installAgents && hasAgents || installInstructions && hasInstructions) {
     logger.blank();
     logger.info("Installed extras:");
@@ -623,11 +793,53 @@ var init = async (options) => {
   logger.step("Read CLAUDE.md for project guidelines");
   logger.step("Explore docs/ for detailed documentation");
   logger.blank();
+}
+var init = async (options) => {
+  const targetDir = options.cwd || process.cwd();
+  await validateTargetDirectory(targetDir);
+  const availableTemplates = await listAvailableTemplates();
+  if (availableTemplates.length === 0) {
+    logger.error("No templates found. Package may be corrupted.");
+    process.exit(1);
+  }
+  const templates = await selectTemplates(options, availableTemplates);
+  await confirmOverwriteIfNeeded(targetDir, options.force ?? false);
+  await installTemplates(templates, targetDir);
+  const { hasSkills, hasCommands, hasAgents, hasInstructions } = await checkAllExtrasExist(templates);
+  const flags = await promptForExtrasInstallation(
+    options,
+    hasSkills,
+    hasCommands,
+    hasAgents,
+    hasInstructions
+  );
+  await installExtras(
+    templates,
+    targetDir,
+    flags,
+    { hasSkills, hasCommands, hasAgents, hasInstructions },
+    options.force ?? false
+  );
+  showInstallationSummary(
+    templates,
+    flags,
+    hasSkills,
+    hasCommands,
+    hasAgents,
+    hasInstructions
+  );
+  try {
+    await updateGitignore(targetDir);
+  } catch (error) {
+    logger.warn(
+      `Failed to update .gitignore: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
 };
 
 // src/index.ts
 var program = new Command();
-program.name("claude-code").description("Claude Code documentation installer for projects").version("0.5.3");
+program.name("claude-code").description("Claude Code documentation installer for projects").version("0.5.5");
 program.option(
   "-t, --template <names>",
   "template names (comma-separated: tanstack-start,hono)"