@gramatr/client 0.6.20 → 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/routing.ts

@@ -47,6 +47,27 @@ export async function routePrompt(options: {
   };
 }
 
+/**
+ * Fetch Packet 2 enrichment (reverse engineering + ISC scaffold).
+ * Called automatically by the prompt enricher hook when packet_2_status is "pending".
+ * Brief timeout — enrichment is usually pre-computed by the time we ask.
+ */
+export async function fetchEnrichment(enrichmentId: string, timeoutMs: number = 2000): Promise<Record<string, unknown> | null> {
+  try {
+    const result = await callMcpToolDetailed<Record<string, unknown>>(
+      'gramatr_get_enrichment',
+      { enrichment_id: enrichmentId, timeout_ms: timeoutMs },
+      timeoutMs + 1000, // HTTP timeout slightly longer than server timeout
+    );
+    if (result.data && result.data.status === 'ready') {
+      return result.data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 export function describeRoutingFailure(error: MctToolCallError): {
   title: string;
   detail: string;

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/gramatr-prompt-enricher.hook.ts

@@ -25,6 +25,7 @@ import { getGitContext } from './lib/gmtr-hook-utils.ts';
 import {
   persistClassificationResult,
   routePrompt,
+  fetchEnrichment,
   shouldSkipPromptRouting,
 } from '../core/routing.ts';
 import type { RouteResponse } from '../core/types.ts';
@@ -155,7 +156,7 @@ function formatFailureWarning(failure: RouterFailure): string {
 
 // ── Format Intelligence Block ──
 
-function formatIntelligence(data: RouteResponse): string {
+function formatIntelligence(data: RouteResponse, enrichment?: Record<string, unknown> | null): string {
   const c = data.classification || {};
   const ts = data.token_savings || {};
   const es = data.execution_summary || {};
@@ -450,6 +451,14 @@ function formatIntelligence(data: RouteResponse): string {
     }
   }
 
+  // Enrichment status — tell agent what happened with Packet 2
+  if (enrichment) {
+    // Enrichment was auto-fetched and merged — ISC scaffold + RE already in the output above
+  } else if (data.packet_2_status === 'pending' && data.enrichment_id) {
+    lines.push('');
+    lines.push(`Packet 2 (reverse engineering + ISC scaffold) is still generating. If needed, call gramatr_get_enrichment with enrichment_id="${data.enrichment_id}".`);
+  }
+
   return lines.join('\n');
 }
 
@@ -580,6 +589,29 @@ async function main() {
     lastFailure = null;
   }
 
+  // Auto-fetch Packet 2 enrichment if pending (reverse engineering + ISC scaffold)
+  // Brief wait — enrichment is usually pre-computed by the time Packet 1 returns.
+  // If it's not ready in 2s, inject what we have and tell the agent how to get it later.
+  let enrichment: Record<string, unknown> | null = null;
+  if (result && (result as any).packet_2_status === 'pending' && (result as any).enrichment_id) {
+    try {
+      enrichment = await fetchEnrichment((result as any).enrichment_id, 2000);
+      if (enrichment) {
+        // Merge enrichment into the classification so the existing formatting logic picks it up
+        const c = (result as any).classification;
+        if (c && enrichment.reverse_engineering) {
+          c.reverse_engineering = enrichment.reverse_engineering;
+        }
+        if (c && enrichment.isc_scaffold) {
+          c.isc_scaffold = enrichment.isc_scaffold;
+        }
+        if (enrichment.constraints_extracted) {
+          c.constraints_extracted = enrichment.constraints_extracted;
+        }
+      }
+    } catch { /* non-blocking — Packet 1 still delivers */ }
+  }
+
   // Emit status to stderr
   emitStatus(result, elapsed);
 
@@ -660,7 +692,7 @@ async function main() {
   }
 
   // Format and inject
-  const context = formatIntelligence(result);
+  const context = formatIntelligence(result, enrichment);
 
   console.log(
     JSON.stringify({

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,10 +480,25 @@ 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.
+    // 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 {
-      await runVersionCheckAndNotify(VERSION);
+      const versionResult = await runVersionCheckAndNotify(VERSION);
+      if (versionResult?.isOutdated) {
+        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.20",
+  "version": "0.6.22",
   "publishConfig": {
     "access": "public"
   },