@kood/claude-code 0.5.9 → 0.6.0

package/dist/index.js

@@ -22,7 +22,7 @@ var banner = () => {
 };
 
 // src/commands/init.ts
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 
 // src/features/templates/template-path-resolver.ts
 import path2 from "path";
@@ -232,37 +232,85 @@ var checkExistingFiles = async (targetDir) => {
 };
 
 // src/features/extras/extras-copier.ts
-import fs4 from "fs-extra";
-import path6 from "path";
+import fs5 from "fs-extra";
+import path7 from "path";
 
 // src/shared/constants.ts
-var FRAMEWORK_SPECIFIC_SKILLS_MAP = {
-  nextjs: ["nextjs-react-best-practices", "korea-uiux-design", "figma-to-code"],
-  "tanstack-start": [
-    "tanstack-start-react-best-practices",
-    "korea-uiux-design",
-    "figma-to-code"
-  ]
-  // hono와 npx는 프레임워크별 스킬 없음
+var NON_UI_TEMPLATES = ["hono", "npx"];
+
+// src/features/extras/skill-metadata.ts
+import fs4 from "fs-extra";
+import path6 from "path";
+var parseSkillMetadata = async (skillPath) => {
+  const skillMdPath = path6.join(skillPath, "SKILL.md");
+  if (!await fs4.pathExists(skillMdPath)) {
+    return null;
+  }
+  const content = await fs4.readFile(skillMdPath, "utf-8");
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+  const frontmatter = frontmatterMatch[1];
+  const metadata = {
+    name: "",
+    description: ""
+  };
+  const lines = frontmatter.split("\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    switch (key) {
+      case "name":
+        metadata.name = value;
+        break;
+      case "description":
+        metadata.description = value;
+        break;
+      case "user-invocable":
+        metadata.userInvocable = value === "true";
+        break;
+      case "ui-only":
+        metadata.uiOnly = value === "true";
+        break;
+      case "framework":
+        metadata.framework = value;
+        break;
+    }
+  }
+  return metadata;
+};
+var loadAllSkillMetadata = async (skillsSrc) => {
+  const metadataMap = /* @__PURE__ */ new Map();
+  if (!await fs4.pathExists(skillsSrc)) {
+    return metadataMap;
+  }
+  const entries = await fs4.readdir(skillsSrc, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const skillPath = path6.join(skillsSrc, entry.name);
+      const metadata = await parseSkillMetadata(skillPath);
+      if (metadata) {
+        if (!metadata.name) {
+          metadata.name = entry.name;
+        }
+        metadataMap.set(entry.name, metadata);
+      }
+    }
+  }
+  return metadataMap;
 };
-var COMMON_SKILLS = [
-  "global-uiux-design",
-  "docs-creator",
-  "docs-refactor",
-  "plan",
-  "prd",
-  "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);
+    const targetExtrasDir = path7.join(targetDir, ".claude", extrasType);
+    const extrasSrc = path7.join(getTemplatesDir(), ".claude", extrasType);
+    if (await fs5.pathExists(extrasSrc)) {
+      await fs5.ensureDir(targetExtrasDir);
       await copyRecursive(extrasSrc, targetExtrasDir, counter);
     }
     return counter;
@@ -271,85 +319,71 @@ var createExtrasCopier = (extrasType) => {
 var copyCommands = createExtrasCopier("commands");
 var copyAgents = createExtrasCopier("agents");
 var copyInstructions = createExtrasCopier("instructions");
+var getSkillsToInstall = async (skillsSrc, templates) => {
+  const metadataMap = await loadAllSkillMetadata(skillsSrc);
+  const isNonUITemplate = templates.some((t) => NON_UI_TEMPLATES.includes(t));
+  const skillsToInstall = [];
+  for (const [skillName, metadata] of metadataMap) {
+    if (isNonUITemplate && metadata.uiOnly) {
+      continue;
+    }
+    if (metadata.framework && !templates.includes(metadata.framework)) {
+      continue;
+    }
+    skillsToInstall.push(skillName);
+  }
+  return skillsToInstall;
+};
 var copySkills = async (templates, targetDir) => {
   const counter = { files: 0, directories: 0 };
-  const targetSkillsDir = path6.join(targetDir, ".claude", "skills");
-  const skillsSrc = path6.join(getTemplatesDir(), ".claude", "skills");
-  if (!await fs4.pathExists(skillsSrc)) {
+  const targetSkillsDir = path7.join(targetDir, ".claude", "skills");
+  const skillsSrc = path7.join(getTemplatesDir(), ".claude", "skills");
+  if (!await fs5.pathExists(skillsSrc)) {
     return counter;
   }
-  await fs4.ensureDir(targetSkillsDir);
-  const skillsToCopy = /* @__PURE__ */ new Set();
-  const skillTemplateMap = /* @__PURE__ */ new Map();
-  COMMON_SKILLS.forEach((skill) => skillsToCopy.add(skill));
-  for (const template of templates) {
-    const skills = FRAMEWORK_SPECIFIC_SKILLS_MAP[template] || [];
-    skills.forEach((skill) => {
-      skillsToCopy.add(skill);
-      if (!skillTemplateMap.has(skill)) {
-        skillTemplateMap.set(skill, /* @__PURE__ */ new Set());
-      }
-      skillTemplateMap.get(skill).add(template);
-    });
-  }
-  for (const skill of skillsToCopy) {
-    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);
-    }
-  }
-  const duplicateSkills = [];
-  for (const [skill, templateSet] of skillTemplateMap.entries()) {
-    if (templateSet.size > 1) {
-      duplicateSkills.push({
-        skill,
-        templates: Array.from(templateSet).sort()
-      });
+  await fs5.ensureDir(targetSkillsDir);
+  const skillsToInstall = await getSkillsToInstall(skillsSrc, templates);
+  for (const skill of skillsToInstall) {
+    const skillSrc = path7.join(skillsSrc, skill);
+    const skillDest = path7.join(targetSkillsDir, skill);
+    if (await fs5.pathExists(skillDest)) {
+      await fs5.remove(skillDest);
     }
+    await copyRecursive(skillSrc, skillDest, counter);
   }
-  return {
-    ...counter,
-    ...duplicateSkills.length > 0 && { duplicateSkills }
-  };
+  return counter;
 };
 
 // src/features/extras/extras-checker.ts
-import fs5 from "fs-extra";
-import path7 from "path";
+import fs6 from "fs-extra";
+import path8 from "path";
 var checkExistingClaudeFiles = async (targetDir) => {
   const existingFiles = [];
-  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)) {
+  const skillsDir = path8.join(targetDir, ".claude", "skills");
+  const commandsDir = path8.join(targetDir, ".claude", "commands");
+  const agentsDir = path8.join(targetDir, ".claude", "agents");
+  const instructionsDir = path8.join(targetDir, ".claude", "instructions");
+  if (await fs6.pathExists(skillsDir)) {
     existingFiles.push(".claude/skills/");
   }
-  if (await fs5.pathExists(commandsDir)) {
+  if (await fs6.pathExists(commandsDir)) {
     existingFiles.push(".claude/commands/");
   }
-  if (await fs5.pathExists(agentsDir)) {
+  if (await fs6.pathExists(agentsDir)) {
     existingFiles.push(".claude/agents/");
   }
-  if (await fs5.pathExists(instructionsDir)) {
+  if (await fs6.pathExists(instructionsDir)) {
     existingFiles.push(".claude/instructions/");
   }
   return existingFiles;
 };
-var checkAllExtrasExist = async (templates) => {
-  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;
-  });
-  const hasSkills = COMMON_SKILLS.length > 0 || hasFrameworkSkills;
+var checkAllExtrasExist = async (_templates) => {
+  const claudeDir = path8.join(getTemplatesDir(), ".claude");
+  const skillsSrc = path8.join(claudeDir, "skills");
+  const commandsSrc = path8.join(claudeDir, "commands");
+  const agentsSrc = path8.join(claudeDir, "agents");
+  const instructionsSrc = path8.join(claudeDir, "instructions");
+  const hasSkills = await hasFiles(skillsSrc);
   const hasCommands = await hasFiles(commandsSrc);
   const hasAgents = await hasFiles(agentsSrc);
   const hasInstructions = await hasFiles(instructionsSrc);
@@ -367,15 +401,6 @@ async function promptConfirm(message, initial = false) {
   });
   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",
@@ -447,8 +472,8 @@ async function promptExtrasSelection(options) {
   } = options;
   let installSkills = skills ?? false;
   let installCommands = commands ?? false;
-  let installAgents = agents ?? hasAgents;
-  let installInstructions = instructions ?? hasInstructions;
+  const installAgents = agents ?? hasAgents;
+  const 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();
@@ -489,32 +514,6 @@ async function handleDuplicateFiles(existingClaudeFiles, force) {
   );
   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 };
@@ -526,13 +525,6 @@ async function installSkillsIfNeeded(templates, targetDir, shouldInstall, hasSki
   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`
   );
@@ -627,8 +619,8 @@ async function installExtras(templates, targetDir, flags, availability, force) {
 }
 
 // src/shared/gitignore-manager.ts
-import fs6 from "fs-extra";
-import path8 from "path";
+import fs7 from "fs-extra";
+import path9 from "path";
 var CLAUDE_GENERATED_FOLDERS = [
   ".claude/plan/",
   ".claude/ralph/",
@@ -636,14 +628,14 @@ var CLAUDE_GENERATED_FOLDERS = [
   ".claude/prd/"
 ];
 async function updateGitignore(targetDir) {
-  const gitignorePath = path8.join(targetDir, ".gitignore");
+  const gitignorePath = path9.join(targetDir, ".gitignore");
   const sectionComment = "# Claude Code generated files";
   let content = "";
   let hasGitignore = false;
   try {
-    content = await fs6.readFile(gitignorePath, "utf-8");
+    content = await fs7.readFile(gitignorePath, "utf-8");
     hasGitignore = true;
-  } catch (error) {
+  } catch {
     content = "";
   }
   const linesToAdd = [];
@@ -684,7 +676,7 @@ async function updateGitignore(targetDir) {
       newContent += linesToAdd.join("\n") + "\n";
     }
   }
-  await fs6.writeFile(gitignorePath, newContent, "utf-8");
+  await fs7.writeFile(gitignorePath, newContent, "utf-8");
   if (hasGitignore) {
     logger.success(`.gitignore updated with ${linesToAdd.length} patterns`);
   } else {
@@ -700,7 +692,7 @@ var TEMPLATE_DESCRIPTIONS = {
 };
 async function validateTargetDirectory(targetDir) {
   try {
-    const stat = await fs7.stat(targetDir);
+    const stat = await fs8.stat(targetDir);
     if (!stat.isDirectory()) {
       logger.error(`Target is not a directory: ${targetDir}`);
       process.exit(1);
@@ -714,7 +706,7 @@ async function validateTargetDirectory(targetDir) {
     process.exit(1);
   }
   try {
-    await fs7.access(targetDir, fs7.constants.W_OK);
+    await fs8.access(targetDir, fs8.constants.W_OK);
   } catch {
     logger.error(`No write permission for: ${targetDir}`);
     process.exit(1);
@@ -854,7 +846,7 @@ var init = async (options) => {
 
 // src/index.ts
 var program = new Command();
-program.name("claude-code").description("Claude Code documentation installer for projects").version("0.5.9");
+program.name("claude-code").description("Claude Code documentation installer for projects").version("0.6.0");
 program.option(
   "-t, --template <names>",
   "template names (comma-separated: tanstack-start,hono)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kood/claude-code",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "description": "Claude Code documentation installer for projects",
   "type": "module",
   "bin": "./dist/index.js",