@ghl-ai/aw 0.1.42-beta.26 → 0.1.42-beta.27

package/hook-cleanup.mjs

@@ -0,0 +1,301 @@
+// hook-cleanup.mjs — Hook cleanup manifest for safe version transitions.
+//
+// writeHookManifest()  → snapshots all AW hook touchpoints to ~/.aw/hooks/manifest.json
+// readHookManifest()   → reads and validates the manifest
+// pruneStaleHooks()    → removes hook entries and runtime deps listed in a manifest
+// removeHookManifest() → deletes the manifest file
+
+import {
+  existsSync, mkdirSync, readFileSync, readdirSync,
+  rmSync, writeFileSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+const SCHEMA_VERSION = 'aw-hooks.v1';
+const HOME = homedir();
+const MANIFEST_PATH = join(HOME, '.aw', 'hooks', 'manifest.json');
+
+// ── Patterns matching AW-managed hook entries ────────────────────────────
+
+function isManagedClaudeEntry(entry) {
+  if (entry?.description === 'AW usage telemetry') return true;
+  const cmds = Array.isArray(entry?.hooks) ? entry.hooks.map(h => h?.command || '') : [];
+  return cmds.some(c => c.includes('aw-usage-'));
+}
+
+function isManagedCursorEntry(entry) {
+  const cmd = String(entry?.command || '');
+  return cmd.includes('.cursor/hooks/') || cmd.includes('aw-ecc');
+}
+
+function isManagedCodexEntry(entry) {
+  if (Array.isArray(entry?.hooks)) {
+    return entry.hooks.some(h => {
+      const cmd = String(h?.command || '');
+      return cmd.includes('.codex/hooks/') || cmd.includes('aw-ecc') || cmd.includes('aw-session-start');
+    });
+  }
+  return false;
+}
+
+// ── Read helpers ─────────────────────────────────────────────────────────
+
+function readJson(filePath) {
+  if (!existsSync(filePath)) return null;
+  try { return JSON.parse(readFileSync(filePath, 'utf8')); } catch { return null; }
+}
+
+function writeJson(filePath, data) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+
+// ── Collect current hook state ───────────────────────────────────────────
+
+function collectClaudeTouchpoints() {
+  const settingsPath = join(HOME, '.claude', 'settings.json');
+  const hooksJsonPath = join(HOME, '.claude', 'hooks', 'hooks.json');
+  const settings = readJson(settingsPath);
+  const phases = [];
+  if (settings?.hooks) {
+    for (const phase of Object.keys(settings.hooks)) {
+      const entries = settings.hooks[phase];
+      if (Array.isArray(entries) && entries.some(isManagedClaudeEntry)) {
+        phases.push(phase);
+      }
+    }
+  }
+  return {
+    settingsPath,
+    hooksJsonPath: existsSync(hooksJsonPath) ? hooksJsonPath : null,
+    managedPhases: phases,
+  };
+}
+
+function collectCursorTouchpoints() {
+  const hooksJsonPath = join(HOME, '.cursor', 'hooks.json');
+  const config = readJson(hooksJsonPath);
+  const phases = [];
+  if (config?.hooks) {
+    for (const phase of Object.keys(config.hooks)) {
+      const entries = config.hooks[phase];
+      if (Array.isArray(entries) && entries.some(isManagedCursorEntry)) {
+        phases.push(phase);
+      }
+    }
+  }
+  return { hooksJsonPath, managedPhases: phases };
+}
+
+function collectCodexTouchpoints() {
+  const hooksJsonPath = join(HOME, '.codex', 'hooks.json');
+  const configPath = join(HOME, '.codex', 'config.toml');
+  const config = readJson(hooksJsonPath);
+  const phases = [];
+  if (config?.hooks) {
+    for (const phase of Object.keys(config.hooks)) {
+      const entries = config.hooks[phase];
+      if (Array.isArray(entries) && entries.some(isManagedCodexEntry)) {
+        phases.push(phase);
+      }
+    }
+  }
+  return {
+    configPath: existsSync(configPath) ? configPath : null,
+    hooksJsonPath,
+    managedPhases: phases,
+  };
+}
+
+function collectGitTouchpoints() {
+  const hooksDir = join(HOME, '.aw', 'hooks');
+  const scripts = [];
+  if (existsSync(hooksDir)) {
+    try {
+      for (const entry of readdirSync(hooksDir)) {
+        // Exclude the manifest itself and hidden files
+        if (entry === 'manifest.json' || entry.startsWith('.')) continue;
+        scripts.push(entry);
+      }
+    } catch { /* best effort */ }
+  }
+  return { hooksDir, scripts };
+}
+
+function collectRuntimeDeps() {
+  const deps = [];
+  const hooksDir = join(HOME, '.aw-ecc', 'scripts', 'hooks');
+  const libDir = join(HOME, '.aw-ecc', 'scripts', 'lib');
+
+  if (existsSync(hooksDir)) {
+    try {
+      for (const entry of readdirSync(hooksDir)) {
+        if (entry.startsWith('aw-usage-')) {
+          deps.push(join(hooksDir, entry));
+        }
+      }
+    } catch { /* best effort */ }
+  }
+
+  const telemetryLib = join(libDir, 'aw-usage-telemetry.js');
+  if (existsSync(telemetryLib)) {
+    deps.push(telemetryLib);
+  }
+
+  return deps;
+}
+
+// ── Public API ───────────────────────────────────────────────────────────
+
+/**
+ * Write a hook manifest capturing all current AW hook touchpoints.
+ * @param {{ eccVersion: string, awVersion: string }} opts
+ * @returns {object} the written manifest
+ */
+export function writeHookManifest({ eccVersion, awVersion }) {
+  const manifest = {
+    schemaVersion: SCHEMA_VERSION,
+    createdAt: new Date().toISOString(),
+    eccVersion,
+    awVersion,
+    touchpoints: {
+      claude: collectClaudeTouchpoints(),
+      cursor: collectCursorTouchpoints(),
+      codex: collectCodexTouchpoints(),
+      git: collectGitTouchpoints(),
+    },
+    runtimeDeps: collectRuntimeDeps(),
+  };
+
+  writeJson(MANIFEST_PATH, manifest);
+  return manifest;
+}
+
+/**
+ * Read and validate the hook manifest.
+ * @returns {object|null} the manifest, or null if missing/invalid
+ */
+export function readHookManifest() {
+  const data = readJson(MANIFEST_PATH);
+  if (!data || data.schemaVersion !== SCHEMA_VERSION) return null;
+  return data;
+}
+
+/**
+ * Remove hook entries and runtime deps listed in a manifest.
+ * Does NOT touch git hooks (handled by removeGlobalHooks).
+ * @param {object} manifest — from readHookManifest()
+ * @returns {number} count of items removed
+ */
+export function pruneStaleHooks(manifest) {
+  if (!manifest?.touchpoints) return 0;
+  let removed = 0;
+
+  // Claude: remove managed telemetry entries from settings.json
+  const claudeSettings = manifest.touchpoints.claude;
+  if (claudeSettings?.settingsPath && claudeSettings.managedPhases?.length > 0) {
+    const config = readJson(claudeSettings.settingsPath);
+    if (config?.hooks) {
+      let changed = false;
+      for (const phase of claudeSettings.managedPhases) {
+        const entries = config.hooks[phase];
+        if (!Array.isArray(entries)) continue;
+        const filtered = entries.filter(e => !isManagedClaudeEntry(e));
+        if (filtered.length !== entries.length) {
+          changed = true;
+          removed += entries.length - filtered.length;
+          if (filtered.length > 0) {
+            config.hooks[phase] = filtered;
+          } else {
+            delete config.hooks[phase];
+          }
+        }
+      }
+      if (changed) {
+        if (Object.keys(config.hooks).length === 0) delete config.hooks;
+        writeJson(claudeSettings.settingsPath, config);
+      }
+    }
+  }
+
+  // Cursor: remove managed entries from hooks.json
+  const cursorHooks = manifest.touchpoints.cursor;
+  if (cursorHooks?.hooksJsonPath && cursorHooks.managedPhases?.length > 0) {
+    const config = readJson(cursorHooks.hooksJsonPath);
+    if (config?.hooks) {
+      let changed = false;
+      for (const phase of cursorHooks.managedPhases) {
+        const entries = config.hooks[phase];
+        if (!Array.isArray(entries)) continue;
+        const filtered = entries.filter(e => !isManagedCursorEntry(e));
+        if (filtered.length !== entries.length) {
+          changed = true;
+          removed += entries.length - filtered.length;
+          if (filtered.length > 0) {
+            config.hooks[phase] = filtered;
+          } else {
+            delete config.hooks[phase];
+          }
+        }
+      }
+      if (changed) {
+        if (Object.keys(config.hooks).length === 0) delete config.hooks;
+        writeJson(cursorHooks.hooksJsonPath, config);
+      }
+    }
+  }
+
+  // Codex: remove managed entries from hooks.json
+  const codexHooks = manifest.touchpoints.codex;
+  if (codexHooks?.hooksJsonPath && codexHooks.managedPhases?.length > 0) {
+    const config = readJson(codexHooks.hooksJsonPath);
+    if (config?.hooks) {
+      let changed = false;
+      for (const phase of codexHooks.managedPhases) {
+        const entries = config.hooks[phase];
+        if (!Array.isArray(entries)) continue;
+        const filtered = entries.filter(e => !isManagedCodexEntry(e));
+        if (filtered.length !== entries.length) {
+          changed = true;
+          removed += entries.length - filtered.length;
+          if (filtered.length > 0) {
+            config.hooks[phase] = filtered;
+          } else {
+            delete config.hooks[phase];
+          }
+        }
+      }
+      if (changed) {
+        if (Object.keys(config.hooks).length === 0) delete config.hooks;
+        writeJson(codexHooks.hooksJsonPath, config);
+      }
+    }
+  }
+
+  // Runtime deps: remove aw-usage-* files
+  if (Array.isArray(manifest.runtimeDeps)) {
+    for (const dep of manifest.runtimeDeps) {
+      if (existsSync(dep)) {
+        try {
+          rmSync(dep, { force: true });
+          removed++;
+        } catch { /* best effort */ }
+      }
+    }
+  }
+
+  return removed;
+}
+
+/**
+ * Delete the manifest file.
+ */
+export function removeHookManifest() {
+  if (existsSync(MANIFEST_PATH)) {
+    rmSync(MANIFEST_PATH, { force: true });
+  }
+}
+
+// Export for testing
+export { MANIFEST_PATH, SCHEMA_VERSION };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.42-beta.26",
+  "version": "0.1.42-beta.27",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {
@@ -26,6 +26,7 @@
     "slack-sim/",
     "file-tree.mjs",
     "apply.mjs",
+    "hook-cleanup.mjs",
     "hook-manifest.mjs",
     "update.mjs",
     "hooks.mjs",