@gurulu/cli 0.4.7 → 1.0.0

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

@@ -1,80 +0,0 @@
-// scripts/patches/auto-instrument/index.cjs — Phase 18.7 B auto-instrument
-// dispatcher.
-//
-// Maps a resolved framework name to the matching auto-instrument module and
-// exposes a single `dispatch(framework, ctx, events)` entry point used by
-// `scripts/gurulu-agentic-install.mjs` and `packages/cli/src/commands/
-// install.ts`. Modules themselves own singleton-helper planning and regex
-// instrumentation; this index is just the registry.
-
-const nextAppRouter = require('./nextjs-app-router.cjs');
-const nextPages = require('./nextjs-pages.cjs');
-const express = require('./express.cjs');
-const viteReact = require('./vite-react.cjs');
-const nestjs = require('./nestjs.cjs');
-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');
-
-const MODULES = [
-  nextAppRouter,
-  nextPages,
-  express,
-  viteReact,
-  nestjs,
-  remix,
-  sveltekit,
-  astro,
-  fastify,
-  hono,
-  vue,
-];
-
-const MODULE_BY_FRAMEWORK = {};
-for (const mod of MODULES) {
-  for (const fw of mod.supportedFrameworks) {
-    MODULE_BY_FRAMEWORK[fw] = mod;
-  }
-}
-// Aliases.
-MODULE_BY_FRAMEWORK['nextjs'] = nextAppRouter;
-MODULE_BY_FRAMEWORK['nextjs-app'] = nextAppRouter;
-
-function resolveModule(framework) {
-  if (!framework) return null;
-  return MODULE_BY_FRAMEWORK[framework] || null;
-}
-
-/**
- * Dispatch: given a framework, context, and a list of ProposedEvents, invoke
- * the matching module's `instrumentEvents()` and return its plan result. If
- * no module matches, returns a no-op plan with a note describing why.
- */
-function dispatch(framework, ctx, events) {
-  const mod = resolveModule(framework);
-  if (!mod) {
-    return {
-      changes: [],
-      notes: [`auto-instrument:no-module-for-${framework || 'auto'}`],
-      filesModified: 0,
-      eventsInstrumented: 0,
-      eventsSkipped: events ? events.length : 0,
-      collision: false,
-      module: null,
-    };
-  }
-  const result = mod.instrumentEvents(ctx, events);
-  return { ...result, module: mod.name };
-}
-
-module.exports = {
-  MODULES,
-  MODULE_BY_FRAMEWORK,
-  resolveModule,
-  dispatch,
-  singleton,
-};

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

@@ -1,286 +0,0 @@
-// scripts/patches/auto-instrument/nestjs.cjs — Phase 20 W1 A3.
-//
-// AST-based auto-instrumentation for NestJS controllers. We parse every
-// controller file under `src/**` and look for class methods decorated with
-// `@Get`, `@Post`, etc. whose enclosing class carries a `@Controller('...')`
-// decorator. Matching methods get a `gurulu.track(...)` call inserted
-// before the last top-level return.
-//
-// Route matching: given a ProposedEvent with `source.route = 'POST /users'`
-// we match against `<controllerBase>/<methodPath>` where `controllerBase`
-// comes from the `@Controller('path')` argument and `methodPath` comes from
-// the method decorator argument (optional, defaults to '/').
-
-const fs = require('fs');
-const path = require('path');
-
-const ast = require('./ast-helper.cjs');
-const singleton = require('./singleton-helper.cjs');
-
-const NAME = 'auto-instrument-nestjs';
-const SUPPORTED = ['nestjs'];
-
-const HTTP_DECORATORS = new Set([
-  'Get', 'Post', 'Put', 'Patch', 'Delete', 'Options', 'Head', 'All',
-]);
-
-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 walkSourceFiles(repoRoot) {
-  const results = [];
-  const stack = ['src'];
-  while (stack.length > 0) {
-    const rel = stack.pop();
-    const abs = path.join(repoRoot, rel);
-    if (!fs.existsSync(abs)) continue;
-    let entries = [];
-    try {
-      entries = fs.readdirSync(abs, { withFileTypes: true });
-    } catch (_) {
-      continue;
-    }
-    for (const entry of entries) {
-      if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
-      const childRel = path.posix.join(rel, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(childRel);
-      } else if (/\.(ts|js)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
-        results.push(childRel);
-      }
-    }
-  }
-  return results;
-}
-
-/**
- * Normalize a base + method route into the "/base/method" form (no trailing
- * slash, no duplicate slashes). Leading slash enforced.
- */
-function joinRoute(base, method) {
-  const a = String(base || '').replace(/^\//, '').replace(/\/+$/, '');
-  const b = String(method || '').replace(/^\//, '').replace(/\/+$/, '');
-  let joined = [a, b].filter(Boolean).join('/');
-  joined = '/' + joined;
-  return joined.replace(/\/+/g, '/').replace(/\/$/, '') || '/';
-}
-
-/**
- * Scan an AST for controller class methods and collect
- * `{ classNode, methodNode, method, urlPath }` entries.
- */
-function collectControllerMethods(tree) {
-  const t = ast.t;
-  const results = [];
-  ast.traverse(tree, {
-    ClassDeclaration(p) {
-      const decorators = p.node.decorators || [];
-      let controllerBase = '';
-      let isController = false;
-      for (const d of decorators) {
-        if (!t.isDecorator(d)) continue;
-        const expr = d.expression;
-        if (t.isCallExpression(expr) && t.isIdentifier(expr.callee) && expr.callee.name === 'Controller') {
-          isController = true;
-          const arg0 = expr.arguments[0];
-          if (t.isStringLiteral(arg0)) controllerBase = arg0.value;
-        }
-      }
-      if (!isController) return;
-      for (const member of p.node.body.body) {
-        if (!t.isClassMethod(member) && !t.isClassProperty(member)) continue;
-        const mDecorators = member.decorators || [];
-        for (const dec of mDecorators) {
-          if (!t.isDecorator(dec)) continue;
-          const expr = dec.expression;
-          if (!t.isCallExpression(expr)) continue;
-          if (!t.isIdentifier(expr.callee)) continue;
-          if (!HTTP_DECORATORS.has(expr.callee.name)) continue;
-          const httpMethod = expr.callee.name.toUpperCase();
-          const arg0 = expr.arguments[0];
-          const methodPath = t.isStringLiteral(arg0) ? arg0.value : '';
-          const fullPath = joinRoute(controllerBase, methodPath);
-          // Only support class methods with block bodies.
-          if (!t.isClassMethod(member) || !t.isBlockStatement(member.body)) continue;
-          results.push({
-            methodNode: member,
-            body: member.body,
-            httpMethod,
-            urlPath: fullPath,
-          });
-        }
-      }
-    },
-  });
-  return results;
-}
-
-function astInstrumentFile(source, targets, opts = {}) {
-  // targets: [{ httpMethod, urlPath, events: [] }]
-  const tree = ast.parseSource(source);
-  const methods = collectControllerMethods(tree);
-  if (methods.length === 0) return { ok: false, reason: 'no-controllers' };
-  let changed = false;
-  const instrumentedNames = [];
-  const skipped = [];
-  for (const target of targets) {
-    const match = methods.find(
-      (m) => m.httpMethod === target.httpMethod && m.urlPath === target.urlPath,
-    );
-    if (!match) {
-      for (const e of target.events) {
-        skipped.push({ event: e.name, reason: 'controller-method-not-found' });
-      }
-      continue;
-    }
-    if (ast.hasInstrumentedMarker(match.methodNode)) {
-      for (const e of target.events) skipped.push({ event: e.name, reason: 'already-instrumented' });
-      continue;
-    }
-    const stmts = target.events.map((e) => ast.buildTrackStatement(e.name, e.autoProperties));
-    ast.injectTrackBeforeLastReturn(match.methodNode, match.body, stmts);
-    changed = true;
-    for (const e of target.events) instrumentedNames.push(e.name);
-  }
-  if (!changed) {
-    return { ok: true, after: source, instrumented: [], skipped, changed: false };
-  }
-  // Sprint D / D4 — alias-aware import.
-  const specifier = ast.resolveGuruluImportSpecifier(opts.repoRoot, opts.relPath);
-  ast.ensureGuruluImport(tree, specifier);
-  const after = ast.generateSource(tree, source);
-  return { ok: true, after, instrumented: instrumentedNames, skipped, changed: true };
-}
-
-function resolveControllerFileForEvent(ctx, httpMethod, urlPath) {
-  const files = walkSourceFiles(ctx.repoRoot);
-  for (const rel of files) {
-    if (!/\.controller\.(ts|js)$/.test(rel) && !rel.includes('controller')) continue;
-    const abs = path.join(ctx.repoRoot, rel);
-    let src;
-    try {
-      src = fs.readFileSync(abs, 'utf8');
-    } catch (_) {
-      continue;
-    }
-    if (!src.includes('@Controller')) continue;
-    try {
-      const tree = ast.parseSource(src);
-      const methods = collectControllerMethods(tree);
-      if (methods.some((m) => m.httpMethod === httpMethod && m.urlPath === urlPath)) {
-        return rel;
-      }
-    } catch (_) {
-      // Skip malformed files.
-    }
-  }
-  return null;
-}
-
-function instrumentEvents(ctx, events) {
-  const helper = singleton.ensureSingletonHelper(ctx, 'nestjs');
-  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,
-    };
-  }
-
-  // Group events by (file, httpMethod, urlPath).
-  const fileGroups = 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 rel = resolveControllerFileForEvent(ctx, parsed.method, parsed.urlPath);
-    if (!rel) {
-      notes.push(`skip:${e.name}:controller-not-found`);
-      eventsSkipped++;
-      continue;
-    }
-    if (!fileGroups.has(rel)) fileGroups.set(rel, new Map());
-    const perFile = fileGroups.get(rel);
-    const key = `${parsed.method}::${parsed.urlPath}`;
-    if (!perFile.has(key)) perFile.set(key, { httpMethod: parsed.method, urlPath: parsed.urlPath, events: [] });
-    perFile.get(key).events.push(e);
-  }
-
-  for (const [rel, perFile] of fileGroups.entries()) {
-    const abs = path.join(ctx.repoRoot, rel);
-    const before = fs.readFileSync(abs, 'utf8');
-    const targets = Array.from(perFile.values());
-    // Sprint D / D4 — pass repoRoot + relPath to the import resolver.
-    const fileOpts = { repoRoot: (ctx && ctx.repoRoot) || null, relPath: rel };
-    let res;
-    try {
-      res = astInstrumentFile(before, targets, fileOpts);
-    } catch (err) {
-      const msg = (err && err.message) || String(err);
-      // eslint-disable-next-line no-console
-      console.warn(`[auto-instrument] patch.fallback ${rel}: ${msg}`);
-      notes.push(`patch.fallback:${rel}:${msg}`);
-      continue;
-    }
-    if (!res.ok) {
-      for (const t of targets) {
-        for (const e of t.events) {
-          notes.push(`skip:${e.name}:${res.reason}`);
-          eventsSkipped++;
-        }
-      }
-      continue;
-    }
-    for (const s of res.skipped || []) {
-      notes.push(`skip:${s.event}:${s.reason}`);
-      eventsSkipped++;
-    }
-    if (res.changed) {
-      changes.push({
-        relPath: rel,
-        before,
-        after: res.after,
-        reason: `auto-instrument-nestjs`,
-        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, 'nestjs');
-}
-
-module.exports = {
-  name: NAME,
-  supportedFrameworks: SUPPORTED,
-  ensureSingletonHelper,
-  instrumentEvents,
-  _internals: {
-    parseEventRoute,
-    walkSourceFiles,
-    collectControllerMethods,
-    astInstrumentFile,
-    resolveControllerFileForEvent,
-    joinRoute,
-  },
-};