@adonis0123/commit 1.0.5 → 1.0.6

package/install-skill.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -24,8 +25,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // shared/src/install-skill.ts
 var import_fs3 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
-var import_os3 = __toESM(require("os"));
+var import_path4 = __toESM(require("path"));
+var import_os4 = __toESM(require("os"));
 var import_child_process = require("child_process");
 
 // shared/src/utils.ts
@@ -115,12 +116,58 @@ function readSkillConfig(dir) {
   }
   return JSON.parse(import_fs.default.readFileSync(configPath, "utf-8"));
 }
+function parseYamlFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return null;
+  }
+  const [, frontmatterStr, body] = match;
+  const frontmatter = {};
+  const lines = frontmatterStr.split("\n");
+  for (const line of lines) {
+    const match2 = line.match(/^(\w+):\s*(.*)$/);
+    if (match2) {
+      const [, key, value] = match2;
+      frontmatter[key] = value.replace(/^["']|["']$/g, "").trim();
+    }
+  }
+  return { frontmatter, body };
+}
+function patchSkillMdName(skillMdPath, name) {
+  try {
+    const content = import_fs.default.readFileSync(skillMdPath, "utf-8");
+    const parsed = parseYamlFrontmatter(content);
+    if (!parsed) {
+      console.warn("  \u26A0 Warning: SKILL.md has no frontmatter, skipping name patch");
+      return;
+    }
+    const { frontmatter, body } = parsed;
+    frontmatter.name = name;
+    const frontmatterLines = Object.entries(frontmatter).map(
+      ([key, value]) => `${key}: ${value}`
+    );
+    const newContent = `---
+${frontmatterLines.join("\n")}
+---
+${body}`;
+    import_fs.default.writeFileSync(skillMdPath, newContent, "utf-8");
+    console.log(`  \u2713 Patched SKILL.md name: ${name}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`  \u26A0 Warning: Failed to patch SKILL.md name: ${message}`);
+  }
+}
 
 // shared/src/claude-settings.ts
 var import_fs2 = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
 var import_os2 = __toESM(require("os"));
+var CLAUDE_SETTINGS_PATH_ENV = "CLAUDE_CODE_SETTINGS_PATH";
 function getClaudeSettingsPath() {
+  const overridePath = process.env[CLAUDE_SETTINGS_PATH_ENV];
+  if (overridePath && overridePath.trim()) {
+    return overridePath.trim();
+  }
   return import_path2.default.join(import_os2.default.homedir(), ".claude", "settings.json");
 }
 function readClaudeSettings() {
@@ -144,8 +191,49 @@ function writeClaudeSettings(settings) {
   }
   import_fs2.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
 }
-function hookMatcherExists(existingHooks, newMatcher) {
-  return existingHooks.some((hook) => hook.matcher === newMatcher.matcher);
+function normalizeHook(hook) {
+  if (!hook || typeof hook !== "object") return null;
+  const command = hook.command;
+  if (typeof command !== "string" || !command.trim()) return null;
+  return { type: "command", command };
+}
+function normalizeHooks(hooks) {
+  if (!Array.isArray(hooks)) return [];
+  const normalized = [];
+  for (const h of hooks) {
+    const nh = normalizeHook(h);
+    if (nh) normalized.push(nh);
+  }
+  return normalized;
+}
+function getHookKey(hook) {
+  return hook.command;
+}
+function mergeHooks(existing, incoming) {
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  let didChange = false;
+  for (const hook of existing) {
+    const key = getHookKey(hook);
+    if (!seen.has(key)) {
+      merged.push(hook);
+      seen.add(key);
+    } else {
+      didChange = true;
+    }
+  }
+  for (const hook of incoming) {
+    const key = getHookKey(hook);
+    if (!seen.has(key)) {
+      merged.push(hook);
+      seen.add(key);
+      didChange = true;
+    }
+  }
+  return { merged, didChange };
+}
+function findMatcherIndex(existingHooks, matcher) {
+  return existingHooks.findIndex((hook) => hook && hook.matcher === matcher);
 }
 function addClaudeHooks(hooksConfig, skillName) {
   const settings = readClaudeSettings();
@@ -163,12 +251,30 @@ function addClaudeHooks(hooksConfig, skillName) {
     }
     const existingHooks = hooks[hookType];
     for (const matcher of hookMatchers) {
-      if (!hookMatcherExists(existingHooks, matcher)) {
-        existingHooks.push(matcher);
-        modified = true;
-        console.log(`  \u2713 Added ${hookType} hook for ${skillName}`);
+      const idx = findMatcherIndex(existingHooks, matcher.matcher);
+      if (idx === -1) {
+        const normalized = {
+          matcher: matcher.matcher,
+          hooks: normalizeHooks(matcher.hooks)
+        };
+        if (normalized.hooks.length > 0) {
+          existingHooks.push(normalized);
+          modified = true;
+          console.log(`  \u2713 Added ${hookType} hook for ${skillName}`);
+        }
       } else {
-        console.log(`  \u2139 ${hookType} hook already exists, skipping`);
+        const existingMatcher = existingHooks[idx];
+        const existingMatcherHooks = normalizeHooks(existingMatcher.hooks);
+        const incomingHooks = normalizeHooks(matcher.hooks);
+        const { merged, didChange } = mergeHooks(existingMatcherHooks, incomingHooks);
+        const normalizedChanged = Array.isArray(existingMatcher.hooks) && JSON.stringify(existingMatcher.hooks) !== JSON.stringify(merged);
+        if (didChange || normalizedChanged) {
+          existingHooks[idx] = { ...existingMatcher, hooks: merged };
+          modified = true;
+          console.log(`  \u2713 Merged ${hookType} hooks for ${skillName} (matcher: ${matcher.matcher})`);
+        } else {
+          console.log(`  \u2139 ${hookType} hook already exists, skipping`);
+        }
       }
     }
     hooks[hookType] = existingHooks;
@@ -179,7 +285,263 @@ function addClaudeHooks(hooksConfig, skillName) {
   return modified;
 }
 
+// shared/src/remote-update-checker-script.ts
+var import_path3 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
+var REMOTE_UPDATE_CHECKER_VERSION = "1";
+function getRemoteUpdateCheckerScriptContents() {
+  const version = REMOTE_UPDATE_CHECKER_VERSION;
+  return `#!/usr/bin/env node
+/* remote-skill-update-checker v${version} */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+
+const DEFAULT_COOLDOWN_MS = 24 * 60 * 60 * 1000; // 1 day
+
+function parseArgs(argv) {
+  const args = new Set(argv.slice(2));
+  return {
+    force: args.has('--force') || args.has('-f'),
+    verbose: args.has('--verbose') || args.has('-v'),
+  };
+}
+
+function readJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const txt = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(txt);
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, obj) {
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(obj, null, 2), 'utf-8');
+  } catch {
+    // ignore
+  }
+}
+
+function getManifestPaths() {
+  const cwd = process.cwd();
+  return Array.from(
+    new Set([
+      path.join(os.homedir(), '.claude', 'skills', '.skills-manifest.json'),
+      path.join(cwd, '.claude', 'skills', '.skills-manifest.json'),
+    ])
+  );
+}
+
+function getRemoteSourcesFromManifest(manifest) {
+  const skills = manifest && typeof manifest.skills === 'object' ? manifest.skills : {};
+  const sources = [];
+  for (const v of Object.values(skills || {})) {
+    if (!v || typeof v !== 'object') continue;
+    const s = v.source;
+    if (typeof s === 'string' && s.trim()) sources.push(s.trim());
+  }
+  return Array.from(new Set(sources));
+}
+
+function parseRemoteSource(remoteSource) {
+  const trimmed = String(remoteSource || '')
+    .trim()
+    .replace(/^https?:\\/\\/github\\.com\\//, '');
+  const parts = trimmed.split('/').filter(Boolean);
+  if (parts.length < 2) return null;
+  const owner = parts[0];
+  const repo = parts[1];
+  const repoPath = parts.slice(2).join('/') || null;
+  return { owner, repo, repoPath };
+}
+
+function buildCommitsUrl(remoteSource) {
+  const parsed = parseRemoteSource(remoteSource);
+  if (!parsed) return null;
+  const base =
+    'https://api.github.com/repos/' +
+    encodeURIComponent(parsed.owner) +
+    '/' +
+    encodeURIComponent(parsed.repo) +
+    '/commits?per_page=1';
+  if (!parsed.repoPath) return base;
+  return base + '&path=' + encodeURIComponent(parsed.repoPath);
+}
+
+function shouldSkipByCooldown(lastCheckedAtIso, now, cooldownMs) {
+  if (!lastCheckedAtIso) return false;
+  const last = new Date(lastCheckedAtIso);
+  if (Number.isNaN(last.getTime())) return false;
+  return now.getTime() - last.getTime() < cooldownMs;
+}
+
+function fetchText(url) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      url,
+      {
+        method: 'GET',
+        headers: {
+          'user-agent': 'claude-skills-remote-update-checker',
+          accept: 'application/vnd.github+json',
+        },
+      },
+      (res) => {
+        let data = '';
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => (data += chunk));
+        res.on('end', () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(data);
+          } else {
+            reject(new Error('HTTP ' + (res.statusCode || 0)));
+          }
+        });
+      }
+    );
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function extractLatestSha(jsonText) {
+  try {
+    const data = JSON.parse(jsonText);
+    if (Array.isArray(data) && data[0] && typeof data[0] === 'object' && typeof data[0].sha === 'string') {
+      return data[0].sha || null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function main() {
+  const { force, verbose } = parseArgs(process.argv);
+  const now = new Date();
+  const cooldownMs = DEFAULT_COOLDOWN_MS;
+
+  const manifestPaths = getManifestPaths();
+  const updates = [];
+
+  for (const manifestPath of manifestPaths) {
+    const manifest = readJson(manifestPath) || {};
+    const sources = getRemoteSourcesFromManifest(manifest);
+    if (!sources.length) continue;
+
+    manifest.remoteCache = manifest.remoteCache && typeof manifest.remoteCache === 'object' ? manifest.remoteCache : {};
+
+    for (const remoteSource of sources) {
+      const prevEntry = manifest.remoteCache[remoteSource] || {};
+      const prevSha = prevEntry.lastSeenSha || null;
+
+      const url = buildCommitsUrl(remoteSource);
+      if (!url) continue;
+
+      if (!force && shouldSkipByCooldown(prevEntry.lastCheckedAt, now, cooldownMs)) {
+        continue;
+      }
+
+      try {
+        const text = await fetchText(url);
+        const latestSha = extractLatestSha(text);
+
+        manifest.remoteCache[remoteSource] = {
+          ...prevEntry,
+          lastCheckedAt: now.toISOString(),
+          ...(latestSha ? { lastSeenSha: latestSha } : {}),
+        };
+        writeJson(manifestPath, manifest);
+
+        // Baseline: first time seeing sha => do not notify
+        if (!prevSha && latestSha) continue;
+
+        if (prevSha && latestSha && prevSha !== latestSha) {
+          updates.push({ remoteSource, prevSha, latestSha });
+        }
+      } catch (e) {
+        manifest.remoteCache[remoteSource] = {
+          ...prevEntry,
+          lastCheckedAt: now.toISOString(),
+        };
+        writeJson(manifestPath, manifest);
+        if (verbose) {
+          console.log('[remote-skill-check] error', remoteSource, String(e && e.message ? e.message : e));
+        }
+      }
+    }
+  }
+
+  if (updates.length > 0) {
+    console.log('\\n\u{1F4E1} \u68C0\u6D4B\u5230\u8FDC\u7A0B skill \u6709\u66F4\u65B0\uFF1A');
+    for (const u of updates) {
+      console.log('  -', u.remoteSource);
+      console.log('    ', (u.prevSha || '').slice(0, 7), '->', (u.latestSha || '').slice(0, 7));
+    }
+    console.log('\\n\u{1F4A1} \u5EFA\u8BAE\u91CD\u65B0\u5B89\u88C5\u5BF9\u5E94 skill \u4EE5\u62C9\u53D6\u6700\u65B0\u7248\u672C\uFF08remoteSource \u6A21\u5F0F\u4E0D\u4F1A\u81EA\u52A8\u66F4\u65B0\uFF09\u3002\\n');
+    process.exitCode = 0;
+  }
+}
+
+main().catch(() => {
+  // ignore
+});
+`;
+}
+function getRemoteUpdateCheckerScriptInstallPath() {
+  const scriptsDir = import_path3.default.join(import_os3.default.homedir(), ".claude", "scripts");
+  return import_path3.default.join(scriptsDir, "remote-skill-update-check.js");
+}
+
 // shared/src/install-skill.ts
+function ensureRemoteUpdateCheckerInstalled() {
+  const scriptPath = getRemoteUpdateCheckerScriptInstallPath();
+  const scriptsDir = import_path4.default.dirname(scriptPath);
+  ensureDir(scriptsDir);
+  const marker = `/* remote-skill-update-checker v${REMOTE_UPDATE_CHECKER_VERSION} */`;
+  if (import_fs3.default.existsSync(scriptPath)) {
+    try {
+      const existing = import_fs3.default.readFileSync(scriptPath, "utf-8");
+      if (existing.includes(marker)) {
+        return scriptPath;
+      }
+    } catch {
+    }
+  }
+  const contents = getRemoteUpdateCheckerScriptContents();
+  import_fs3.default.writeFileSync(scriptPath, contents, { encoding: "utf-8" });
+  try {
+    import_fs3.default.chmodSync(scriptPath, 493);
+  } catch {
+  }
+  return scriptPath;
+}
+function ensureRemoteUpdateSessionEndHook(scriptPath) {
+  const command = `node "${scriptPath}"`;
+  addClaudeHooks(
+    {
+      SessionEnd: [
+        {
+          matcher: "*",
+          hooks: [
+            {
+              command,
+              // Claude Code settings schema expects "command"
+              type: "command"
+            }
+          ]
+        }
+      ]
+    },
+    "remote-update-checker"
+  );
+}
 function fetchFromRemote(tempDir, remoteSource) {
   try {
     console.log(`  \u{1F310} Fetching latest from ${remoteSource}...`);
@@ -187,7 +549,7 @@ function fetchFromRemote(tempDir, remoteSource) {
       stdio: "pipe",
       timeout: 6e4
     });
-    if (import_fs3.default.existsSync(import_path3.default.join(tempDir, "SKILL.md"))) {
+    if (import_fs3.default.existsSync(import_path4.default.join(tempDir, "SKILL.md"))) {
       console.log("  \u2713 Fetched latest version from remote");
       return true;
     }
@@ -209,7 +571,7 @@ function getSourceDir(config, packageDir) {
       isRemote: false
     };
   }
-  const tempDir = import_path3.default.join(import_os3.default.tmpdir(), `skill-fetch-${Date.now()}`);
+  const tempDir = import_path4.default.join(import_os4.default.tmpdir(), `skill-fetch-${Date.now()}`);
   const remoteSuccess = fetchFromRemote(tempDir, config.remoteSource);
   if (remoteSuccess) {
     return {
@@ -235,7 +597,7 @@ function getSourceDir(config, packageDir) {
   };
 }
 function updateManifest(skillsDir, config, targetName, isRemote) {
-  const manifestPath = import_path3.default.join(skillsDir, ".skills-manifest.json");
+  const manifestPath = import_path4.default.join(skillsDir, ".skills-manifest.json");
   let manifest = { skills: {} };
   if (import_fs3.default.existsSync(manifestPath)) {
     try {
@@ -250,7 +612,7 @@ function updateManifest(skillsDir, config, targetName, isRemote) {
     version: config.version,
     installedAt: (/* @__PURE__ */ new Date()).toISOString(),
     package: config.package || config.name,
-    path: import_path3.default.join(skillsDir, skillName),
+    path: import_path4.default.join(skillsDir, skillName),
     target: targetName,
     ...config.remoteSource && { source: config.remoteSource }
   };
@@ -263,8 +625,8 @@ function installToTarget(target, config, sourceDir, isRemote) {
   const isGlobal = isGlobalInstall();
   const location = detectInstallLocation(target.paths, isGlobal);
   const skillName = extractSkillName(config.name);
-  const targetDir = import_path3.default.join(location.base, skillName);
-  const altTargetDir = import_path3.default.join(location.base, config.name);
+  const targetDir = import_path4.default.join(location.base, skillName);
+  const altTargetDir = import_path4.default.join(location.base, config.name);
   console.log(`  Type: ${location.type}${isGlobal ? " (global)" : " (project)"}`);
   console.log(`  Directory: ${targetDir}`);
   if (import_fs3.default.existsSync(altTargetDir) && altTargetDir !== targetDir) {
@@ -273,31 +635,46 @@ function installToTarget(target, config, sourceDir, isRemote) {
     console.log(`  \u2713 Removed directory: ${config.name}`);
   }
   ensureDir(targetDir);
-  const skillMdSource = import_path3.default.join(sourceDir, "SKILL.md");
+  const skillMdSource = import_path4.default.join(sourceDir, "SKILL.md");
   if (!import_fs3.default.existsSync(skillMdSource)) {
     throw new Error("SKILL.md is required but not found");
   }
-  import_fs3.default.copyFileSync(skillMdSource, import_path3.default.join(targetDir, "SKILL.md"));
+  import_fs3.default.copyFileSync(skillMdSource, import_path4.default.join(targetDir, "SKILL.md"));
   console.log("  \u2713 Copied SKILL.md");
+  if (isRemote && config.remoteSource) {
+    patchSkillMdName(import_path4.default.join(targetDir, "SKILL.md"), config.name);
+  }
   const filesToCopy = config.files || {};
   for (const [source, dest] of Object.entries(filesToCopy)) {
-    const sourcePath = import_path3.default.join(sourceDir, source);
+    if (source === "SKILL.md") {
+      continue;
+    }
+    const sourcePath = import_path4.default.join(sourceDir, source);
     if (!import_fs3.default.existsSync(sourcePath)) {
       console.warn(`  \u26A0 Warning: ${source} not found, skipping`);
       continue;
     }
-    const destPath = import_path3.default.join(targetDir, dest);
+    const destPath = import_path4.default.join(targetDir, dest);
     if (import_fs3.default.statSync(sourcePath).isDirectory()) {
       copyDir(sourcePath, destPath);
       console.log(`  \u2713 Copied directory: ${source}`);
     } else {
-      const destDir = import_path3.default.dirname(destPath);
+      const destDir = import_path4.default.dirname(destPath);
       ensureDir(destDir);
       import_fs3.default.copyFileSync(sourcePath, destPath);
       console.log(`  \u2713 Copied file: ${source}`);
     }
   }
   updateManifest(location.base, config, target.name, isRemote);
+  if (target.name === "claude-code" && config.remoteSource) {
+    try {
+      const checkerPath = ensureRemoteUpdateCheckerInstalled();
+      ensureRemoteUpdateSessionEndHook(checkerPath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`  \u26A0 \u8B66\u544A: \u65E0\u6CD5\u914D\u7F6E\u8FDC\u7A0B\u66F4\u65B0\u68C0\u67E5\uFF08\u53EF\u5B89\u5168\u5FFD\u7565\uFF09: ${message}`);
+    }
+  }
   if (target.name === "claude-code" && ((_a = config.claudeSettings) == null ? void 0 : _a.hooks)) {
     console.log("  \u{1F527} \u914D\u7F6E Claude Code \u94A9\u5B50...");
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis0123/commit",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Claude Code Skill - 根据暂存的代码变更自动生成符合 Conventional Commits 规范的提交信息",
   "scripts": {
     "postinstall": "node install-skill.js",

package/uninstall-skill.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -100,7 +101,12 @@ function readSkillConfig(dir) {
 var import_fs2 = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
 var import_os2 = __toESM(require("os"));
+var CLAUDE_SETTINGS_PATH_ENV = "CLAUDE_CODE_SETTINGS_PATH";
 function getClaudeSettingsPath() {
+  const overridePath = process.env[CLAUDE_SETTINGS_PATH_ENV];
+  if (overridePath && overridePath.trim()) {
+    return overridePath.trim();
+  }
   return import_path2.default.join(import_os2.default.homedir(), ".claude", "settings.json");
 }
 function readClaudeSettings() {
@@ -124,6 +130,32 @@ function writeClaudeSettings(settings) {
   }
   import_fs2.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
 }
+function normalizeHook(hook) {
+  if (!hook || typeof hook !== "object") return null;
+  const command = hook.command;
+  if (typeof command !== "string" || !command.trim()) return null;
+  return { type: "command", command };
+}
+function normalizeHooks(hooks) {
+  if (!Array.isArray(hooks)) return [];
+  const normalized = [];
+  for (const h of hooks) {
+    const nh = normalizeHook(h);
+    if (nh) normalized.push(nh);
+  }
+  return normalized;
+}
+function getHookKey(hook) {
+  return hook.command;
+}
+function removeHooks(existing, toRemove) {
+  const removeKeys = new Set(toRemove.map(getHookKey));
+  const remaining = existing.filter((h) => !removeKeys.has(getHookKey(h)));
+  return { remaining, didChange: remaining.length !== existing.length };
+}
+function findMatcherIndex(existingHooks, matcher) {
+  return existingHooks.findIndex((hook) => hook && hook.matcher === matcher);
+}
 function removeClaudeHooks(hooksConfig, skillName) {
   const settings = readClaudeSettings();
   let modified = false;
@@ -139,16 +171,35 @@ function removeClaudeHooks(hooksConfig, skillName) {
       continue;
     }
     const existingHooks = hooks[hookType];
-    const initialLength = existingHooks.length;
-    const matchersToRemove = hookMatchers.map((m) => m.matcher);
-    const filteredHooks = existingHooks.filter(
-      (hook) => !matchersToRemove.includes(hook.matcher)
-    );
-    if (filteredHooks.length < initialLength) {
-      hooks[hookType] = filteredHooks;
-      modified = true;
-      console.log(`  \u2713 Removed ${hookType} hook for ${skillName}`);
+    for (const matcher of hookMatchers) {
+      const idx = findMatcherIndex(existingHooks, matcher.matcher);
+      if (idx === -1) {
+        continue;
+      }
+      const existingMatcher = existingHooks[idx];
+      const existingMatcherHooks = normalizeHooks(existingMatcher.hooks);
+      const toRemoveHooks = normalizeHooks(matcher.hooks);
+      const { remaining, didChange } = removeHooks(existingMatcherHooks, toRemoveHooks);
+      if (didChange) {
+        modified = true;
+        if (remaining.length === 0) {
+          existingHooks.splice(idx, 1);
+          console.log(
+            `  \u2713 Removed ${hookType} matcher for ${skillName} (matcher: ${matcher.matcher})`
+          );
+        } else {
+          existingHooks[idx] = { ...existingMatcher, hooks: remaining };
+          console.log(`  \u2713 Removed ${hookType} hooks for ${skillName} (matcher: ${matcher.matcher})`);
+        }
+      } else {
+        const normalizedChanged = Array.isArray(existingMatcher.hooks) && JSON.stringify(existingMatcher.hooks) !== JSON.stringify(existingMatcherHooks);
+        if (normalizedChanged) {
+          existingHooks[idx] = { ...existingMatcher, hooks: existingMatcherHooks };
+          modified = true;
+        }
+      }
     }
+    hooks[hookType] = existingHooks;
   }
   if (modified) {
     writeClaudeSettings(settings);