@gramatr/client 0.6.21 → 0.6.22

package/bin/install.ts

@@ -261,14 +261,24 @@ function installClientFiles(): void {
     mkdirSync(join(CLIENT_DIR, sub), { recursive: true });
   }
 
-  // Hooks (7 core + utils)
+  // Clean stale hooks before copying — prevents old tool names persisting across upgrades (#633)
+  const hooksDestDir = join(CLIENT_DIR, 'hooks');
+  if (existsSync(hooksDestDir)) {
+    for (const f of readdirSync(hooksDestDir)) {
+      if (f.endsWith('.hook.ts') || f.endsWith('-utils.ts')) {
+        rmSync(join(hooksDestDir, f), { force: true });
+      }
+    }
+  }
+
+  // Hooks (core + utils)
   let hookCount = 0;
   const hooksSrc = join(SCRIPT_DIR, 'hooks');
   if (existsSync(hooksSrc)) {
     for (const f of readdirSync(hooksSrc)) {
       const src = join(hooksSrc, f);
       if (statSync(src).isFile() && (f.endsWith('.hook.ts') || f.endsWith('-utils.ts'))) {
-        cpSync(src, join(CLIENT_DIR, 'hooks', f));
+        cpSync(src, join(CLIENT_DIR, 'hooks', f), { force: true });
         chmodSync(join(CLIENT_DIR, 'hooks', f), 0o755);
         hookCount++;
       }
@@ -278,7 +288,7 @@ function installClientFiles(): void {
     const libHookSrc = join(hooksSrc, 'lib');
     if (existsSync(libHookSrc)) {
       const libs = readdirSync(libHookSrc).filter(f => f.endsWith('.ts') && !f.endsWith('.test.ts'));
-      for (const f of libs) cpSync(join(libHookSrc, f), join(CLIENT_DIR, 'hooks/lib', f));
+      for (const f of libs) cpSync(join(libHookSrc, f), join(CLIENT_DIR, 'hooks/lib', f), { force: true });
       log(`OK Installed ${hookCount} hooks + ${libs.length} lib modules`);
     }
 
@@ -717,6 +727,7 @@ async function main(): Promise<void> {
   log('');
   log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
   log(`  gramatr v${VERSION} — Intelligence Layer`);
+  log(`  Source: ${SCRIPT_DIR}`);
   log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
   log('');
 

package/core/version-check.ts

@@ -15,8 +15,9 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { homedir } from 'os';
+import { spawn } from 'child_process';
 
-const REGISTRY_URL = 'https://registry.npmjs.org/gramatr/latest';
+const REGISTRY_URL = 'https://registry.npmjs.org/@gramatr%2fclient/latest';
 const FETCH_TIMEOUT_MS = 3000;
 const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
 
@@ -184,7 +185,7 @@ export function formatUpgradeNotification(installed: string, latest: string): st
     '',
     '  To upgrade:',
     '    1. Type /exit to leave Claude Code',
-    '    2. Run: npx gramatr@latest install claude-code',
+    '    2. Run: npx @gramatr/client@latest install claude-code',
     '    3. Restart: claude --resume',
     '',
     "  Why restart? gramatr's hooks are loaded by Claude Code at",
@@ -217,3 +218,90 @@ export async function runVersionCheckAndNotify(
   }
   return result;
 }
+
+// ── Auto-upgrade ──────────────────────────────────────────────────────────
+
+const UPGRADE_LOCK_TTL_MS = 10 * 60 * 1000; // 10 minutes — prevent concurrent upgrades
+
+function getUpgradeLockPath(home: string = homedir()): string {
+  return join(home, '.gramatr', '.cache', 'upgrade.lock');
+}
+
+function isUpgradeLocked(lockPath: string = getUpgradeLockPath()): boolean {
+  try {
+    if (!existsSync(lockPath)) return false;
+    const raw = readFileSync(lockPath, 'utf8');
+    const lock = JSON.parse(raw);
+    if (typeof lock.startedAt !== 'number') return false;
+    return Date.now() - lock.startedAt < UPGRADE_LOCK_TTL_MS;
+  } catch {
+    return false;
+  }
+}
+
+function writeUpgradeLock(version: string, lockPath: string = getUpgradeLockPath()): void {
+  try {
+    mkdirSync(dirname(lockPath), { recursive: true });
+    writeFileSync(lockPath, JSON.stringify({ version, startedAt: Date.now() }) + '\n');
+  } catch {
+    // Best-effort.
+  }
+}
+
+export interface AutoUpgradeResult {
+  triggered: boolean;
+  version: string;
+  reason?: string;
+}
+
+/**
+ * Auto-upgrade gramatr when a newer version is available.
+ *
+ * Spawns `npx @gramatr/client@{version} install claude-code --yes` as a
+ * detached background process. The install is idempotent: copies files to
+ * ~/.gramatr/, merges hooks into ~/.claude/settings.json, re-registers MCP.
+ * Existing auth token and URL are preserved (merge, not overwrite).
+ *
+ * The upgrade runs in the background so it doesn't block session start.
+ * New hook code won't take effect until the user restarts Claude Code.
+ *
+ * Safety:
+ *   - Lock file prevents concurrent upgrades (10min TTL)
+ *   - --yes flag ensures non-interactive (no stdin prompts)
+ *   - Detached + unref'd so the parent process can exit
+ *   - Never throws — returns result indicating what happened
+ */
+export function autoUpgrade(
+  latestVersion: string,
+  options: { stream?: NodeJS.WritableStream; lockPath?: string } = {},
+): AutoUpgradeResult {
+  const stream = options.stream ?? process.stderr;
+  const lockPath = options.lockPath ?? getUpgradeLockPath();
+
+  if (isUpgradeLocked(lockPath)) {
+    return { triggered: false, version: latestVersion, reason: 'upgrade already in progress' };
+  }
+
+  writeUpgradeLock(latestVersion, lockPath);
+
+  try {
+    const npxBin = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    const child = spawn(
+      npxBin,
+      ['@gramatr/client@' + latestVersion, 'install', 'claude-code', '--yes'],
+      {
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env, GRAMATR_AUTO_UPGRADE: '1' },
+      },
+    );
+    child.unref();
+
+    stream.write(`  gramatr auto-upgrade started: v${latestVersion}\n`);
+    stream.write('  Files will be updated in ~/.gramatr/ — restart Claude Code for new hooks.\n');
+
+    return { triggered: true, version: latestVersion };
+  } catch (err: any) {
+    return { triggered: false, version: latestVersion, reason: err?.message || 'spawn failed' };
+  }
+}

package/hooks/session-start.hook.ts

@@ -33,7 +33,7 @@ import {
   writeCurrentProjectContextFile,
   persistSessionRegistration,
 } from '../core/session.ts';
-import { runVersionCheckAndNotify } from '../core/version-check.ts';
+import { runVersionCheckAndNotify, autoUpgrade } from '../core/version-check.ts';
 import { VERSION } from '../core/version.ts';
 
 // ── stdout (Claude context injection) ──
@@ -480,16 +480,24 @@ async function main(): Promise<void> {
       }
     }
 
-    // Opportunistic npm version check — prints a notification to stderr if a
-    // newer gramatr is published. Never blocks or crashes the session start.
-    // Also injects context to stdout so Claude can proactively inform the user.
+    // Opportunistic version check + auto-upgrade.
+    // 1. Check npm registry for newer @gramatr/client
+    // 2. If outdated, auto-install in background (detached, non-interactive)
+    // 3. Inject context so Claude tells the user to restart for new hooks
     try {
       const versionResult = await runVersionCheckAndNotify(VERSION);
       if (versionResult?.isOutdated) {
-        emitStdout(`gramatr update available: v${versionResult.installedVersion} → v${versionResult.latestVersion}. ` +
-          `Inform the user that a gramatr update is available and recommend they exit Claude Code (/exit) ` +
-          `then run \`npx gramatr@latest install claude-code\` followed by \`claude --resume\` to get the latest features. ` +
-          `Hooks are loaded at session start so a restart is required for new hook code to take effect.`);
+        const upgrade = autoUpgrade(versionResult.latestVersion);
+        if (upgrade.triggered) {
+          log(`  Auto-upgrading gramatr: v${versionResult.installedVersion} → v${versionResult.latestVersion}`);
+          emitStdout(`gramatr auto-upgrade in progress: v${versionResult.installedVersion} → v${versionResult.latestVersion}. ` +
+            `Files are being updated in ~/.gramatr/. Tell the user: "gramatr has auto-upgraded to v${versionResult.latestVersion}. ` +
+            `Exit Claude Code (/exit) and restart with \`claude --resume\` to activate the new hooks and features."`);
+        } else {
+          emitStdout(`gramatr update available: v${versionResult.installedVersion} → v${versionResult.latestVersion}. ` +
+            `Auto-upgrade skipped (${upgrade.reason}). Recommend the user exit Claude Code (/exit) ` +
+            `then run \`npx @gramatr/client@latest install claude-code\` followed by \`claude --resume\`.`);
+        }
       }
     } catch {
       // Silent — version check is strictly optional.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gramatr/client",
-  "version": "0.6.21",
+  "version": "0.6.22",
   "publishConfig": {
     "access": "public"
   },