@kood/claude-code 0.1.6 → 0.1.9

package/dist/index.js

@@ -88,8 +88,26 @@ var copyMultipleTemplates = async (templates, targetDir) => {
       counter
     );
   }
+  const indexContent = generateIndexClaudeMd(templates);
+  await fs.writeFile(path.join(targetDir, "CLAUDE.md"), indexContent);
+  counter.files++;
   return counter;
 };
+var generateIndexClaudeMd = (templates) => {
+  const templateLinks = templates.map((t) => `- [${t}](docs/${t}/CLAUDE.md)`).join("\n");
+  return `# CLAUDE.md
+
+> \uC774 \uD504\uB85C\uC81D\uD2B8\uB294 \uC5EC\uB7EC \uD15C\uD50C\uB9BF\uC758 Claude Code \uBB38\uC11C\uB97C \uD3EC\uD568\uD569\uB2C8\uB2E4.
+
+## \uD15C\uD50C\uB9BF \uBB38\uC11C
+
+${templateLinks}
+
+## \uC0AC\uC6A9\uBC95
+
+\uAC01 \uD15C\uD50C\uB9BF\uC758 \`CLAUDE.md\`\uB97C \uCC38\uC870\uD558\uC5EC \uD574\uB2F9 \uAE30\uC220 \uC2A4\uD0DD\uC758 \uAC00\uC774\uB4DC\uB77C\uC778\uC744 \uD655\uC778\uD558\uC138\uC694.
+`;
+};
 var checkExistingFiles = async (targetDir) => {
   const existingFiles = [];
   const claudeMd = path.join(targetDir, "CLAUDE.md");
@@ -118,122 +136,59 @@ var listAvailableTemplates = async () => {
   }
   return templates;
 };
-var getSkillsPath = (template) => {
-  return path.join(getTemplatePath(template), "docs", "skills");
-};
-var listAvailableSkills = async (template) => {
-  const skillsPath = getSkillsPath(template);
-  if (!await fs.pathExists(skillsPath)) {
-    return [];
-  }
-  const items = await fs.readdir(skillsPath);
-  const skills = [];
-  for (const item of items) {
-    const itemPath = path.join(skillsPath, item);
-    const stat = await fs.stat(itemPath);
-    if (stat.isDirectory()) {
-      skills.push(item);
-    }
-  }
-  return skills;
-};
-var copySkills = async (template, targetDir) => {
-  const skillsPath = getSkillsPath(template);
+var copySkills = async (templates, targetDir) => {
+  const counter = { files: 0, directories: 0 };
   const targetSkillsDir = path.join(targetDir, ".claude", "skills");
-  if (!await fs.pathExists(skillsPath)) {
-    return { files: 0, directories: 0, skills: [] };
-  }
-  let files = 0;
-  let directories = 0;
-  const installedSkills = [];
-  const copyRecursive2 = async (src, dest) => {
-    const stat = await fs.stat(src);
-    if (stat.isDirectory()) {
-      await fs.ensureDir(dest);
-      directories++;
-      const items = await fs.readdir(src);
-      for (const item of items) {
-        await copyRecursive2(path.join(src, item), path.join(dest, item));
-      }
-    } else {
-      await fs.copy(src, dest);
-      files++;
-    }
-  };
-  const skillItems = await fs.readdir(skillsPath);
-  for (const skill of skillItems) {
-    const skillSrcPath = path.join(skillsPath, skill);
-    const skillDestPath = path.join(targetSkillsDir, skill);
-    const stat = await fs.stat(skillSrcPath);
-    if (stat.isDirectory()) {
-      await copyRecursive2(skillSrcPath, skillDestPath);
-      installedSkills.push(skill);
+  for (const template of templates) {
+    const templatePath = getTemplatePath(template);
+    const skillsSrc = path.join(templatePath, "docs", "skills");
+    if (await fs.pathExists(skillsSrc)) {
+      await fs.ensureDir(targetSkillsDir);
+      await copyRecursive(skillsSrc, targetSkillsDir, counter);
     }
   }
-  return { files, directories, skills: installedSkills };
+  return counter;
 };
-var checkExistingSkills = async (targetDir, skills) => {
-  const existingSkills = [];
-  const targetSkillsDir = path.join(targetDir, ".claude", "skills");
-  for (const skill of skills) {
-    const skillPath = path.join(targetSkillsDir, skill);
-    if (await fs.pathExists(skillPath)) {
-      existingSkills.push(skill);
+var copyCommands = async (templates, targetDir) => {
+  const counter = { files: 0, directories: 0 };
+  const targetCommandsDir = path.join(targetDir, ".claude", "commands");
+  for (const template of templates) {
+    const templatePath = getTemplatePath(template);
+    const commandsSrc = path.join(templatePath, "docs", "commands");
+    if (await fs.pathExists(commandsSrc)) {
+      await fs.ensureDir(targetCommandsDir);
+      await copyRecursive(commandsSrc, targetCommandsDir, counter);
     }
   }
-  return existingSkills;
-};
-var getCommandsPath = (template) => {
-  return path.join(getTemplatePath(template), "docs", "commands");
+  return counter;
 };
-var listAvailableCommands = async (template) => {
-  const commandsPath = getCommandsPath(template);
-  if (!await fs.pathExists(commandsPath)) {
-    return [];
-  }
-  const items = await fs.readdir(commandsPath);
-  const commands = [];
-  for (const item of items) {
-    const itemPath = path.join(commandsPath, item);
-    const stat = await fs.stat(itemPath);
-    if (stat.isFile() && item.endsWith(".md")) {
-      commands.push(item.replace(".md", ""));
+var checkSkillsAndCommandsExist = async (templates) => {
+  let hasSkills = false;
+  let hasCommands = false;
+  for (const template of templates) {
+    const templatePath = getTemplatePath(template);
+    const skillsSrc = path.join(templatePath, "docs", "skills");
+    const commandsSrc = path.join(templatePath, "docs", "commands");
+    if (await fs.pathExists(skillsSrc)) {
+      hasSkills = true;
     }
-  }
-  return commands;
-};
-var copyCommands = async (template, targetDir) => {
-  const commandsPath = getCommandsPath(template);
-  const targetCommandsDir = path.join(targetDir, ".claude", "commands");
-  if (!await fs.pathExists(commandsPath)) {
-    return { files: 0, commands: [] };
-  }
-  let files = 0;
-  const installedCommands = [];
-  await fs.ensureDir(targetCommandsDir);
-  const items = await fs.readdir(commandsPath);
-  for (const item of items) {
-    const srcPath = path.join(commandsPath, item);
-    const stat = await fs.stat(srcPath);
-    if (stat.isFile() && item.endsWith(".md")) {
-      const destPath = path.join(targetCommandsDir, item);
-      await fs.copy(srcPath, destPath);
-      files++;
-      installedCommands.push(item.replace(".md", ""));
+    if (await fs.pathExists(commandsSrc)) {
+      hasCommands = true;
     }
   }
-  return { files, commands: installedCommands };
+  return { hasSkills, hasCommands };
 };
-var checkExistingCommands = async (targetDir, commands) => {
-  const existingCommands = [];
-  const targetCommandsDir = path.join(targetDir, ".claude", "commands");
-  for (const command of commands) {
-    const commandPath = path.join(targetCommandsDir, `${command}.md`);
-    if (await fs.pathExists(commandPath)) {
-      existingCommands.push(command);
-    }
+var checkExistingClaudeFiles = async (targetDir) => {
+  const existingFiles = [];
+  const skillsDir = path.join(targetDir, ".claude", "skills");
+  const commandsDir = path.join(targetDir, ".claude", "commands");
+  if (await fs.pathExists(skillsDir)) {
+    existingFiles.push(".claude/skills/");
+  }
+  if (await fs.pathExists(commandsDir)) {
+    existingFiles.push(".claude/commands/");
   }
-  return existingCommands;
+  return existingFiles;
 };
 
 // src/commands/init.ts
@@ -296,8 +251,6 @@ var init = async (options) => {
   const isSingleTemplate = templates.length === 1;
   let totalFiles = 0;
   let totalDirectories = 0;
-  const allSkills = [];
-  const allCommands = [];
   logger.blank();
   try {
     if (isSingleTemplate) {
@@ -309,10 +262,6 @@ var init = async (options) => {
       totalFiles = result.files;
       totalDirectories = result.directories;
       logger.success(`${template}: ${result.files} files copied`);
-      const availableSkills = await listAvailableSkills(template);
-      allSkills.push(...availableSkills);
-      const availableCommands = await listAvailableCommands(template);
-      allCommands.push(...availableCommands);
     } else {
       logger.info(`Installing ${templates.length} templates...`);
       logger.step(`Target: ${targetDir}/docs/`);
@@ -322,18 +271,6 @@ var init = async (options) => {
       totalDirectories = result.directories;
       for (const template of templates) {
         logger.success(`${template}: installed to docs/${template}/`);
-        const availableSkills = await listAvailableSkills(template);
-        for (const skill of availableSkills) {
-          if (!allSkills.includes(skill)) {
-            allSkills.push(skill);
-          }
-        }
-        const availableCommands = await listAvailableCommands(template);
-        for (const command of availableCommands) {
-          if (!allCommands.includes(command)) {
-            allCommands.push(command);
-          }
-        }
       }
     }
   } catch (error) {
@@ -344,127 +281,83 @@ var init = async (options) => {
   }
   logger.blank();
   logger.success(`Total: ${totalFiles} files, ${totalDirectories} directories`);
-  if (allSkills.length > 0) {
-    let installSkills = options.skills;
-    if (installSkills === void 0) {
+  if (options.skills || options.commands) {
+    const { hasSkills, hasCommands } = await checkSkillsAndCommandsExist(templates);
+    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: "installSkills",
-        message: `Install Claude Code skills? (${allSkills.join(", ")})`,
-        initial: true
+        name: "overwrite",
+        message: "Overwrite existing .claude files?",
+        initial: false
       });
-      installSkills = response.installSkills;
-    }
-    if (installSkills) {
-      const existingSkills = await checkExistingSkills(targetDir, allSkills);
-      if (existingSkills.length > 0 && !options.force) {
-        logger.warn("The following skills already exist:");
-        existingSkills.forEach((s) => logger.step(s));
-        logger.blank();
-        const response = await prompts({
-          type: "confirm",
-          name: "overwrite",
-          message: "Overwrite existing skills?",
-          initial: false
-        });
-        if (!response.overwrite) {
-          logger.info("Skipping skills installation.");
-        } else {
-          await installAllSkills(templates, targetDir);
-        }
+      if (!response.overwrite) {
+        logger.info("Skipping skills/commands installation.");
       } else {
-        await installAllSkills(templates, targetDir);
+        await installSkillsAndCommands();
       }
-      logger.blank();
-    }
-  }
-  if (allCommands.length > 0) {
-    let installCommands = options.commands;
-    if (installCommands === void 0) {
-      logger.blank();
-      const response = await prompts({
-        type: "confirm",
-        name: "installCommands",
-        message: `Install Claude Code commands? (${allCommands.join(", ")})`,
-        initial: true
-      });
-      installCommands = response.installCommands;
+    } else {
+      await installSkillsAndCommands();
     }
-    if (installCommands) {
-      const existingCommands = await checkExistingCommands(
-        targetDir,
-        allCommands
-      );
-      if (existingCommands.length > 0 && !options.force) {
-        logger.warn("The following commands already exist:");
-        existingCommands.forEach((c) => logger.step(c));
+    async function installSkillsAndCommands() {
+      if (options.skills && hasSkills) {
         logger.blank();
-        const response = await prompts({
-          type: "confirm",
-          name: "overwrite",
-          message: "Overwrite existing commands?",
-          initial: false
-        });
-        if (!response.overwrite) {
-          logger.info("Skipping commands installation.");
-        } else {
-          await installAllCommands(templates, targetDir);
-        }
-      } else {
-        await installAllCommands(templates, targetDir);
+        logger.info("Installing skills...");
+        const skillsResult = await copySkills(templates, targetDir);
+        totalFiles += skillsResult.files;
+        totalDirectories += skillsResult.directories;
+        logger.success(
+          `Skills: ${skillsResult.files} files, ${skillsResult.directories} directories`
+        );
+      } else if (options.skills && !hasSkills) {
+        logger.warn("No skills found in selected templates.");
+      }
+      if (options.commands && 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 (options.commands && !hasCommands) {
+        logger.warn("No commands found in selected templates.");
       }
-      logger.blank();
     }
   }
+  logger.blank();
   logger.success("Claude Code documentation installed!");
   logger.blank();
   logger.info("Installed templates:");
   templates.forEach((t) => logger.step(t));
+  if (options.skills || options.commands) {
+    logger.blank();
+    logger.info("Installed extras:");
+    if (options.skills) {
+      logger.step("Skills \u2192 .claude/skills/");
+    }
+    if (options.commands) {
+      logger.step("Commands \u2192 .claude/commands/");
+    }
+  }
   logger.blank();
   logger.info("Next steps:");
   logger.step("Read CLAUDE.md for project guidelines");
   logger.step("Explore docs/ for detailed documentation");
   logger.blank();
 };
-var installAllSkills = async (templates, targetDir) => {
-  const installedSkills = [];
-  for (const template of templates) {
-    const skillsResult = await copySkills(template, targetDir);
-    for (const skill of skillsResult.skills) {
-      if (!installedSkills.includes(skill)) {
-        installedSkills.push(skill);
-      }
-    }
-  }
-  if (installedSkills.length > 0) {
-    logger.success(`Skills installed: ${installedSkills.join(", ")}`);
-    logger.step(`Location: .claude/skills/`);
-  }
-};
-var installAllCommands = async (templates, targetDir) => {
-  const installedCommands = [];
-  for (const template of templates) {
-    const commandsResult = await copyCommands(template, targetDir);
-    for (const command of commandsResult.commands) {
-      if (!installedCommands.includes(command)) {
-        installedCommands.push(command);
-      }
-    }
-  }
-  if (installedCommands.length > 0) {
-    logger.success(`Commands installed: ${installedCommands.join(", ")}`);
-    logger.step(`Location: .claude/commands/`);
-  }
-};
 
 // src/index.ts
 var program = new Command();
-program.name("claude-code").description("Claude Code documentation installer for projects").version("0.1.5");
+program.name("claude-code").description("Claude Code documentation installer for projects").version("0.1.9");
 program.option(
   "-t, --template <names>",
   "template names (comma-separated: tanstack-start,hono)"
-).option("-f, --force", "overwrite existing files without prompting").option("-s, --skills", "install Claude Code skills").option("--no-skills", "skip skills installation").option("-c, --commands", "install Claude Code commands").option("--no-commands", "skip commands installation").option("--cwd <path>", "target directory (default: current directory)").option("--list", "list available templates").action(async (options) => {
+).option("-f, --force", "overwrite existing files without prompting").option("--cwd <path>", "target directory (default: current directory)").option("--list", "list available templates").option("-s, --skills", "install skills to .claude/skills/").option("-c, --commands", "install commands to .claude/commands/").action(async (options) => {
   banner();
   if (options.list) {
     const templates = await listAvailableTemplates();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kood/claude-code",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "Claude Code documentation installer for projects",
   "type": "module",
   "bin": "./dist/index.js",
@@ -12,6 +12,8 @@
     "copy-templates": "node scripts/copy-templates.js",
     "build": "tsup && npm run copy-templates",
     "dev": "npm run build && node dist/index.js",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -38,10 +40,14 @@
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.10.0",
     "@types/prompts": "^2.4.9",
+    "@typescript-eslint/eslint-plugin": "^8.50.1",
+    "@typescript-eslint/parser": "^8.50.1",
+    "eslint": "^9.39.2",
+    "globals": "^16.5.0",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2"
   },
   "engines": {
     "node": ">=18"
   }
-}
+}