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

package/commands/init.mjs

@@ -339,12 +339,16 @@ export async function initCommand(args) {
     if (oldManifest) pruneStaleHooks(oldManifest);
 
     await installAwEcc(cwd, { silent });
+
+    const setupSpinner = silent ? null : fmt.spinner();
+    if (setupSpinner) setupSpinner.start('Configuring hooks and IDE integration...');
     ensureAwRuntimeHook(HOME);
     syncHomeAndProjectInstructions(cwd, freshCfg?.namespace || team);
     await setupMcp(HOME, freshCfg?.namespace || team, { silent });
     applyStoredStartupPreferences(HOME);
     const removedLegacyStartupFiles = cwd !== HOME ? removeWorkspaceHookDefaults(cwd) : [];
     installGlobalHooks();
+    if (setupSpinner) setupSpinner.stop('Hooks and IDE integration configured');
 
     // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath (creates stale .aw_registry symlink)
     if (cwd !== HOME) {
@@ -482,6 +486,9 @@ export async function initCommand(args) {
   if (oldManifestFresh) pruneStaleHooks(oldManifestFresh);
 
   await installAwEcc(cwd, { silent });
+
+  const setupSpinnerFresh = silent ? null : fmt.spinner();
+  if (setupSpinnerFresh) setupSpinnerFresh.start('Configuring hooks and IDE integration...');
   ensureAwRuntimeHook(HOME);
 
   // Parallel batch B: post-ECC setup (instructions and MCP are independent)
@@ -494,6 +501,7 @@ export async function initCommand(args) {
   const removedLegacyStartupFiles = cwd !== HOME ? removeWorkspaceHookDefaults(cwd) : [];
   const hooksInstalled = installGlobalHooks();
   installIdeTasks();
+  if (setupSpinnerFresh) setupSpinnerFresh.stop('Hooks and IDE integration configured');
 
   // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath
   if (cwd !== HOME) {

package/ecc.mjs

@@ -259,13 +259,16 @@ export async function installAwEcc(
   { targets = ["cursor", "claude", "codex"], silent = false } = {},
 ) {
   if (process.env.AW_NO_ECC === '1') return;
-  if (!silent) fmt.logStep("Installing aw-ecc engine...");
 
   const repoDir = eccDir();
   const home = homedir();
 
+  const eccSpinner = silent ? null : fmt.spinner();
+
   try {
+    if (eccSpinner) eccSpinner.start('Cloning aw-ecc engine...');
     cloneOrUpdate(AW_ECC_TAG, repoDir);
+    if (eccSpinner) eccSpinner.message('Installing aw-ecc dependencies...');
 
     // Claude Code: plugin install via marketplace CLI (proper agent dispatch)
     if (targets.includes("claude")) {
@@ -291,6 +294,7 @@ export async function installAwEcc(
           run(`node "${generateHooksScript}"`, { cwd: repoDir });
         } catch { /* best effort — older engine versions may not have this script */ }
       }
+      if (eccSpinner) eccSpinner.message('Applying aw-ecc to IDE targets...');
       // Each target writes to disjoint paths (~/.claude/, ~/.cursor/, ~/.codex/) — safe to parallelize.
       await Promise.all(fileCopyTargets.map(async (target) => {
         try {
@@ -319,9 +323,10 @@ export async function installAwEcc(
 
     applyStoredStartupPreferences();
 
-    if (!silent) fmt.logSuccess("aw-ecc engine installed");
+    if (eccSpinner) eccSpinner.stop('aw-ecc engine installed');
   } catch (err) {
-    if (!silent) fmt.logWarn(`aw-ecc install failed: ${err.message}`);
+    if (eccSpinner) eccSpinner.stop(chalk.yellow(`aw-ecc install failed: ${err.message}`));
+    else if (!silent) fmt.logWarn(`aw-ecc install failed: ${err.message}`);
   }
 }
 

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.28",
   "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",