td-ai-tools 1.2.3 → 1.2.4

package/README.md

@@ -57,7 +57,7 @@ This keeps the installed assets available to both Claude-style and `.agents`-sty
 
 Some skills provide a recognized setup command (`setup.sh`, `scripts/setup.sh`, or `package.json` with `scripts.setup`). Non-interactive installs and updates run setup only when you pass `--setup`; interactive installs/updates ask for confirmation only when the selected skills include a recognized setup command. Accepted setup runs once inside each installed copy: `.claude/skills/<name>/` and `.agents/skills/<name>/`.
 
-Skills can also declare reusable project-hook setup in `hooks/manifest.json`. The shared installer in `lib/project-hooks.js` copies listed hook assets and merges each registration into its Claude or Codex JSON settings file, preserving unrelated configuration and updating an existing hook with the same `type` and `command` instead of duplicating it. A hook manifest counts as a recognized setup even when the skill has no setup script, so future skills only need to provide their assets and declarative registrations.
+Skills can also declare reusable project-hook setup in `hooks/manifest.json`. The shared installer in `lib/project-hooks.js` copies listed hook assets and merges each registration into its Claude or Codex JSON settings file, preserving unrelated configuration and updating an existing hook with the same `type` and `command` instead of duplicating it. A hook manifest counts as a recognized setup even when the skill has no setup script, so future skills only need to provide their assets and declarative registrations. Deleting the skill removes unchanged manifest-owned registrations and assets; user-modified hooks and invalid settings files are left untouched with a warning.
 
 `install` now errors when the target item already exists. Use `update` to replace an existing installed skill or agent pack.
 

package/lib/installer.js

@@ -9,7 +9,11 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { copyDir } from './fs-utils.js';
 import { bundledAgentsIn } from './catalog.js';
-import { hasProjectHooks, installProjectHooks } from './project-hooks.js';
+import {
+  hasProjectHooks,
+  installProjectHooks,
+  uninstallProjectHooks,
+} from './project-hooks.js';
 
 /** @typedef {import('./catalog.js').Ctx} Ctx */
 /** @typedef {import('./catalog.js').Target} Target */
@@ -179,6 +183,17 @@ export function installSkill(ctx, name, { replaceExisting = false, runSetup = fa
  */
 export function deleteSkill(ctx, name, { report = noop } = {}) {
   let deletedAny = false;
+  const hookSource = ctx.installTargets
+    .map(target => path.join(ctx.targetRoot, target.root, 'skills', name))
+    .find(hasProjectHooks);
+  if (hookSource) {
+    try {
+      uninstallProjectHooks(ctx.targetRoot, hookSource, { report });
+    } catch (error) {
+      report('error', `skill: ${name} hook cleanup failed: ${error.message}`);
+    }
+  }
+
   for (const target of ctx.installTargets) {
     const dest = path.join(ctx.targetRoot, target.root, 'skills', name);
     const bundledAgents = bundledAgentsIn(path.join(dest, 'agents'));

package/lib/project-hooks.js

@@ -6,6 +6,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
 
 const MANIFEST_PATH = path.join('hooks', 'manifest.json');
 
@@ -94,6 +95,69 @@ export function mergeHookRegistration(settings, event, hook, group = {}) {
   settings.hooks[event].push({ ...group, hooks: [{ ...hook }] });
 }
 
+/**
+ * Remove one unchanged, manifest-owned runtime hook group from settings.
+ *
+ * The complete group must still equal the manifest declaration. This avoids
+ * deleting a hook or group that a user customized after setup.
+ *
+ * @param {Record<string, any>} settings
+ * @param {string} event
+ * @param {Record<string, any>} hook
+ * @param {Record<string, any>} [group]
+ * @returns {boolean} Whether an exact registration was removed.
+ */
+export function removeHookRegistration(settings, event, hook, group = {}) {
+  if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+    throw new Error('hook settings must be a JSON object');
+  }
+  if (typeof event !== 'string' || !event) {
+    throw new Error('hook event must be a non-empty string');
+  }
+  if (!hook || typeof hook !== 'object' || Array.isArray(hook)
+    || typeof hook.type !== 'string' || typeof hook.command !== 'string') {
+    throw new Error('hook must define string type and command fields');
+  }
+  if (!group || typeof group !== 'object' || Array.isArray(group)) {
+    throw new Error('hook group must be a JSON object');
+  }
+  if (settings.hooks === undefined) return false;
+  if (!settings.hooks || typeof settings.hooks !== 'object' || Array.isArray(settings.hooks)) {
+    throw new Error('settings.hooks must be a JSON object');
+  }
+  if (settings.hooks[event] === undefined) return false;
+  if (!Array.isArray(settings.hooks[event])) {
+    throw new Error(`settings.hooks.${event} must be an array`);
+  }
+
+  const expectedGroup = { ...group, hooks: [{ ...hook }] };
+  const index = settings.hooks[event].findIndex(candidate => (
+    isDeepStrictEqual(candidate, expectedGroup)
+  ));
+  if (index === -1) return false;
+  settings.hooks[event].splice(index, 1);
+  return true;
+}
+
+/**
+ * Whether settings still contain a hook with the manifest hook's identity.
+ *
+ * @param {Record<string, any>} settings
+ * @param {string} event
+ * @param {Record<string, any>} hook
+ * @returns {boolean}
+ */
+function hasHookIdentity(settings, event, hook) {
+  const groups = settings.hooks?.[event];
+  if (!Array.isArray(groups)) return false;
+  return groups.some(existingGroup => (
+    Array.isArray(existingGroup?.hooks)
+    && existingGroup.hooks.some(candidate => (
+      candidate?.type === hook.type && candidate?.command === hook.command
+    ))
+  ));
+}
+
 /**
  * Read JSON settings, backing up malformed input before starting a clean file.
  *
@@ -169,3 +233,106 @@ export function installProjectHooks(projectRoot, skillDir, { report = noop } = {
 
   return true;
 }
+
+/**
+ * Remove unchanged hook assets and registrations declared by a skill.
+ *
+ * User-modified files, registrations, and malformed settings files are left
+ * untouched with a warning. Settings keys and directories are retained even
+ * when their managed entries are removed so unrelated structure is preserved.
+ *
+ * @param {string} projectRoot
+ * @param {string} skillDir
+ * @param {object} [options]
+ * @param {(kind: 'success'|'warn'|'info', message: string) => void} [options.report]
+ * @returns {boolean} Whether a manifest was found and processed.
+ */
+export function uninstallProjectHooks(projectRoot, skillDir, { report = noop } = {}) {
+  const manifestPath = path.join(skillDir, MANIFEST_PATH);
+  if (!fs.existsSync(manifestPath)) return false;
+
+  const hooksDir = path.dirname(manifestPath);
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
+    throw new Error(`hook manifest must be a JSON object: ${manifestPath}`);
+  }
+
+  const files = (manifest.files || []).map(file => {
+    const source = resolveWithin(hooksDir, file.source, 'hook source');
+    const destination = resolveWithin(projectRoot, file.destination, 'hook destination');
+    if (!fs.existsSync(source) || !fs.statSync(source).isFile()) {
+      throw new Error(`hook source does not exist: ${source}`);
+    }
+    const exists = fs.existsSync(destination);
+    const unchanged = exists
+      && fs.statSync(destination).isFile()
+      && fs.readFileSync(destination).equals(fs.readFileSync(source));
+    return { file, destination, exists, unchanged };
+  });
+  const preserveRegistrations = files.some(file => file.exists && !file.unchanged);
+  let preserveHookFiles = preserveRegistrations;
+
+  for (const registration of manifest.registrations || []) {
+    const settingsPath = resolveWithin(projectRoot, registration.settings, 'hook settings path');
+    if (!fs.existsSync(settingsPath)) continue;
+
+    let settings;
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+        throw new Error('root value is not an object');
+      }
+    } catch {
+      report('warn', `hooks: ${registration.settings} is invalid JSON; leaving it unchanged`);
+      preserveHookFiles = true;
+      continue;
+    }
+
+    if (preserveRegistrations
+      && hasHookIdentity(settings, registration.event, registration.hook)) {
+      report('warn',
+        `hooks: leaving ${registration.event} registration in ${registration.settings} because a hook file was modified`);
+      preserveHookFiles = true;
+      continue;
+    }
+
+    let removed = false;
+    try {
+      removed = removeHookRegistration(
+        settings,
+        registration.event,
+        registration.hook,
+        registration.group || {},
+      );
+    } catch (error) {
+      report('warn', `hooks: could not safely inspect ${registration.settings}: ${error.message}`);
+      preserveHookFiles = true;
+      continue;
+    }
+
+    if (removed) {
+      fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+      report('success', `hooks: removed ${registration.event} from ${registration.settings}`);
+    } else if (hasHookIdentity(settings, registration.event, registration.hook)) {
+      report('warn',
+        `hooks: leaving modified ${registration.event} registration in ${registration.settings}`);
+      preserveHookFiles = true;
+    }
+  }
+
+  for (const { file, destination, exists, unchanged } of files) {
+    if (!exists) continue;
+    if (!unchanged) {
+      report('warn', `hooks: leaving modified hook file ${file.destination}`);
+      continue;
+    }
+    if (preserveHookFiles) {
+      report('warn', `hooks: leaving hook file ${file.destination} because a registration was preserved`);
+      continue;
+    }
+    fs.rmSync(destination);
+    report('success', `hooks: removed ${file.destination}`);
+  }
+
+  return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "td-ai-tools",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "Install agent skills and packs into your project",
   "type": "module",
   "scripts": {