@gurulu/cli 0.3.4 → 0.4.1

package/scripts/patches/auto-instrument/hono.cjs

@@ -0,0 +1,381 @@
+// scripts/patches/auto-instrument/hono.cjs — Phase 20 W1 A4.
+//
+// Hono supports several idiomatic route registration shapes:
+//
+//   app.get('/users', (c) => { ... });
+//   app.post('/orders', async (c) => { ... });
+//   const api = new Hono(); api.get('/users', handler);
+//   app.get('/health', (c) => c.json({ ok: true })).post('/data', async (c) => { ... });
+//
+// We search the usual server entry files plus `routes/**` for a matching
+// registration, parse the AST, and inject `gurulu.track(...)` into the
+// handler body before the last return.
+
+const fs = require('fs');
+const path = require('path');
+
+const ast = require('./ast-helper.cjs');
+const singleton = require('./singleton-helper.cjs');
+
+const NAME = 'auto-instrument-hono';
+const SUPPORTED = ['hono'];
+const MARKER = '// @gurulu-instrumented';
+const IMPORT_LINE_ESM = "import { gurulu } from '@/lib/gurulu';";
+
+const CANDIDATE_ENTRIES = [
+  'app.js',
+  'server.js',
+  'index.js',
+  'src/app.js',
+  'src/server.js',
+  'src/index.js',
+  'src/app.ts',
+  'src/server.ts',
+  'src/index.ts',
+  'src/main.ts',
+  'src/main.js',
+];
+
+function parseEventRoute(routeStr) {
+  if (!routeStr || typeof routeStr !== 'string') return null;
+  const m = routeStr.trim().match(/^([A-Z]+)\s+(\/.*)$/);
+  if (!m) return null;
+  return { method: m[1].toUpperCase(), urlPath: m[2].replace(/\/+$/, '') || '/' };
+}
+
+function walkRoutes(repoRoot) {
+  const results = [];
+  const dirs = ['routes', 'src/routes', 'src/api', 'app', 'src/app'];
+  for (const d of dirs) {
+    const abs = path.join(repoRoot, d);
+    if (!fs.existsSync(abs)) continue;
+    for (const entry of fs.readdirSync(abs, { withFileTypes: true })) {
+      if (entry.isFile() && /\.(js|ts|mjs|cjs)$/.test(entry.name)) {
+        results.push(path.posix.join(d, entry.name));
+      }
+    }
+  }
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// AST path
+// ---------------------------------------------------------------------------
+
+/**
+ * Find all `app.<method>('path', ..., handler)` or `api.<method>(...)`
+ * or `router.<method>(...)` call expressions matching the given method +
+ * urlPath. Hono apps are typically named `app`, `api`, `router`, or
+ * `server`. Returns an array of `{ fn, body }` entries.
+ */
+function findHonoHandlers(tree, method, urlPath) {
+  const t = ast.t;
+  const results = [];
+  const lowerMethod = method.toLowerCase();
+  const HONO_IDENTIFIERS = new Set(['app', 'api', 'router', 'server']);
+
+  ast.traverse(tree, {
+    CallExpression(p) {
+      const callee = p.node.callee;
+      if (!t.isMemberExpression(callee)) return;
+      if (!t.isIdentifier(callee.property) || callee.property.name !== lowerMethod) return;
+
+      // The object can be a simple identifier (app.get) or a chained call
+      // expression (app.get('/a', h).post('/b', h) — the object of `.post`
+      // is the preceding CallExpression). We accept identifiers from the
+      // known set, and also any CallExpression (chained).
+      const obj = callee.object;
+      const isKnownIdent = t.isIdentifier(obj) && HONO_IDENTIFIERS.has(obj.name);
+      const isChained = t.isCallExpression(obj);
+      if (!isKnownIdent && !isChained) return;
+
+      const args = p.node.arguments;
+      if (args.length < 2) return;
+      if (!t.isStringLiteral(args[0]) || args[0].value !== urlPath) return;
+
+      // The final argument should be the handler function.
+      const handler = args[args.length - 1];
+      if (
+        (t.isArrowFunctionExpression(handler) || t.isFunctionExpression(handler)) &&
+        t.isBlockStatement(handler.body)
+      ) {
+        results.push({ fn: handler, body: handler.body });
+      }
+    },
+  });
+  return results;
+}
+
+function astInstrumentFile(source, method, urlPath, events) {
+  const tree = ast.parseSource(source);
+  const handlers = findHonoHandlers(tree, method, urlPath);
+  if (handlers.length === 0) {
+    return { ok: false, reason: 'handler-not-found' };
+  }
+  const target = handlers[0];
+  if (ast.hasInstrumentedMarker(target.fn)) {
+    return {
+      ok: true,
+      after: source,
+      instrumented: [],
+      skipped: events.map((e) => ({ event: e.name, reason: 'already-instrumented' })),
+      changed: false,
+    };
+  }
+  const stmts = events.map((e) => ast.buildTrackStatement(e.name, e.autoProperties));
+  ast.injectTrackBeforeLastReturn(target.fn, target.body, stmts);
+  ast.ensureGuruluImport(tree);
+  const after = ast.generateSource(tree, source);
+  return {
+    ok: true,
+    after,
+    instrumented: events.map((e) => e.name),
+    skipped: [],
+    changed: true,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Regex fallback
+// ---------------------------------------------------------------------------
+
+function regexFindHandlerStart(source, method, urlPath) {
+  const lower = method.toLowerCase();
+  const escapedPath = urlPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(
+    `(?:app|api|router|server)\\.${lower}\\s*\\(\\s*['"\`]${escapedPath}['"\`]\\s*,`,
+  );
+  const m = re.exec(source);
+  if (!m) return null;
+  let i = m.index + m[0].length;
+  const tail = source.slice(i);
+  const arrowIdx = tail.search(/=>\s*\{/);
+  const funcIdx = tail.search(/function\s*[^(]*\([^)]*\)\s*\{/);
+  let bodyOpen = -1;
+  if (arrowIdx !== -1 && (funcIdx === -1 || arrowIdx < funcIdx)) {
+    bodyOpen = i + tail.indexOf('{', arrowIdx);
+  } else if (funcIdx !== -1) {
+    bodyOpen = i + tail.indexOf('{', funcIdx);
+  }
+  if (bodyOpen === -1) return null;
+  let depth = 0;
+  for (let j = bodyOpen; j < source.length; j++) {
+    const c = source[j];
+    if (c === '{') depth++;
+    else if (c === '}') {
+      depth--;
+      if (depth === 0) return { start: bodyOpen, end: j };
+    }
+  }
+  return null;
+}
+
+function regexFindLastResponseCall(source, start, end) {
+  const snippet = source.slice(start, end);
+  // Hono response patterns: c.json(), c.text(), c.html(), c.body(),
+  // c.redirect(), c.notFound()
+  const patterns = [
+    /c\.json\s*\(/g,
+    /c\.text\s*\(/g,
+    /c\.html\s*\(/g,
+    /c\.body\s*\(/g,
+    /c\.redirect\s*\(/g,
+    /c\.notFound\s*\(/g,
+    /return\s+c\./g,
+  ];
+  let lastIdx = -1;
+  for (const re of patterns) {
+    let m;
+    while ((m = re.exec(snippet)) !== null) {
+      if (m.index > lastIdx) lastIdx = m.index;
+    }
+  }
+  if (lastIdx === -1) return null;
+  const absoluteIdx = start + lastIdx;
+  let lineStart = absoluteIdx;
+  while (lineStart > 0 && source[lineStart - 1] !== '\n') lineStart--;
+  const indentMatch = source.slice(lineStart, absoluteIdx).match(/^(\s*)/);
+  const indent = (indentMatch && indentMatch[1]) || '  ';
+  return { insertAt: lineStart, indent };
+}
+
+function regexEnsureImport(source) {
+  if (source.includes(IMPORT_LINE_ESM)) return source;
+  const importRegex = /^(?:import[\s\S]*?;\s*\n)+/m;
+  const m = source.match(importRegex);
+  if (m) {
+    const end = m.index + m[0].length;
+    return source.slice(0, end) + IMPORT_LINE_ESM + '\n' + source.slice(end);
+  }
+  return IMPORT_LINE_ESM + '\n' + source;
+}
+
+function regexBuildTrackCall(eventName, indent) {
+  const safeName = JSON.stringify(eventName);
+  return `${indent}${MARKER} ${eventName}\n${indent}gurulu.track(${safeName}, {});\n`;
+}
+
+function regexInstrumentFile(before, method, urlPath, events) {
+  const body = regexFindHandlerStart(before, method, urlPath);
+  if (!body) return { ok: false, reason: 'handler-not-found' };
+  const snippet = before.slice(body.start, body.end);
+  const needed = [];
+  const skipped = [];
+  for (const e of events) {
+    if (snippet.includes(`${MARKER} ${e.name}`)) {
+      skipped.push({ event: e.name, reason: 'already-instrumented' });
+    } else {
+      needed.push(e);
+    }
+  }
+  if (needed.length === 0) return { ok: true, after: before, instrumented: [], skipped, changed: false };
+  const ret = regexFindLastResponseCall(before, body.start, body.end);
+  if (!ret) return { ok: false, reason: 'no-response-found' };
+  const block = needed.map((e) => regexBuildTrackCall(e.name, ret.indent)).join('');
+  let after = before.slice(0, ret.insertAt) + block + before.slice(ret.insertAt);
+  after = regexEnsureImport(after);
+  return {
+    ok: true,
+    after,
+    instrumented: needed.map((e) => e.name),
+    skipped,
+    changed: true,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Glue
+// ---------------------------------------------------------------------------
+
+function resolveRouteFile(ctx, method, urlPath) {
+  const seen = new Set();
+  const candidates = [
+    ...CANDIDATE_ENTRIES,
+    ...walkRoutes(ctx.repoRoot),
+  ].filter((rel) => {
+    if (seen.has(rel)) return false;
+    seen.add(rel);
+    return fs.existsSync(path.join(ctx.repoRoot, rel));
+  });
+  for (const rel of candidates) {
+    const src = fs.readFileSync(path.join(ctx.repoRoot, rel), 'utf8');
+    // Cheap pre-filter: must contain `.${method.toLowerCase()}(`.
+    if (!src.includes(`.${method.toLowerCase()}(`)) continue;
+    try {
+      const tree = ast.parseSource(src);
+      const handlers = findHonoHandlers(tree, method, urlPath);
+      if (handlers.length > 0) return { relPath: rel };
+    } catch (_) {
+      // Regex check as last-ditch.
+      if (regexFindHandlerStart(src, method, urlPath)) return { relPath: rel };
+    }
+  }
+  return null;
+}
+
+function instrumentEvents(ctx, events) {
+  const helper = singleton.ensureSingletonHelper(ctx, 'hono');
+  const changes = [...helper.changes];
+  const notes = [...helper.notes];
+  let eventsInstrumented = 0;
+  let eventsSkipped = 0;
+
+  if (helper.collision) {
+    return {
+      changes: [],
+      notes,
+      filesModified: 0,
+      eventsInstrumented: 0,
+      eventsSkipped: events ? events.length : 0,
+      collision: true,
+    };
+  }
+
+  const groups = new Map();
+  for (const e of events || []) {
+    const parsed = parseEventRoute(e && e.source && e.source.route);
+    if (!parsed) {
+      notes.push(`skip:${e && e.name}:no-source-route`);
+      eventsSkipped++;
+      continue;
+    }
+    const resolved = resolveRouteFile(ctx, parsed.method, parsed.urlPath);
+    if (!resolved) {
+      notes.push(`skip:${e.name}:route-not-found`);
+      eventsSkipped++;
+      continue;
+    }
+    const key = `${resolved.relPath}::${parsed.method}::${parsed.urlPath}`;
+    if (!groups.has(key)) {
+      groups.set(key, {
+        relPath: resolved.relPath,
+        method: parsed.method,
+        urlPath: parsed.urlPath,
+        events: [],
+      });
+    }
+    groups.get(key).events.push(e);
+  }
+
+  for (const group of groups.values()) {
+    const abs = path.join(ctx.repoRoot, group.relPath);
+    const before = fs.readFileSync(abs, 'utf8');
+    let res;
+    try {
+      res = astInstrumentFile(before, group.method, group.urlPath, group.events);
+    } catch (err) {
+      const msg = (err && err.message) || String(err);
+      // eslint-disable-next-line no-console
+      console.warn(`[auto-instrument] patch.fallback ${group.relPath}: ${msg}`);
+      notes.push(`patch.fallback:${group.relPath}:${msg}`);
+      res = regexInstrumentFile(before, group.method, group.urlPath, group.events);
+    }
+    if (!res.ok) {
+      for (const e of group.events) {
+        notes.push(`skip:${e.name}:${res.reason || 'instrument-failed'}`);
+        eventsSkipped++;
+      }
+      continue;
+    }
+    for (const s of res.skipped || []) {
+      notes.push(`skip:${s.event}:${s.reason}`);
+      eventsSkipped++;
+    }
+    if (!res.changed) continue;
+    const existing = changes.find((c) => c.relPath === group.relPath && c.type === 'auto-instrument');
+    if (existing) {
+      existing.after = res.after;
+    } else {
+      changes.push({
+        relPath: group.relPath,
+        before,
+        after: res.after,
+        reason: `auto-instrument-${group.method}`,
+        type: 'auto-instrument',
+      });
+    }
+    eventsInstrumented += (res.instrumented || []).length;
+  }
+
+  const filesModified = changes.filter((c) => c.type === 'auto-instrument').length;
+  return { changes, notes, filesModified, eventsInstrumented, eventsSkipped, collision: false };
+}
+
+function ensureSingletonHelper(ctx) {
+  return singleton.ensureSingletonHelper(ctx, 'hono');
+}
+
+module.exports = {
+  name: NAME,
+  supportedFrameworks: SUPPORTED,
+  ensureSingletonHelper,
+  instrumentEvents,
+  _internals: {
+    parseEventRoute,
+    resolveRouteFile,
+    astInstrumentFile,
+    regexInstrumentFile,
+    walkRoutes,
+    findHonoHandlers,
+  },
+};

package/scripts/patches/auto-instrument/index.cjs

@@ -16,6 +16,7 @@ const remix = require('./remix.cjs');
 const sveltekit = require('./sveltekit.cjs');
 const astro = require('./astro.cjs');
 const fastify = require('./fastify.cjs');
+const hono = require('./hono.cjs');
 const vue = require('./vue.cjs');
 const singleton = require('./singleton-helper.cjs');
 
@@ -29,6 +30,7 @@ const MODULES = [
   sveltekit,
   astro,
   fastify,
+  hono,
   vue,
 ];
 

package/scripts/patches/auto-instrument/nextjs-app-router.cjs

@@ -70,7 +70,7 @@ function astInstrumentFile(source, method, events, opts = {}) {
     };
   }
   const trackStmts = events.map((e) =>
-    ast.buildTrackStatement(e.name, e.autoProperties || opts.autoProperties && e.extractedProperties),
+    ast.buildTrackStatement(e.name, e.extractedProperties || e.autoProperties),
   );
   const injected = ast.injectTrackBeforeLastReturn(target.fn, target.body, trackStmts);
   if (!injected) {
@@ -147,11 +147,20 @@ function regexFindLastReturnInBody(source, start, end) {
   return { insertAt: lineStart, indent };
 }
 
-function regexBuildTrackCall(eventName, indent) {
+function regexBuildTrackCall(eventName, indent, extractedProperties) {
   const safeName = JSON.stringify(eventName);
+  let propsStr = '{}';
+  if (Array.isArray(extractedProperties) && extractedProperties.length > 0) {
+    const entries = extractedProperties
+      .filter((p) => p && p.name && p.source)
+      .map((p) => `${p.name}: ${p.source}`);
+    if (entries.length > 0) {
+      propsStr = `{ ${entries.join(', ')} }`;
+    }
+  }
   return (
     `${indent}${MARKER} ${eventName}\n` +
-    `${indent}gurulu.track(${safeName}, {});\n`
+    `${indent}gurulu.track(${safeName}, ${propsStr});\n`
   );
 }
 
@@ -173,7 +182,7 @@ function regexInstrumentFile(before, method, events) {
   if (needed.length === 0) return { ok: true, after: before, instrumented: [], skipped, changed: false };
   const ret = regexFindLastReturnInBody(before, body.start, body.end);
   if (!ret) return { ok: false, reason: 'no-return-found' };
-  const block = needed.map((e) => regexBuildTrackCall(e.name, ret.indent)).join('');
+  const block = needed.map((e) => regexBuildTrackCall(e.name, ret.indent, e.extractedProperties)).join('');
   let after = before.slice(0, ret.insertAt) + block + before.slice(ret.insertAt);
   after = regexEnsureImport(after).source;
   return {

package/scripts/patches/express.patch.cjs

@@ -2,7 +2,7 @@
 //
 // Detects an Express server (`app.js`, `server.js`, `src/index.js` with the
 // idiomatic `const app = express()` signature) and appends:
-//   - A proxy route that serves /gurulu-tracker.js from the Gurulu CDN
+//   - A proxy route that serves /gurulu-tracker from the Gurulu CDN
 //   - A `res.locals.guruluConfig` middleware exposing siteId / tenantId
 
 const fs = require('fs');
@@ -59,7 +59,7 @@ function buildMiddleware(appVar, injection) {
     `  };\n` +
     `  next();\n` +
     `});\n` +
-    `${appVar}.use('/gurulu-tracker.js', (req, res) => {\n` +
+    `${appVar}.use('/gurulu-tracker', (req, res) => {\n` +
     `  res.set('Content-Type', 'application/javascript');\n` +
     `  res.send(\`// Gurulu tracker proxy — site=\${${JSON.stringify(injection.siteId)}} data-gurulu-publishable-key=\${${JSON.stringify(injection.publishableKey || '')}}\\n` +
     `window.gurulu = window.gurulu || { queue: [] };\`);\n` +

package/scripts/patches/fastify.patch.cjs

@@ -68,6 +68,7 @@ function buildScriptTag(injection) {
     `      src="${injection.scriptSrc}"\n` +
     `      data-gurulu-site-id="${injection.siteId}"\n` +
     `      data-gurulu-tenant-id="${injection.tenantId}"${pkAttr}\n` +
+    `      data-features="errors,replay,advanced"\n` +
     `      ${MARKER}\n` +
     `      async\n` +
     `    ></script>\n`

package/scripts/patches/nestjs.patch.cjs

@@ -70,6 +70,7 @@ function buildScriptTag(injection) {
     `      src="${injection.scriptSrc}"\n` +
     `      data-gurulu-site-id="${injection.siteId}"\n` +
     `      data-gurulu-tenant-id="${injection.tenantId}"${pkAttr}\n` +
+    `      data-features="errors,replay,advanced"\n` +
     `      ${MARKER}\n` +
     `      async\n` +
     `    ></script>\n`

package/scripts/patches/nextjs-app-router.patch.cjs

@@ -2,7 +2,7 @@
 //
 // Detects a Next.js App Router layout (`src/app/layout.tsx` or `app/layout.tsx`)
 // and injects a <Script> tag loaded via next/script that points to the Gurulu
-// Web SDK tracker (`/gurulu-tracker.js` by default).
+// Web SDK tracker (`https://gurulu.io/t.js` by default).
 //
 // Regex-based: fast alpha, good enough for most idiomatic RootLayouts.
 
@@ -40,7 +40,7 @@ function buildScriptTag(injection) {
     `          data-gurulu-site-id=${JSON.stringify(injection.siteId)}\n` +
     `          data-gurulu-tenant-id=${JSON.stringify(injection.tenantId)}\n` +
     pkAttr +
-    `          data-features="errors"\n` +
+    `          data-features="errors,replay,advanced"\n` +
     `          ${MARKER}\n` +
     `        />\n`
   );

package/scripts/patches/nextjs-pages.patch.cjs

@@ -54,6 +54,7 @@ function buildHook(injection) {
     `    s.setAttribute('data-gurulu-site-id', ${JSON.stringify(injection.siteId)});\n` +
     `    s.setAttribute('data-gurulu-tenant-id', ${JSON.stringify(injection.tenantId)});\n` +
     pkLine +
+    `    s.setAttribute('data-features', 'errors,replay,advanced');\n` +
     `    document.head.appendChild(s);\n` +
     `  }, []);\n`
   );

package/scripts/patches/remix.patch.cjs

@@ -36,6 +36,7 @@ function buildScriptTag(injection) {
     `          data-gurulu-site-id=${JSON.stringify(injection.siteId)}\n` +
     `          data-gurulu-tenant-id=${JSON.stringify(injection.tenantId)}\n` +
     pkAttr +
+    `          data-features="errors,replay,advanced"\n` +
     `          ${MARKER}\n` +
     `          async\n` +
     `        />\n`

package/scripts/patches/sveltekit.patch.cjs

@@ -33,6 +33,7 @@ function buildScriptTag(injection) {
     `      src="${injection.scriptSrc}"\n` +
     `      data-gurulu-site-id="${injection.siteId}"\n` +
     `      data-gurulu-tenant-id="${injection.tenantId}"${pkAttr}\n` +
+    `      data-features="errors,replay,advanced"\n` +
     `      ${MARKER}\n` +
     `      async\n` +
     `    ></script>\n`

package/scripts/patches/vite-react.patch.cjs

@@ -35,6 +35,7 @@ function buildBootstrap(injection) {
     `  s.setAttribute('data-gurulu-install', '1');\n` +
     `  s.setAttribute('data-gurulu-site-id', ${JSON.stringify(injection.siteId)});\n` +
     pkLine +
+    `  s.setAttribute('data-features', 'errors,replay,advanced');\n` +
     `  document.head.appendChild(s);\n` +
     `}\n`
   );

package/scripts/patches/vue.patch.cjs

@@ -48,6 +48,7 @@ function buildScriptTag(injection) {
     `      src="${injection.scriptSrc}"\n` +
     `      data-gurulu-site-id="${injection.siteId}"\n` +
     `      data-gurulu-tenant-id="${injection.tenantId}"${pkAttr}\n` +
+    `      data-features="errors,replay,advanced"\n` +
     `      ${MARKER}\n` +
     `      async\n` +
     `    ></script>\n`