@kood/claude-code 0.7.10 → 0.7.12

package/dist/index.js

@@ -22,9 +22,9 @@ var banner = () => {
 };
 
 // src/commands/init.ts
-import fs9 from "fs-extra";
+import fs10 from "fs-extra";
 import os2 from "os";
-import path11 from "path";
+import path12 from "path";
 
 // src/features/templates/template-path-resolver.ts
 import path2 from "path";
@@ -327,6 +327,7 @@ var copyCommands = createExtrasCopier("commands");
 var copyAgents = createExtrasCopier("agents");
 var copyInstructions = createExtrasCopier("instructions");
 var copyScripts = createExtrasCopier("scripts");
+var copyHooks = createExtrasCopier("hooks");
 var getSkillsToInstall = async (skillsSrc, templates) => {
   const metadataMap = await loadAllSkillMetadata(skillsSrc);
   const isNonUITemplate = templates.some((t) => NON_UI_TEMPLATES.includes(t));
@@ -372,6 +373,7 @@ var checkExistingClaudeFiles = async (targetDir) => {
   const agentsDir = path8.join(targetDir, ".claude", "agents");
   const instructionsDir = path8.join(targetDir, ".claude", "instructions");
   const scriptsDir = path8.join(targetDir, ".claude", "scripts");
+  const hooksDir = path8.join(targetDir, ".claude", "hooks");
   if (await fs6.pathExists(skillsDir)) {
     existingFiles.push(".claude/skills/");
   }
@@ -387,6 +389,9 @@ var checkExistingClaudeFiles = async (targetDir) => {
   if (await fs6.pathExists(scriptsDir)) {
     existingFiles.push(".claude/scripts/");
   }
+  if (await fs6.pathExists(hooksDir)) {
+    existingFiles.push(".claude/hooks/");
+  }
   return existingFiles;
 };
 var checkAllExtrasExist = async (_templates) => {
@@ -396,15 +401,56 @@ var checkAllExtrasExist = async (_templates) => {
   const agentsSrc = path8.join(claudeDir, "agents");
   const instructionsSrc = path8.join(claudeDir, "instructions");
   const scriptsSrc = path8.join(claudeDir, "scripts");
+  const hooksSrc = path8.join(claudeDir, "hooks");
   const hasSkills = await hasFiles(skillsSrc);
   const hasCommands = await hasFiles(commandsSrc);
   const hasAgents = await hasFiles(agentsSrc);
   const hasInstructions = await hasFiles(instructionsSrc);
   const hasScripts = await hasFiles(scriptsSrc);
-  return { hasSkills, hasCommands, hasAgents, hasInstructions, hasScripts };
+  const hasHooks = await hasFiles(hooksSrc);
+  return {
+    hasSkills,
+    hasCommands,
+    hasAgents,
+    hasInstructions,
+    hasScripts,
+    hasHooks
+  };
 };
 
 // src/features/extras/extras-installer.ts
+import fs7 from "fs-extra";
+import path9 from "path";
+async function registerSessionStartHook(targetDir) {
+  const settingsPath = path9.join(targetDir, ".claude", "settings.local.json");
+  const hookCommand = ".claude/hooks/session-env-setup.sh";
+  let config = {};
+  if (await fs7.pathExists(settingsPath)) {
+    try {
+      config = await fs7.readJson(settingsPath);
+    } catch {
+      config = {};
+    }
+  }
+  if (!config.hooks) {
+    config.hooks = {};
+  }
+  if (!config.hooks.SessionStart) {
+    config.hooks.SessionStart = [];
+  }
+  const alreadyRegistered = config.hooks.SessionStart.some(
+    (hook) => hook.type === "command" && hook.command === hookCommand
+  );
+  if (!alreadyRegistered) {
+    config.hooks.SessionStart.push({
+      type: "command",
+      command: hookCommand
+    });
+    await fs7.ensureDir(path9.dirname(settingsPath));
+    await fs7.writeJson(settingsPath, config, { spaces: 2 });
+    logger.step("Registered SessionStart hook for CLAUDE_SCRIPTS_ROOT");
+  }
+}
 function logExistingFilesUpdate(existingClaudeFiles) {
   if (existingClaudeFiles.length > 0) {
     logger.info("Updating existing extras:");
@@ -475,6 +521,22 @@ async function installScriptsIfNeeded(templates, targetDir, shouldInstall, hasSc
   );
   return scriptsResult;
 }
+async function installHooksIfNeeded(templates, targetDir, shouldInstall, hasHooks) {
+  if (!shouldInstall) {
+    return { files: 0, directories: 0 };
+  }
+  if (!hasHooks) {
+    logger.warn("No hooks found in selected templates.");
+    return { files: 0, directories: 0 };
+  }
+  logger.blank();
+  logger.info("Installing hooks...");
+  const hooksResult = await copyHooks(templates, targetDir);
+  logger.success(
+    `Hooks: ${hooksResult.files} files, ${hooksResult.directories} directories`
+  );
+  return hooksResult;
+}
 async function installInstructionsIfNeeded(templates, targetDir, shouldInstall, hasInstructions) {
   if (!shouldInstall) {
     return { files: 0, directories: 0 };
@@ -497,9 +559,10 @@ async function installExtras(templates, targetDir, flags, availability) {
     installCommands,
     installAgents,
     installInstructions,
-    installScripts
+    installScripts,
+    installHooks
   } = flags;
-  if (!installSkills && !installCommands && !installAgents && !installInstructions && !installScripts) {
+  if (!installSkills && !installCommands && !installAgents && !installInstructions && !installScripts && !installHooks) {
     return { files: 0, directories: 0 };
   }
   const existingClaudeFiles = await checkExistingClaudeFiles(targetDir);
@@ -534,8 +597,17 @@ async function installExtras(templates, targetDir, flags, availability) {
     installScripts,
     availability.hasScripts
   );
-  const totalFiles = skillsResult.files + commandsResult.files + agentsResult.files + instructionsResult.files + scriptsResult.files;
-  const totalDirectories = skillsResult.directories + commandsResult.directories + agentsResult.directories + instructionsResult.directories + scriptsResult.directories;
+  const hooksResult = await installHooksIfNeeded(
+    templates,
+    targetDir,
+    installHooks,
+    availability.hasHooks
+  );
+  if (installHooks && hooksResult.files > 0) {
+    await registerSessionStartHook(targetDir);
+  }
+  const totalFiles = skillsResult.files + commandsResult.files + agentsResult.files + instructionsResult.files + scriptsResult.files + hooksResult.files;
+  const totalDirectories = skillsResult.directories + commandsResult.directories + agentsResult.directories + instructionsResult.directories + scriptsResult.directories + hooksResult.directories;
   return { files: totalFiles, directories: totalDirectories };
 }
 
@@ -620,19 +692,22 @@ async function promptExtrasSelection(options) {
     agents,
     instructions,
     scripts,
+    hooks,
     hasSkills,
     hasCommands,
     hasAgents,
     hasInstructions,
-    hasScripts
+    hasScripts,
+    hasHooks
   } = options;
   let installSkills = skills ?? false;
   let installCommands = commands ?? false;
   const installAgents = agents ?? hasAgents;
   const installInstructions = instructions ?? hasInstructions;
   const installScripts = scripts ?? hasScripts;
-  const noOptionsProvided = skills === void 0 && commands === void 0 && agents === void 0 && instructions === void 0 && scripts === void 0;
-  if (noOptionsProvided && (hasSkills || hasCommands || hasAgents || hasInstructions || hasScripts)) {
+  const installHooks = hooks ?? hasHooks;
+  const noOptionsProvided = skills === void 0 && commands === void 0 && agents === void 0 && instructions === void 0 && scripts === void 0 && hooks === void 0;
+  if (noOptionsProvided && (hasSkills || hasCommands || hasAgents || hasInstructions || hasScripts || hasHooks)) {
     logger.blank();
     if (hasSkills) {
       const result = await promptConfirm(
@@ -654,7 +729,8 @@ async function promptExtrasSelection(options) {
     installCommands,
     installAgents,
     installInstructions,
-    installScripts
+    installScripts,
+    installHooks
   };
 }
 async function promptScopeSelection(options) {
@@ -707,8 +783,8 @@ async function promptCodexSync(options) {
 }
 
 // src/shared/gitignore-manager.ts
-import fs7 from "fs-extra";
-import path9 from "path";
+import fs8 from "fs-extra";
+import path10 from "path";
 var CLAUDE_GENERATED_FOLDERS = [
   ".claude/brainstorms/",
   ".claude/crawler/",
@@ -737,13 +813,13 @@ function parseIgnoreLine(line) {
 }
 async function updateGitignore(targetDir, options = {}) {
   const { includeCodex = false } = options;
-  const gitignorePath = path9.join(targetDir, ".gitignore");
+  const gitignorePath = path10.join(targetDir, ".gitignore");
   const sectionComment = "# Claude Code generated files";
   const targetFolders = includeCodex ? [...CLAUDE_GENERATED_FOLDERS, ...CODEX_GENERATED_FOLDERS] : CLAUDE_GENERATED_FOLDERS;
   let content = "";
   let hasGitignore = false;
   try {
-    content = await fs7.readFile(gitignorePath, "utf-8");
+    content = await fs8.readFile(gitignorePath, "utf-8");
     hasGitignore = true;
   } catch {
     content = "";
@@ -776,7 +852,7 @@ async function updateGitignore(targetDir, options = {}) {
   if (!newContent.endsWith(eol)) {
     newContent += eol;
   }
-  await fs7.writeFile(gitignorePath, newContent, "utf-8");
+  await fs8.writeFile(gitignorePath, newContent, "utf-8");
   if (hasGitignore) {
     logger.success(`.gitignore updated with ${linesToAdd.length} patterns`);
   } else {
@@ -785,9 +861,9 @@ async function updateGitignore(targetDir, options = {}) {
 }
 
 // src/features/codex-sync/codex-sync.ts
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 import os from "os";
-import path10 from "path";
+import path11 from "path";
 var RESERVED_CODEX_SKILL_DIRS = /* @__PURE__ */ new Set([".system", "claude-commands"]);
 var COMMAND_INSTRUCTION_PREFIX_REGEX = /^@\.\.\/instructions\//gm;
 var COMMAND_INSTRUCTION_PREFIX_REPLACEMENT = "@../../../instructions/";
@@ -821,13 +897,13 @@ function extractDescriptionFromFrontmatter(markdown) {
   return void 0;
 }
 function buildCommandSkillContent(commandPath, commandRaw) {
-  const commandName = path10.basename(commandPath, ".md");
+  const commandName = path11.basename(commandPath, ".md");
   const normalizedCommand = normalizeLineEndings(commandRaw).trim();
   const rewrittenCommand = normalizedCommand.replace(
     COMMAND_INSTRUCTION_PREFIX_REGEX,
     COMMAND_INSTRUCTION_PREFIX_REPLACEMENT
   );
-  const sourcePath = path10.resolve(commandPath);
+  const sourcePath = path11.resolve(commandPath);
   const description = extractDescriptionFromFrontmatter(normalizedCommand) || `${commandName} command imported from .claude/commands`;
   return `---
 name: ${yamlQuote(commandName)}
@@ -905,9 +981,9 @@ function getProjectState(claudeState, targetDir) {
   if (!isRecord(projects)) {
     return void 0;
   }
-  const normalizedTarget = path10.resolve(targetDir);
+  const normalizedTarget = path11.resolve(targetDir);
   for (const [projectPath, projectState] of Object.entries(projects)) {
-    if (path10.resolve(projectPath) !== normalizedTarget) {
+    if (path11.resolve(projectPath) !== normalizedTarget) {
       continue;
     }
     if (isRecord(projectState)) {
@@ -938,11 +1014,11 @@ function filterMcpJsonServersByProjectState(servers, projectState) {
   return Object.fromEntries(filteredEntries);
 }
 async function readJsonFile(filePath) {
-  if (!await fs8.pathExists(filePath)) {
+  if (!await fs9.pathExists(filePath)) {
     return void 0;
   }
   try {
-    const raw = await fs8.readFile(filePath, "utf8");
+    const raw = await fs9.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isRecord(parsed)) {
       return void 0;
@@ -1119,10 +1195,10 @@ function mergeCodexConfigToml(existingToml, renderedMcpBlocks) {
 ${mcp}`;
 }
 async function loadClaudeMcpServers(targetDir) {
-  const homeDir = path10.resolve(os.homedir());
-  const normalizedTarget = path10.resolve(targetDir);
+  const homeDir = path11.resolve(os.homedir());
+  const normalizedTarget = path11.resolve(targetDir);
   const isUserScope = normalizedTarget === homeDir;
-  const claudeStatePath = path10.join(homeDir, CLAUDE_STATE_FILE);
+  const claudeStatePath = path11.join(homeDir, CLAUDE_STATE_FILE);
   const claudeState = await readJsonFile(claudeStatePath);
   if (isUserScope) {
     return {
@@ -1132,7 +1208,7 @@ async function loadClaudeMcpServers(targetDir) {
   }
   const projectState = claudeState ? getProjectState(claudeState, normalizedTarget) : void 0;
   const projectServers = normalizeClaudeMcpServers(projectState?.mcpServers);
-  const localMcpPath = path10.join(normalizedTarget, CLAUDE_LOCAL_MCP_FILE);
+  const localMcpPath = path11.join(normalizedTarget, CLAUDE_LOCAL_MCP_FILE);
   const localMcpState = await readJsonFile(localMcpPath);
   const localMcpServers = filterMcpJsonServersByProjectState(
     normalizeClaudeMcpServers(localMcpState?.mcpServers),
@@ -1147,18 +1223,18 @@ async function loadClaudeMcpServers(targetDir) {
   };
 }
 async function syncMcpServers(targetDir) {
-  const homeDir = path10.resolve(os.homedir());
-  const normalizedTarget = path10.resolve(targetDir);
+  const homeDir = path11.resolve(os.homedir());
+  const normalizedTarget = path11.resolve(targetDir);
   const isUserScope = normalizedTarget === homeDir;
-  const codexBaseDir = isUserScope ? path10.join(homeDir, ".codex") : path10.join(normalizedTarget, ".codex");
-  const codexMcpConfigPath = path10.join(codexBaseDir, CODEX_CONFIG_FILE);
+  const codexBaseDir = isUserScope ? path11.join(homeDir, ".codex") : path11.join(normalizedTarget, ".codex");
+  const codexMcpConfigPath = path11.join(codexBaseDir, CODEX_CONFIG_FILE);
   const { scope, servers } = await loadClaudeMcpServers(normalizedTarget);
   const codexServers = Object.entries(servers).map(([name, server]) => [name, toCodexMcpServer(server)]).filter((entry) => Boolean(entry[1])).sort((a, b) => a[0].localeCompare(b[0]));
   const renderedMcpBlocks = codexServers.map(([name, server]) => renderCodexMcpServer(name, server)).join("\n\n");
-  const existingConfig = await fs8.pathExists(codexMcpConfigPath) ? await fs8.readFile(codexMcpConfigPath, "utf8") : "";
+  const existingConfig = await fs9.pathExists(codexMcpConfigPath) ? await fs9.readFile(codexMcpConfigPath, "utf8") : "";
   const nextConfig = mergeCodexConfigToml(existingConfig, renderedMcpBlocks);
-  await fs8.ensureDir(codexBaseDir);
-  await fs8.writeFile(codexMcpConfigPath, `${nextConfig.trimEnd()}
+  await fs9.ensureDir(codexBaseDir);
+  await fs9.writeFile(codexMcpConfigPath, `${nextConfig.trimEnd()}
 `);
   return {
     codexMcpConfigPath,
@@ -1167,16 +1243,16 @@ async function syncMcpServers(targetDir) {
   };
 }
 async function syncSkills(claudeSkillsDir, codexSkillsDir) {
-  await fs8.ensureDir(codexSkillsDir);
+  await fs9.ensureDir(codexSkillsDir);
   let sourceSkillNames = [];
-  if (await fs8.pathExists(claudeSkillsDir)) {
-    const sourceEntries = await fs8.readdir(claudeSkillsDir, {
+  if (await fs9.pathExists(claudeSkillsDir)) {
+    const sourceEntries = await fs9.readdir(claudeSkillsDir, {
       withFileTypes: true
     });
     sourceSkillNames = sourceEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => name !== ".system");
   }
   const sourceSkillSet = new Set(sourceSkillNames);
-  const codexEntries = await fs8.readdir(codexSkillsDir, {
+  const codexEntries = await fs9.readdir(codexSkillsDir, {
     withFileTypes: true
   });
   for (const entry of codexEntries) {
@@ -1187,40 +1263,40 @@ async function syncSkills(claudeSkillsDir, codexSkillsDir) {
       continue;
     }
     if (!sourceSkillSet.has(entry.name)) {
-      await fs8.remove(path10.join(codexSkillsDir, entry.name));
+      await fs9.remove(path11.join(codexSkillsDir, entry.name));
     }
   }
   for (const skillName of sourceSkillNames) {
-    const src = path10.join(claudeSkillsDir, skillName);
-    const dest = path10.join(codexSkillsDir, skillName);
-    if (await fs8.pathExists(dest)) {
-      await fs8.remove(dest);
+    const src = path11.join(claudeSkillsDir, skillName);
+    const dest = path11.join(codexSkillsDir, skillName);
+    if (await fs9.pathExists(dest)) {
+      await fs9.remove(dest);
     }
     await copyRecursive(src, dest, { files: 0, directories: 0 });
   }
   return sourceSkillNames.length;
 }
 async function syncCommands(claudeCommandsDir, codexCommandsDir) {
-  if (!await fs8.pathExists(claudeCommandsDir)) {
-    await fs8.remove(codexCommandsDir);
+  if (!await fs9.pathExists(claudeCommandsDir)) {
+    await fs9.remove(codexCommandsDir);
     return 0;
   }
-  const entries = await fs8.readdir(claudeCommandsDir, { withFileTypes: true });
+  const entries = await fs9.readdir(claudeCommandsDir, { withFileTypes: true });
   const commandFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
   if (commandFiles.length === 0) {
-    await fs8.remove(codexCommandsDir);
+    await fs9.remove(codexCommandsDir);
     return 0;
   }
-  await fs8.remove(codexCommandsDir);
-  await fs8.ensureDir(codexCommandsDir);
+  await fs9.remove(codexCommandsDir);
+  await fs9.ensureDir(codexCommandsDir);
   for (const commandFile of commandFiles) {
-    const commandPath = path10.join(claudeCommandsDir, commandFile);
-    const commandRaw = await fs8.readFile(commandPath, "utf8");
-    const commandName = path10.basename(commandFile, ".md");
-    const skillDir = path10.join(codexCommandsDir, commandName);
-    const skillPath = path10.join(skillDir, "SKILL.md");
-    await fs8.ensureDir(skillDir);
-    await fs8.writeFile(
+    const commandPath = path11.join(claudeCommandsDir, commandFile);
+    const commandRaw = await fs9.readFile(commandPath, "utf8");
+    const commandName = path11.basename(commandFile, ".md");
+    const skillDir = path11.join(codexCommandsDir, commandName);
+    const skillPath = path11.join(skillDir, "SKILL.md");
+    await fs9.ensureDir(skillDir);
+    await fs9.writeFile(
       skillPath,
       buildCommandSkillContent(commandPath, commandRaw)
     );
@@ -1228,12 +1304,12 @@ async function syncCommands(claudeCommandsDir, codexCommandsDir) {
   return commandFiles.length;
 }
 async function syncInstructions(claudeInstructionsDir, codexInstructionsDir) {
-  if (!await fs8.pathExists(claudeInstructionsDir)) {
-    await fs8.remove(codexInstructionsDir);
+  if (!await fs9.pathExists(claudeInstructionsDir)) {
+    await fs9.remove(codexInstructionsDir);
     return 0;
   }
-  await fs8.remove(codexInstructionsDir);
-  await fs8.ensureDir(codexInstructionsDir);
+  await fs9.remove(codexInstructionsDir);
+  await fs9.ensureDir(codexInstructionsDir);
   const counter = { files: 0, directories: 0 };
   await copyRecursive(claudeInstructionsDir, codexInstructionsDir, counter);
   return counter.files;
@@ -1254,12 +1330,12 @@ function extractReferenceCandidate(line) {
   return candidate;
 }
 async function collectSkillMarkdownFiles(rootDir, collector = []) {
-  if (!await fs8.pathExists(rootDir)) {
+  if (!await fs9.pathExists(rootDir)) {
     return collector;
   }
-  const entries = await fs8.readdir(rootDir, { withFileTypes: true });
+  const entries = await fs9.readdir(rootDir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path10.join(rootDir, entry.name);
+    const fullPath = path11.join(rootDir, entry.name);
     if (entry.isDirectory()) {
       await collectSkillMarkdownFiles(fullPath, collector);
       continue;
@@ -1275,7 +1351,7 @@ async function validateSkillReferences(codexSkillsDir) {
   let count = 0;
   const samples = [];
   for (const skillFile of skillFiles) {
-    const content = await fs8.readFile(skillFile, "utf8");
+    const content = await fs9.readFile(skillFile, "utf8");
     const lines = normalizeLineEndings(content).split("\n");
     for (const line of lines) {
       const candidate = extractReferenceCandidate(line);
@@ -1286,8 +1362,8 @@ async function validateSkillReferences(codexSkillsDir) {
       if (!referencePath) {
         continue;
       }
-      const resolvedPath = path10.resolve(path10.dirname(skillFile), referencePath);
-      if (await fs8.pathExists(resolvedPath)) {
+      const resolvedPath = path11.resolve(path11.dirname(skillFile), referencePath);
+      if (await fs9.pathExists(resolvedPath)) {
         continue;
       }
       count += 1;
@@ -1303,15 +1379,15 @@ async function validateSkillReferences(codexSkillsDir) {
   return { count, samples };
 }
 async function syncWithCodex(targetDir) {
-  const codexHome = path10.resolve(targetDir, ".codex");
-  const codexSkillsDir = path10.join(codexHome, "skills");
-  const codexCommandsDir = path10.join(codexSkillsDir, "claude-commands");
-  const codexInstructionsDir = path10.join(codexHome, "instructions");
-  await fs8.ensureDir(codexSkillsDir);
-  const claudeRootDir = path10.join(targetDir, ".claude");
-  const claudeSkillsDir = path10.join(claudeRootDir, "skills");
-  const claudeCommandsDir = path10.join(claudeRootDir, "commands");
-  const claudeInstructionsDir = path10.join(claudeRootDir, "instructions");
+  const codexHome = path11.resolve(targetDir, ".codex");
+  const codexSkillsDir = path11.join(codexHome, "skills");
+  const codexCommandsDir = path11.join(codexSkillsDir, "claude-commands");
+  const codexInstructionsDir = path11.join(codexHome, "instructions");
+  await fs9.ensureDir(codexSkillsDir);
+  const claudeRootDir = path11.join(targetDir, ".claude");
+  const claudeSkillsDir = path11.join(claudeRootDir, "skills");
+  const claudeCommandsDir = path11.join(claudeRootDir, "commands");
+  const claudeInstructionsDir = path11.join(claudeRootDir, "instructions");
   const syncedSkills = await syncSkills(claudeSkillsDir, codexSkillsDir);
   const syncedInstructions = await syncInstructions(
     claudeInstructionsDir,
@@ -1352,7 +1428,7 @@ var TEMPLATE_DESCRIPTIONS = {
 };
 async function validateTargetDirectory(targetDir) {
   try {
-    const stat = await fs9.stat(targetDir);
+    const stat = await fs10.stat(targetDir);
     if (!stat.isDirectory()) {
       logger.error(`Target is not a directory: ${targetDir}`);
       process.exit(1);
@@ -1366,7 +1442,7 @@ async function validateTargetDirectory(targetDir) {
     process.exit(1);
   }
   try {
-    await fs9.access(targetDir, fs9.constants.W_OK);
+    await fs10.access(targetDir, fs10.constants.W_OK);
   } catch {
     logger.error(`No write permission for: ${targetDir}`);
     process.exit(1);
@@ -1420,29 +1496,32 @@ async function installTemplates(templates, targetDir) {
   logger.success(`Total: ${totalFiles} files, ${totalDirectories} directories`);
   return { files: totalFiles, directories: totalDirectories };
 }
-async function promptForExtrasInstallation(options, hasSkills, hasCommands, hasAgents, hasInstructions, hasScripts) {
+async function promptForExtrasInstallation(options, hasSkills, hasCommands, hasAgents, hasInstructions, hasScripts, hasHooks) {
   return await promptExtrasSelection({
     skills: options.skills,
     commands: options.commands,
     agents: options.agents,
     instructions: options.instructions,
     scripts: options.scripts,
+    hooks: options.hooks,
     hasSkills,
     hasCommands,
     hasAgents,
     hasInstructions,
-    hasScripts
+    hasScripts,
+    hasHooks
   });
 }
-function showInstallationSummary(templates, flags, hasSkills, hasCommands, hasAgents, hasInstructions, hasScripts, scope) {
+function showInstallationSummary(templates, flags, hasSkills, hasCommands, hasAgents, hasInstructions, hasScripts, hasHooks, scope) {
   const {
     installSkills,
     installCommands,
     installAgents,
     installInstructions,
-    installScripts
+    installScripts,
+    installHooks
   } = flags;
-  const hasExtrasInstalled = installSkills && hasSkills || installCommands && hasCommands || installAgents && hasAgents || installInstructions && hasInstructions || installScripts && hasScripts;
+  const hasExtrasInstalled = installSkills && hasSkills || installCommands && hasCommands || installAgents && hasAgents || installInstructions && hasInstructions || installScripts && hasScripts || installHooks && hasHooks;
   if (templates.length === 0 && !hasExtrasInstalled) {
     logger.blank();
     logger.info("No templates or extras installed.");
@@ -1475,6 +1554,9 @@ function showInstallationSummary(templates, flags, hasSkills, hasCommands, hasAg
     if (installScripts && hasScripts) {
       logger.step("Scripts \u2192 .claude/scripts/");
     }
+    if (installHooks && hasHooks) {
+      logger.step("Hooks \u2192 .claude/hooks/");
+    }
   }
   logger.blank();
   logger.info("Next steps:");
@@ -1513,21 +1595,30 @@ var init = async (options) => {
     }
   }
   const templatesToCheck = templates.length > 0 ? templates : availableTemplates;
-  const { hasSkills, hasCommands, hasAgents, hasInstructions, hasScripts } = await checkAllExtrasExist(templatesToCheck);
+  const {
+    hasSkills,
+    hasCommands,
+    hasAgents,
+    hasInstructions,
+    hasScripts,
+    hasHooks
+  } = await checkAllExtrasExist(templatesToCheck);
   const flags = await promptForExtrasInstallation(
     options,
     hasSkills,
     hasCommands,
     hasAgents,
     hasInstructions,
-    hasScripts
+    hasScripts,
+    hasHooks
   );
   await installExtras(templatesToCheck, targetDir, flags, {
     hasSkills,
     hasCommands,
     hasAgents,
     hasInstructions,
-    hasScripts
+    hasScripts,
+    hasHooks
   });
   showInstallationSummary(
     templates,
@@ -1537,9 +1628,10 @@ var init = async (options) => {
     hasAgents,
     hasInstructions,
     hasScripts,
+    hasHooks,
     scope
   );
-  const codexSyncPath = path11.join(targetDir, ".codex");
+  const codexSyncPath = path12.join(targetDir, ".codex");
   const { syncCodex } = await promptCodexSync({
     providedSyncCodex: options.syncCodex,
     codexPath: codexSyncPath
@@ -1575,8 +1667,8 @@ var init = async (options) => {
             `Codex skill reference issues found: ${result.referenceIssueCount} (showing up to ${result.referenceIssueSamples.length})`
           );
           for (const issue of result.referenceIssueSamples) {
-            const skillPath = path11.relative(targetDir, issue.skillPath);
-            const resolvedPath = path11.relative(targetDir, issue.resolvedPath);
+            const skillPath = path12.relative(targetDir, issue.skillPath);
+            const resolvedPath = path12.relative(targetDir, issue.resolvedPath);
             logger.step(
               `${skillPath} -> @${issue.reference} (missing: ${resolvedPath})`
             );
@@ -1602,7 +1694,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.7.10");
+program.name("claude-code").description("Claude Code documentation installer for projects").version("0.7.12");
 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.7.10",
+  "version": "0.7.12",
   "description": "Claude Code documentation installer for projects",
   "type": "module",
   "bin": "./dist/index.js",