@ghl-ai/aw 0.1.30-beta.3 → 0.1.30-beta.6

package/hooks.mjs

@@ -0,0 +1,144 @@
+// hooks.mjs — Global git hooks via core.hooksPath (git-lfs pattern).
+//
+// installGlobalHooks() → writes dispatcher scripts to ~/.aw/hooks/,
+//                         sets core.hooksPath with chaining to .git/hooks/
+// removeGlobalHooks()  → restores previous core.hooksPath, removes ~/.aw/hooks/
+
+import { mkdirSync, writeFileSync, readFileSync, existsSync, chmodSync, rmSync, readdirSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import * as fmt from './fmt.mjs';
+
+const HOME = homedir();
+const HOOKS_DIR = join(HOME, '.aw', 'hooks');
+const PREV_PATH_FILE = join(HOOKS_DIR, '.previous-hooks-path');
+
+// ── Dispatcher scripts ─────────────────────────────────────────────────
+// Each hook: (1) runs aw logic in background, (2) chains to previous
+// hooksPath if another tool owned it, (3) chains to repo-local .git/hooks/.
+// `exec` replaces the shell process so the local hook's exit code propagates.
+
+function makeDispatcher(hookName, awBlock) {
+  return `#!/bin/sh
+# aw: global ${hookName} dispatcher (installed by aw init)
+# Chains to local hooks — see https://git-scm.com/docs/githooks
+
+# Skip if inside aw's own temp sparse checkout (prevents recursion)
+case "$(pwd)" in /tmp/aw-*|/var/folders/*/aw-*) exit 0 ;; esac
+
+${awBlock}
+
+# Chain to previous hooksPath (if another tool set it before aw)
+PREV_PATH_FILE="$HOME/.aw/hooks/.previous-hooks-path"
+if [ -f "$PREV_PATH_FILE" ]; then
+  PREV_HOOK="$(cat "$PREV_PATH_FILE")/${hookName}"
+  if [ -x "$PREV_HOOK" ]; then
+    exec "$PREV_HOOK" "$@"
+  fi
+fi
+
+# Chain to repo-local hook
+GIT_DIR="$(git rev-parse --git-dir 2>/dev/null)"
+if [ -n "$GIT_DIR" ]; then
+  LOCAL_HOOK="$GIT_DIR/hooks/${hookName}"
+  [ -x "$LOCAL_HOOK" ] && exec "$LOCAL_HOOK" "$@"
+fi
+
+exit 0
+`;
+}
+
+const POST_MERGE = makeDispatcher('post-merge', `\
+if command -v aw >/dev/null 2>&1; then
+  aw init --silent >/dev/null 2>&1 &
+fi`);
+
+const POST_CHECKOUT = makeDispatcher('post-checkout', `\
+AW_REGISTRY="$HOME/.aw_registry"
+if [ -d "$AW_REGISTRY" ] && [ ! -e ".aw_registry" ] && [ -d ".git" ]; then
+  ln -s "$AW_REGISTRY" ".aw_registry" 2>/dev/null
+fi
+if command -v aw >/dev/null 2>&1; then
+  aw init --silent >/dev/null 2>&1 &
+fi`);
+
+/**
+ * Install global git hooks at ~/.aw/hooks/ and set core.hooksPath.
+ * If core.hooksPath is already set by another tool, saves the previous
+ * value for chaining and restoration on uninstall.
+ * @returns {boolean} true if hooks were installed
+ */
+export function installGlobalHooks() {
+  try {
+    mkdirSync(HOOKS_DIR, { recursive: true });
+
+    writeFileSync(join(HOOKS_DIR, 'post-merge'), POST_MERGE);
+    chmodSync(join(HOOKS_DIR, 'post-merge'), '755');
+
+    writeFileSync(join(HOOKS_DIR, 'post-checkout'), POST_CHECKOUT);
+    chmodSync(join(HOOKS_DIR, 'post-checkout'), '755');
+
+    // Detect and preserve existing core.hooksPath
+    let previousPath = null;
+    try {
+      previousPath = execSync('git config --global core.hooksPath', {
+        encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+    } catch { /* not set */ }
+
+    if (previousPath && previousPath !== HOOKS_DIR) {
+      writeFileSync(PREV_PATH_FILE, previousPath);
+      fmt.logStep(`Saved previous core.hooksPath (${previousPath}) for chaining`);
+    }
+
+    execSync(`git config --global core.hooksPath "${HOOKS_DIR}"`, { stdio: 'pipe' });
+    fmt.logStep('Global git hooks installed (auto-sync on pull/clone)');
+    return true;
+  } catch (e) {
+    fmt.logWarn(`Could not install global hooks: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * Remove global hooks and restore previous core.hooksPath if one existed.
+ */
+export function removeGlobalHooks() {
+  // Restore previous core.hooksPath or unset
+  let restored = false;
+  if (existsSync(PREV_PATH_FILE)) {
+    try {
+      const prev = readFileSync(PREV_PATH_FILE, 'utf8').trim();
+      if (prev) {
+        execSync(`git config --global core.hooksPath "${prev}"`, { stdio: 'pipe' });
+        restored = true;
+      }
+    } catch { /* best effort */ }
+  }
+
+  if (!restored) {
+    try {
+      const current = execSync('git config --global core.hooksPath', {
+        encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      if (current === HOOKS_DIR) {
+        execSync('git config --global --unset core.hooksPath', { stdio: 'pipe' });
+      }
+    } catch { /* not set or already unset */ }
+  }
+
+  if (existsSync(HOOKS_DIR)) {
+    rmSync(HOOKS_DIR, { recursive: true, force: true });
+  }
+
+  // Clean up parent ~/.aw/ if empty
+  const awDir = join(HOME, '.aw');
+  try {
+    if (existsSync(awDir) && readdirSync(awDir).length === 0) {
+      rmSync(awDir, { force: true });
+    }
+  } catch { /* best effort */ }
+
+  fmt.logStep('Global git hooks removed');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.30-beta.3",
+  "version": "0.1.30-beta.6",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {
@@ -23,7 +23,8 @@
     "plan.mjs",
     "registry.mjs",
     "apply.mjs",
-    "update.mjs"
+    "update.mjs",
+    "hooks.mjs"
   ],
   "engines": {
     "node": ">=18.0.0"

package/update.mjs

@@ -4,11 +4,16 @@
 // notifyUpdate(r)   → prints banner if r says update available
 // autoUpdate(r)     → synchronous install with atomic lock, verification, logging
 // promptUpdate(r)   → asks user interactively (normal init)
+//
+// Package manager detection uses import.meta.url (zero subprocesses):
+//   .volta/  → volta install     pnpm/  → pnpm add -g
+//   else     → npm i -g
 
-import { readFileSync, mkdirSync, writeFileSync, statSync, rmSync, appendFileSync, existsSync } from 'node:fs';
+import { readFileSync, mkdirSync, writeFileSync, statSync, rmSync, appendFileSync } from 'node:fs';
 import { exec as execCb, execSync } from 'node:child_process';
 import { promisify } from 'node:util';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
 import { chalk } from './fmt.mjs';
@@ -21,9 +26,40 @@ const LOG_PATH = join(homedir(), '.aw_registry', '.aw-upgrade.log');
 const LOCK_MAX_AGE_MS = 5 * 60 * 1000;
 const LOG_MAX_ENTRIES = 50;
 
+// ── Package manager detection ──────────────────────────────────────────
+// We ARE the installed binary. Our own file path tells us who installed us
+// — no subprocess needed.
+//
+// import.meta.url examples:
+//   Volta: file:///Users/x/.volta/tools/image/packages/@ghl-ai/aw/...
+//   pnpm:  file:///Users/x/.local/share/pnpm/global/.../node_modules/@ghl-ai/aw/...
+//   npm:   file:///opt/homebrew/lib/node_modules/@ghl-ai/aw/...
+//   npm:   file:///usr/local/lib/node_modules/@ghl-ai/aw/...
+//   link:  file:///Users/x/code/ghl-agentic-workspace/libs/aw/...  (npm link / dev)
+
+const SELF_PATH = fileURLToPath(import.meta.url);
+
+function detectPM() {
+  if (SELF_PATH.includes('/.volta/')) return 'volta';
+  if (SELF_PATH.includes('/pnpm/')) return 'pnpm';
+  return 'npm';
+}
+
+const PM = detectPM();
+
+function getInstallCmd(version = 'latest') {
+  const spec = `${PKG_NAME}@${version}`;
+  if (PM === 'volta') return `volta install ${spec}`;
+  if (PM === 'pnpm') return `pnpm add -g ${spec}`;
+  return `npm i -g ${spec}`;
+}
+
+// ── Version helpers ────────────────────────────────────────────────────
+
 function getLocalVersion() {
   try {
-    return JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version;
+    const pkgPath = join(dirname(SELF_PATH), 'package.json');
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version;
   } catch {
     return '0.0.0';
   }
@@ -51,6 +87,32 @@ function compareVersions(a, b) {
   return 0;
 }
 
+// ── Installed version verification ─────────────────────────────────────
+// After install, re-resolve where the package actually landed and read
+// its package.json. Falls back to getLocalVersion() (our own bundle).
+
+function getInstalledVersion() {
+  try {
+    if (PM === 'volta') {
+      // Volta resolves via its own image; ask it directly
+      const resolved = execSync('volta which aw', {
+        encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
+      }).trim();
+      const pkgRoot = join(resolved, '..', '..');
+      return JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf8')).version;
+    }
+
+    // npm / pnpm: read from the global prefix
+    const prefix = execSync('npm prefix -g', {
+      encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
+    }).trim();
+    const pkgPath = join(prefix, 'lib', 'node_modules', PKG_NAME, 'package.json');
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version;
+  } catch {
+    return getLocalVersion();
+  }
+}
+
 // ── Atomic lock via mkdir ──────────────────────────────────────────────
 // mkdir is atomic on all POSIX filesystems. Stale detection uses
 // directory mtime (OS-maintained) rather than parsing PIDs.
@@ -92,18 +154,6 @@ function appendLog(entry) {
   } catch { /* logging is best-effort */ }
 }
 
-// ── Installed version verification ─────────────────────────────────────
-
-function getInstalledVersion() {
-  try {
-    const prefix = execSync('npm prefix -g', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000 }).trim();
-    const pkgPath = join(prefix, 'lib', 'node_modules', PKG_NAME, 'package.json');
-    return JSON.parse(readFileSync(pkgPath, 'utf8')).version;
-  } catch {
-    return getLocalVersion();
-  }
-}
-
 /**
  * Fetch the latest version from npm (non-blocking, 15s timeout).
  * Call at the start of any command, await at the end.
@@ -125,10 +175,11 @@ export async function checkForUpdate() {
  */
 export function notifyUpdate(result) {
   if (!result?.hasUpdate) return;
+  const cmd = getInstallCmd(result.latest);
   const msg = [
     '',
     `  ${chalk.bgHex('#FF6B35').bold(' UPDATE ')} New version available: ${chalk.dim(result.current)} → ${chalk.green(result.latest)}`,
-    `  ${chalk.dim('Run')} ${chalk.bold(`npm i -g ${PKG_NAME}`)} ${chalk.dim('to update')}`,
+    `  ${chalk.dim('Run')} ${chalk.bold(cmd)} ${chalk.dim('to update')}`,
     '',
   ].join('\n');
   console.log(msg);
@@ -144,15 +195,16 @@ export function autoUpdate(result) {
   if (isPrerelease(result.current)) return { status: 'skipped', reason: 'prerelease' };
   if (!acquireLock()) return { status: 'skipped', reason: 'locked' };
 
+  const cmd = getInstallCmd('latest');
   try {
-    execSync(`npm i -g ${PKG_NAME}@latest`, { stdio: 'pipe', timeout: 60_000 });
+    execSync(cmd, { stdio: 'pipe', timeout: 60_000 });
     const installed = getInstalledVersion();
     const ok = compareVersions(installed, result.current) > 0;
-    const entry = { ts: new Date().toISOString(), from: result.current, to: installed, ok };
+    const entry = { ts: new Date().toISOString(), pm: PM, cmd, from: result.current, to: installed, ok };
     appendLog(entry);
     return { status: ok ? 'upgraded' : 'failed', ...entry };
   } catch (e) {
-    const entry = { ts: new Date().toISOString(), from: result.current, error: e.message, ok: false };
+    const entry = { ts: new Date().toISOString(), pm: PM, cmd, from: result.current, error: e.message, ok: false };
     appendLog(entry);
     return { status: 'failed', error: e.message };
   } finally {
@@ -168,6 +220,7 @@ export async function promptUpdate(result) {
   if (!result?.hasUpdate) return false;
   if (isPrerelease(result.current)) return false;
 
+  const cmd = getInstallCmd(result.latest);
   fmt.logWarn(`Update available: ${chalk.dim(result.current)} → ${chalk.green(result.latest)}`);
 
   const { default: clack } = await import('@clack/prompts');
@@ -184,14 +237,14 @@ export async function promptUpdate(result) {
   const s = fmt.spinner();
   s.start(`Updating to ${result.latest}...`);
   try {
-    execSync(`npm i -g ${PKG_NAME}@latest`, { stdio: 'pipe', timeout: 60_000 });
+    execSync(cmd, { stdio: 'pipe', timeout: 60_000 });
     const installed = getInstalledVersion();
     const ok = compareVersions(installed, result.current) > 0;
     s.stop(ok ? `Updated to ${chalk.green(installed)}` : chalk.red('Update may have failed — verify with: aw --version'));
     return ok;
   } catch {
     s.stop(chalk.red('Update failed'));
-    fmt.logWarn(`Manual update: ${chalk.bold(`npm i -g ${PKG_NAME}@latest`)}`);
+    fmt.logWarn(`Manual update: ${chalk.bold(cmd)}`);
     return false;
   }
 }