@ghl-ai/aw 0.1.55 → 0.1.56-beta.0

package/install-aw-usage-hooks.mjs

@@ -0,0 +1,303 @@
+// install-aw-usage-hooks.mjs — Self-sufficient producer-hook install.
+//
+// Why this exists:
+//   The aw-usage-*.js producer hooks (which emit telemetry events to the
+//   live cloud DB) used to live in aw-ecc and required a separate install +
+//   manual wiring into ~/.claude/settings.json. Devs running
+//     npm install -g @ghl-ai/aw && aw init
+//   would NOT get telemetry flowing — there was a silent gap in the
+//   installer. This module bundles the producer scripts into @ghl-ai/aw
+//   and writes them + the hook wiring during `aw init` so that
+//   step-1-then-step-2 is genuinely sufficient.
+//
+// What it does on `aw init`:
+//   1. Copies bundled aw-usage scripts (libs/aw/hooks/aw-usage/*.js) into
+//      ~/.claude/scripts/hooks/
+//   2. Copies the supporting lib files (aw-usage-telemetry.js, aw-pricing.js)
+//      into ~/.claude/scripts/lib/
+//   3. Non-destructively MERGES five hook phases into ~/.claude/settings.json:
+//        SessionStart, UserPromptSubmit, PostToolUse, PostToolUseFailure, Stop
+//      (Each phase array gets ONE new entry appended, with `description` so
+//       it can be identified + re-applied on future runs.)
+//   4. Ensures ~/.aw/telemetry/config.json exists with machine_id + enabled
+//      (so the hooks can self-resolve their config on first fire).
+//
+// What it does NOT do:
+//   - Overwrite existing hooks (the graphify SessionStart, plugin hooks, etc.
+//     are preserved verbatim — we only append).
+//   - Set telemetry_url. Default (omitted) → events go to the production API
+//     at services.leadconnectorhq.com. Devs can override locally for
+//     localhost testing.
+//   - Touch ~/.codex/. Codex hook wiring is handled separately (TODO: extend
+//     here when we have the same pattern stabilized for Codex).
+//
+// Idempotent: re-running `aw init` is a no-op once everything is in place.
+
+import { readFileSync, writeFileSync, mkdirSync, copyFileSync, existsSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir, hostname, userInfo } from 'node:os';
+import { createHash } from 'node:crypto';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Bundled layout (mirrors aw-ecc/scripts/) so the scripts' relative
+// `require('../lib/aw-usage-telemetry')` paths resolve correctly:
+//   libs/aw/hooks/aw-usage/
+//     ├── package.json    ("type": "commonjs" — overrides parent ESM)
+//     ├── hooks/          (7 scripts)
+//     └── lib/            (aw-usage-telemetry.js, aw-pricing.js)
+const BUNDLED_ROOT = join(__dirname, 'hooks', 'aw-usage');
+const BUNDLED_HOOKS_DIR = join(BUNDLED_ROOT, 'hooks');
+const BUNDLED_LIB_DIR = join(BUNDLED_ROOT, 'lib');
+const HOME = homedir();
+
+// IDE targets we install into. Claude Code is the only fully-wired target.
+// Cursor + Codex are deliberately deferred — copying scripts without wiring
+// the matching hooks.json was misleading (events never fired). A follow-up
+// PR will wire ~/.cursor/hooks/hooks.json properly.
+const IDE_TARGETS = [
+  { name: 'Claude Code',  configFile: join(HOME, '.claude', 'settings.json'),  scriptsRoot: join(HOME, '.claude', 'scripts'),  shouldWireConfig: true  },
+];
+
+const HOOK_SCRIPTS = [
+  'aw-usage-prompt-submit.js',
+  'aw-usage-post-tool-use.js',
+  'aw-usage-post-tool-use-failure.js',
+  'aw-usage-session-start.js',
+  'aw-usage-stop.js',
+  'aw-usage-telemetry-send.js',
+  'aw-usage-commit-created.js',
+];
+
+const LIB_FILES = [
+  'aw-usage-telemetry.js',
+  'aw-pricing.js',
+];
+
+// Hook description marker — used to detect prior install + idempotent re-apply.
+const MARKER = 'AW usage telemetry';
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function safeMkdir(dir) {
+  try { mkdirSync(dir, { recursive: true }); } catch { /* best effort */ }
+}
+
+// Tri-state result so callers can distinguish a real failure from a no-op:
+//   'copied'    — wrote bytes
+//   'unchanged' — destination already matches source byte-for-byte
+//   'failed'    — source missing OR write/read threw (permissions, EBUSY, …)
+function copyIfChanged(src, dest) {
+  if (!existsSync(src)) return 'failed';
+  try {
+    if (existsSync(dest)) {
+      const a = readFileSync(src);
+      const b = readFileSync(dest);
+      if (a.equals(b)) return 'unchanged';
+    }
+    copyFileSync(src, dest);
+    return 'copied';
+  } catch { return 'failed'; }
+}
+
+function generateMachineId() {
+  return createHash('sha256')
+    .update(`${hostname()}:${userInfo().username}`)
+    .digest('hex');
+}
+
+// ── Telemetry config bootstrap ───────────────────────────────────────
+
+function ensureTelemetryConfig() {
+  const cfgPath = join(HOME, '.aw', 'telemetry', 'config.json');
+  safeMkdir(dirname(cfgPath));
+  let cfg = {};
+  if (existsSync(cfgPath)) {
+    try { cfg = JSON.parse(readFileSync(cfgPath, 'utf8')); } catch { cfg = {}; }
+  }
+  let changed = false;
+  if (!cfg.machine_id || cfg.machine_id === 'unknown') {
+    cfg.machine_id = generateMachineId();
+    changed = true;
+  }
+  if (cfg.enabled !== false && cfg.enabled !== true) {
+    cfg.enabled = true;
+    changed = true;
+  }
+  if (changed) writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n');
+  return { cfgPath, changed };
+}
+
+// ── settings.json hook merge ─────────────────────────────────────────
+
+function settingsHookEntry(scriptName, description, scriptsRoot, withMatcher) {
+  // Use $HOME so the path is portable across machines. Shell expansion
+  // applies when Claude invokes the command.
+  const portablePath = scriptsRoot
+    .replace(HOME, '$HOME')
+    .split(/[\\/]/).join('/');
+  const cmd = `node "${portablePath}/hooks/${scriptName}"`;
+  const entry = {
+    hooks: [{
+      type: 'command',
+      command: cmd,
+      async: true,
+      timeout: 10,
+    }],
+    description,
+  };
+  if (withMatcher) entry.matcher = '*';
+  return entry;
+}
+
+function alreadyWired(phaseArray, expectedCommand) {
+  if (!Array.isArray(phaseArray)) return false;
+  return phaseArray.some(group =>
+    Array.isArray(group?.hooks) &&
+    group.hooks.some(h => h?.command === expectedCommand)
+  );
+}
+
+function isLegacyAwUsageHookGroup(group, expectedCommand, scriptName) {
+  if (!Array.isArray(group?.hooks)) return false;
+  const commands = group.hooks
+    .map(h => h?.command)
+    .filter(command => typeof command === 'string');
+  const hasExpected = commands.includes(expectedCommand);
+  const hasLegacyAwUsage = commands.some((command) => {
+    const normalized = command.split('\\').join('/');
+    return command.includes(scriptName) &&
+      (normalized.includes('/.aw-ecc/') || command.includes('${CLAUDE_PLUGIN_ROOT}'));
+  });
+  return !hasExpected && hasLegacyAwUsage;
+}
+
+function mergeSettings(configFile, scriptsRoot) {
+  safeMkdir(dirname(configFile));
+  let cfg = {};
+  if (existsSync(configFile)) {
+    try { cfg = JSON.parse(readFileSync(configFile, 'utf8')); } catch { cfg = {}; }
+  }
+  cfg.hooks = cfg.hooks && typeof cfg.hooks === 'object' && !Array.isArray(cfg.hooks)
+    ? cfg.hooks
+    : {};
+
+  const phases = [
+    { name: 'SessionStart',       script: 'aw-usage-session-start.js',         desc: `${MARKER}: session_start`,                              matcher: false },
+    { name: 'UserPromptSubmit',   script: 'aw-usage-prompt-submit.js',         desc: `${MARKER}: prompt_submitted with slash-command detection`, matcher: false },
+    { name: 'PostToolUse',        script: 'aw-usage-post-tool-use.js',         desc: `${MARKER}: skill/agent/error/test/sdlc events`,         matcher: true  },
+    { name: 'PostToolUseFailure', script: 'aw-usage-post-tool-use-failure.js', desc: `${MARKER}: tool_error on failure`,                      matcher: true  },
+    { name: 'Stop',               script: 'aw-usage-stop.js',                  desc: `${MARKER}: response_completed with tokens + cost`,       matcher: true  },
+  ];
+
+  let changed = 0;
+  for (const phase of phases) {
+    // Normalize: existing config may have a non-array value here from a manual
+    // edit or another tool — don't trust truthiness, demand an array.
+    cfg.hooks[phase.name] = Array.isArray(cfg.hooks[phase.name]) ? cfg.hooks[phase.name] : [];
+    const entry = settingsHookEntry(phase.script, phase.desc, scriptsRoot, phase.matcher);
+    const before = cfg.hooks[phase.name].length;
+    cfg.hooks[phase.name] = cfg.hooks[phase.name].filter(group =>
+      !isLegacyAwUsageHookGroup(group, entry.hooks[0].command, phase.script)
+    );
+    changed += before - cfg.hooks[phase.name].length;
+    if (!alreadyWired(cfg.hooks[phase.name], entry.hooks[0].command)) {
+      cfg.hooks[phase.name].push(entry);
+      changed++;
+    }
+  }
+
+  if (changed > 0) {
+    writeFileSync(configFile, JSON.stringify(cfg, null, 2) + '\n');
+  }
+  return { added: changed, configFile };
+}
+
+// ── Main entry ───────────────────────────────────────────────────────
+
+/**
+ * Install the aw-usage producer hooks into ~/.claude/.
+ * Idempotent — safe to re-run.
+ *
+ * @returns {{
+ *   scriptsCopied: number,
+ *   scriptsUnchanged: number,
+ *   scriptsFailed: number,
+ *   libCopied: number,
+ *   libUnchanged: number,
+ *   libFailed: number,
+ *   targetsConfigured: string[],
+ *   telemetryConfigInitialized: boolean,
+ * }}
+ */
+export function installAwUsageHooks() {
+  const result = {
+    scriptsCopied: 0,
+    scriptsUnchanged: 0,
+    scriptsFailed: 0,
+    libCopied: 0,
+    libUnchanged: 0,
+    libFailed: 0,
+    targetsConfigured: [],
+    telemetryConfigInitialized: false,
+  };
+
+  if (!existsSync(BUNDLED_HOOKS_DIR) || !existsSync(BUNDLED_LIB_DIR)) {
+    // Bundled scripts missing — nothing to install. Caller can decide.
+    return result;
+  }
+
+  // 1. Copy scripts + lib to each IDE target
+  for (const target of IDE_TARGETS) {
+    const hooksDest = join(target.scriptsRoot, 'hooks');
+    const libDest = join(target.scriptsRoot, 'lib');
+    safeMkdir(hooksDest);
+    safeMkdir(libDest);
+
+    for (const name of HOOK_SCRIPTS) {
+      const src = join(BUNDLED_HOOKS_DIR, name);
+      const dest = join(hooksDest, name);
+      const r = copyIfChanged(src, dest);
+      if (r === 'copied') result.scriptsCopied++;
+      else if (r === 'unchanged') result.scriptsUnchanged++;
+      else result.scriptsFailed++;
+    }
+    for (const name of LIB_FILES) {
+      const src = join(BUNDLED_LIB_DIR, name);
+      const dest = join(libDest, name);
+      const r = copyIfChanged(src, dest);
+      if (r === 'copied') result.libCopied++;
+      else if (r === 'unchanged') result.libUnchanged++;
+      else result.libFailed++;
+    }
+
+    // 2. Merge hook wiring into settings.json (Claude only for now)
+    if (target.shouldWireConfig && target.configFile) {
+      const { added, configFile } = mergeSettings(target.configFile, target.scriptsRoot);
+      if (added > 0) result.targetsConfigured.push(`${target.name}:${configFile}`);
+    }
+  }
+
+  // 3. Bootstrap telemetry config
+  const { changed } = ensureTelemetryConfig();
+  result.telemetryConfigInitialized = changed;
+
+  return result;
+}
+
+/**
+ * Print a tidy summary of what installAwUsageHooks did.
+ */
+export function formatAwUsageHooksInstallReport(result) {
+  const parts = [];
+  if (result.scriptsCopied > 0) parts.push(`${result.scriptsCopied} scripts`);
+  if (result.libCopied > 0) parts.push(`${result.libCopied} lib files`);
+  if (result.targetsConfigured.length > 0) parts.push(`wired ${result.targetsConfigured.length} settings.json`);
+  if (result.telemetryConfigInitialized) parts.push('bootstrapped telemetry config');
+  // Surface failures even when everything else is a no-op, so an install that
+  // silently lost files doesn't masquerade as "already up to date".
+  const failedTotal = (result.scriptsFailed || 0) + (result.libFailed || 0);
+  if (failedTotal > 0) parts.push(`⚠ ${failedTotal} failed (check ~/.claude/scripts/ permissions)`);
+  if (parts.length === 0) return 'aw-usage hooks already up to date';
+  return `aw-usage hooks: ${parts.join(' · ')}`;
+}

package/integrations.mjs

@@ -24,6 +24,10 @@ const execAsync = promisify(exec);
 const HOME = homedir();
 const MANIFEST_PATH = join(HOME, '.aw_registry', '.integration-manifest.json');
 
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // ────────────────────────────────────────────────────────────────────────────────
 // INTEGRATION REGISTRY
 // ────────────────────────────────────────────────────────────────────────────────
@@ -109,7 +113,7 @@ export const INTEGRATIONS = {
     type: 'python-cli',
     label: 'Graphify (Knowledge Graph)',
     description: 'Builds a queryable knowledge graph of your codebase + docs',
-    pipPackage: 'graphifyy',
+    pipPackage: 'graphifyy[mcp,pdf,office,svg,sql,google,neo4j]',
     cliCommand: 'graphify',
     minPython: { major: 3, minor: 10 },
     postInstall: [
@@ -204,7 +208,7 @@ function addToJsonMcp(filePath, serverName, config) {
     try {
       existing = JSON.parse(readFileSync(filePath, 'utf8'));
     } catch {
-      // Corrupted file, start fresh
+      existing = {};
     }
   }
 
@@ -244,6 +248,12 @@ function addToTomlMcp(filePath, serverName, url) {
 const IS_WINDOWS = process.platform === 'win32';
 const WHICH_CMD = IS_WINDOWS ? 'where' : 'which';
 
+function quoteHookCommandArg(value) {
+  const text = String(value);
+  if (IS_WINDOWS) return `"${text.replace(/"/g, '\\"')}"`;
+  return "'" + text.replace(/'/g, "'\\''") + "'";
+}
+
 // Try interpreters in order; return the first that meets minPython, or null.
 async function detectPython({ major, minor }) {
   const candidates = IS_WINDOWS
@@ -286,14 +296,14 @@ async function pickPythonInstaller(pythonCmd) {
 // current project's graph into ~/.graphify/global-graph.json every time Claude Code
 // opens in a project that has a built graph. Fast (JSON merge only, no LLM).
 // Written globally so one hook covers all projects — guarded by graph.json existence.
-export function installGraphifyGlobalAddHook(homeDir) {
+export function installGraphifyGlobalAddHook(homeDir, installerName = 'pip') {
   const claudeDir = join(homeDir, '.claude');
   if (!existsSync(claudeDir)) return;
 
   const settingsPath = join(claudeDir, 'settings.json');
   let settings = {};
   if (existsSync(settingsPath)) {
-    try { settings = JSON.parse(readFileSync(settingsPath, 'utf8')); } catch { /* corrupt — start fresh */ }
+    try { settings = JSON.parse(readFileSync(settingsPath, 'utf8')); } catch { settings = {}; }
   }
 
   if (!settings.hooks) settings.hooks = {};
@@ -308,8 +318,35 @@ export function installGraphifyGlobalAddHook(homeDir) {
   // across future shell sessions where an old graphify binary might shadow the
   // currently-installed version via PATH. Derived fresh here rather than baking
   // in the cli token resolved at install time.
-  const pythonExe = IS_WINDOWS ? 'python' : 'python3';
-  const cmd = `[ -f graphify-out/graph.json ] && ${pythonExe} -m graphify global add graphify-out/graph.json --as "$(basename "$PWD")" > /dev/null 2>&1 || true`;
+  const pythonExe = resolveGraphifyPython(installerName, homeDir);
+  const scriptsDir = join(claudeDir, 'scripts');
+  const scriptPath = join(scriptsDir, 'graphify-global-add.mjs');
+  mkdirSync(scriptsDir, { recursive: true });
+  writeFileSync(scriptPath, `import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename } from 'node:path';
+
+const pythonExe = process.argv[2] || (process.platform === 'win32' ? 'python' : 'python3');
+const graphPath = 'graphify-out/graph.json';
+
+if (!existsSync(graphPath)) {
+  process.exit(0);
+}
+
+const result = spawnSync(
+  pythonExe,
+  ['-m', 'graphify', 'global', 'add', graphPath, '--as', basename(process.cwd())],
+  { stdio: 'ignore', windowsHide: true },
+);
+
+if (result.error) {
+  process.exit(0);
+}
+
+process.exit(0);
+`);
+
+  const cmd = `${quoteHookCommandArg(process.execPath || 'node')} ${quoteHookCommandArg(scriptPath)} ${quoteHookCommandArg(pythonExe)}`;
 
   settings.hooks.SessionStart.push({
     description: MARKER,
@@ -320,38 +357,49 @@ export function installGraphifyGlobalAddHook(homeDir) {
   writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
 }
 
-// Write the graphify-global MCP server entry to ~/.claude/settings.json so Claude Code
-// auto-starts it on launch. Uses `python -m graphify.serve` to avoid PATH issues with
-// stale graphify.exe binaries that may shadow the currently installed version.
-//
-// The command is a single stable token — `python` on Windows, `python3` on POSIX —
-// so the JSON args array is always parseable (py.cmd can be `py -3` which has a space
-// and would break if used directly as the command field).
-export function installGraphifyMcpServer(homeDir) {
-  const claudeDir = join(homeDir, '.claude');
-  if (!existsSync(claudeDir)) return;
+// Resolve the Python executable that has graphify installed.
+// uv/pipx create isolated venvs — system `python` won't find the module.
+function resolveGraphifyPython(installerName, homeDir) {
+  if (installerName === 'uv') {
+    const appData = IS_WINDOWS
+      ? (process.env.APPDATA || join(homeDir, 'AppData', 'Roaming'))
+      : join(homeDir, '.local', 'share');
+    const candidate = IS_WINDOWS
+      ? join(appData, 'uv', 'tools', 'graphifyy', 'Scripts', 'python.exe')
+      : join(appData, 'uv', 'tools', 'graphifyy', 'bin', 'python');
+    if (existsSync(candidate)) return candidate;
+  }
+  if (installerName === 'pipx') {
+    const candidate = IS_WINDOWS
+      ? join(homeDir, '.local', 'pipx', 'venvs', 'graphifyy', 'Scripts', 'python.exe')
+      : join(homeDir, '.local', 'pipx', 'venvs', 'graphifyy', 'bin', 'python');
+    if (existsSync(candidate)) return candidate;
+  }
+  // pip --user: graphify lands in system site-packages, system python works.
+  return IS_WINDOWS ? 'python' : 'python3';
+}
 
-  const settingsPath = join(claudeDir, 'settings.json');
-  let settings = {};
-  if (existsSync(settingsPath)) {
-    try { settings = JSON.parse(readFileSync(settingsPath, 'utf8')); } catch { /* corrupt — start fresh */ }
+// Write the graphify-global MCP server entry to ~/.claude.json so Claude Code CLI
+// picks it up via `claude mcp list`. Uses the venv Python for uv/pipx installs so
+// `python -m graphify.serve` resolves correctly (system python won't find the module).
+export function installGraphifyMcpServer(homeDir, installerName = 'pip') {
+  const claudeJsonPath = join(homeDir, '.claude.json');
+  let config = {};
+  if (existsSync(claudeJsonPath)) {
+    try { config = JSON.parse(readFileSync(claudeJsonPath, 'utf8')); } catch { config = {}; }
   }
 
-  if (!settings.mcpServers) settings.mcpServers = {};
+  if (!config.mcpServers) config.mcpServers = {};
 
-  // Use join() so the path uses OS-correct separators on all platforms.
   const globalGraphPath = join(homeDir, '.graphify', 'global-graph.json');
-  // `python` on Windows (Microsoft Store + standard installer both put it on PATH),
-  // `python3` on macOS/Linux (standard convention; `python` may not exist).
-  const pythonExe = IS_WINDOWS ? 'python' : 'python3';
+  const pythonExe = resolveGraphifyPython(installerName, homeDir);
 
-  settings.mcpServers['graphify-global'] = {
+  config.mcpServers['graphify-global'] = {
     command: pythonExe,
     args: ['-m', 'graphify.serve', globalGraphPath],
   };
 
-  mkdirSync(claudeDir, { recursive: true });
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  writeFileSync(claudeJsonPath, JSON.stringify(config, null, 2) + '\n');
 }
 
 // After pip install, the CLI binary may not be on PATH (pip --user puts it in a Scripts
@@ -436,8 +484,8 @@ async function runPythonCli(integration, key, { silent = false } = {}) {
   //     The graph itself is built manually via `/graphify .` — graphify's own per-IDE
   //     install (step 6 below) writes the CLAUDE.md / AGENTS.md sections for that.
   if (integration.cliCommand === 'graphify') {
-    installGraphifyMcpServer(HOME);
-    installGraphifyGlobalAddHook(HOME);
+    installGraphifyMcpServer(HOME, installer.name);
+    installGraphifyGlobalAddHook(HOME, installer.name);
   }
 
   // 6. Run per-project hooks if cwd looks like a real project (not HOME).
@@ -540,7 +588,9 @@ async function runUniversalInstaller(integration, key, { silent = false } = {})
           // Verify bash is actually available inside WSL
           execSync('wsl -- bash --version', { stdio: 'ignore' });
           wslOk = true;
-        } catch { /* WSL absent or bash not installed */ }
+        } catch {
+          wslOk = false;
+        }
 
         if (wslOk) {
           cmd = `wsl -- bash -c "curl -fsSL '${integration.scripts.posix}' | sh"`;
@@ -730,8 +780,8 @@ export async function removeIntegration(key, { silent = false } = {}) {
           delete config.mcpServers?.[key];
           writeFileSync(claudePath, JSON.stringify(config, null, 2) + '\n');
         }
-      } catch {
-        // Best effort
+      } catch (error) {
+        if (!silent) fmt.logWarn(`Claude MCP cleanup skipped: ${getErrorMessage(error)}`, 'Cleanup Warning');
       }
 
       // Cursor
@@ -742,8 +792,8 @@ export async function removeIntegration(key, { silent = false } = {}) {
           delete config.mcpServers?.[key];
           writeFileSync(cursorPath, JSON.stringify(config, null, 2) + '\n');
         }
-      } catch {
-        // Best effort
+      } catch (error) {
+        if (!silent) fmt.logWarn(`Cursor MCP cleanup skipped: ${getErrorMessage(error)}`, 'Cleanup Warning');
       }
 
       // Codex
@@ -758,8 +808,8 @@ export async function removeIntegration(key, { silent = false } = {}) {
           content = content.replace(blockRegex, '');
           writeFileSync(codexPath, content);
         }
-      } catch {
-        // Best effort
+      } catch (error) {
+        if (!silent) fmt.logWarn(`Codex MCP cleanup skipped: ${getErrorMessage(error)}`, 'Cleanup Warning');
       }
 
       if (!silent) fmt.logSuccess(`${integration.label} removed from MCP servers`);
@@ -770,7 +820,7 @@ export async function removeIntegration(key, { silent = false } = {}) {
         fmt.logWarn(
           `Removed ${integration.label} from the aw manifest. The Python package was left installed.\n` +
           `  To fully remove, run in each project: \`${integration.cliCommand} claude uninstall\` and \`${integration.cliCommand} hook uninstall\`\n` +
-          `  Then uninstall the package: \`pip uninstall ${integration.pipPackage.split(/[<>=]/)[0]}\` (or \`uv tool uninstall\` / \`pipx uninstall\`)`,
+          `  Then uninstall the package: \`pip uninstall ${integration.pipPackage.split(/[<>=\[]/)[0]}\` (or \`uv tool uninstall\` / \`pipx uninstall\`)`,
           'Manual Cleanup',
         );
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.55",
+  "version": "0.1.56-beta.0",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {
@@ -33,6 +33,7 @@
     "update.mjs",
     "hooks.mjs",
     "hooks/",
+    "install-aw-usage-hooks.mjs",
     "startup.mjs",
     "ecc.mjs",
     "integrations.mjs",
@@ -40,7 +41,7 @@
     "telemetry.mjs"
   ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "keywords": [
     "ai",