sdlc-agent-4-enterprise-server 1.0.0

package/src/engine/analyzers/entry-points/EntryPointDetector.ts

@@ -0,0 +1,76 @@
+/**
+ * KSA-162: Entry Point Detector — Main orchestrator.
+ */
+
+import Database from 'better-sqlite3';
+import type { EntryPoint, EntryPointFilters, EntryPointQueryResult } from './types.js';
+import { PatternRegistry } from './PatternRegistry.js';
+import { FrameworkDetector } from './FrameworkDetector.js';
+import { EntryPointStore } from './EntryPointStore.js';
+import { HTTPHandlerDetector } from './detectors/HTTPHandlerDetector.js';
+import { MainDetector } from './detectors/MainDetector.js';
+import { CLIDetector } from './detectors/CLIDetector.js';
+import { EventDetector } from './detectors/EventDetector.js';
+
+export class EntryPointDetector {
+  private registry: PatternRegistry;
+  private frameworkDetector: FrameworkDetector;
+  private httpDetector: HTTPHandlerDetector;
+  private mainDetector: MainDetector;
+  private cliDetector: CLIDetector;
+  private eventDetector: EventDetector;
+  private store: EntryPointStore;
+  private db: Database.Database;
+
+  constructor(db: Database.Database) {
+    this.db = db;
+    this.registry = new PatternRegistry();
+    this.frameworkDetector = new FrameworkDetector(this.registry);
+    this.httpDetector = new HTTPHandlerDetector(this.registry);
+    this.mainDetector = new MainDetector(this.registry);
+    this.cliDetector = new CLIDetector();
+    this.eventDetector = new EventDetector();
+    this.store = new EntryPointStore(db);
+  }
+
+  /** Detect all entry points in a file. */
+  detectFile(filePath: string, source: string, language: string, symbols: Array<{
+    id: number; name: string; decorators?: string[]; parentName?: string | null;
+    filePath: string; startLine: number;
+  }>): EntryPoint[] {
+    const allEntryPoints: EntryPoint[] = [];
+
+    // 1. Detect framework
+    const framework = this.frameworkDetector.detect(source, language);
+
+    // 2. HTTP handlers (if framework detected)
+    if (framework) {
+      const httpEntries = this.httpDetector.detectFromSymbols(symbols, framework.name, source);
+      allEntryPoints.push(...httpEntries);
+    }
+
+    // 3. Main functions
+    const mainEntries = this.mainDetector.detect(symbols, source, language);
+    allEntryPoints.push(...mainEntries);
+
+    // 4. CLI commands
+    const cliEntries = this.cliDetector.detect(symbols, source);
+    allEntryPoints.push(...cliEntries);
+
+    // 5. Event handlers
+    const eventEntries = this.eventDetector.detect(symbols, source);
+    allEntryPoints.push(...eventEntries);
+
+    // Store results
+    if (allEntryPoints.length > 0) {
+      this.store.upsertBatch(allEntryPoints);
+    }
+
+    return allEntryPoints;
+  }
+
+  /** Query stored entry points. */
+  query(filters: EntryPointFilters): EntryPointQueryResult {
+    return this.store.query(filters);
+  }
+}

package/src/engine/analyzers/entry-points/EntryPointStore.ts

@@ -0,0 +1,162 @@
+/**
+ * KSA-162: Entry Point Store — SQLite CRUD for detected entry points.
+ */
+
+import Database from 'better-sqlite3';
+import type { EntryPoint, EntryPointFilters, EntryPointQueryResult } from './types.js';
+
+const CREATE_TABLE = `
+CREATE TABLE IF NOT EXISTS entry_points (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  symbol_id INTEGER NOT NULL,
+  entry_type TEXT NOT NULL,
+  framework TEXT,
+  http_method TEXT,
+  route_path TEXT,
+  full_route TEXT,
+  middleware TEXT,
+  has_auth INTEGER DEFAULT 0,
+  controller TEXT,
+  event_name TEXT,
+  confidence TEXT DEFAULT 'High',
+  detected_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (symbol_id) REFERENCES symbols(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_ep_type ON entry_points(entry_type);
+CREATE INDEX IF NOT EXISTS idx_ep_framework ON entry_points(framework);
+CREATE INDEX IF NOT EXISTS idx_ep_route ON entry_points(route_path);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_ep_symbol ON entry_points(symbol_id);
+`;
+
+export class EntryPointStore {
+  private db: Database.Database;
+  private stmts!: {
+    upsert: Database.Statement;
+    deleteBySymbol: Database.Statement;
+  };
+
+  constructor(db: Database.Database) {
+    this.db = db;
+    this.ensureTable();
+    this.prepareStatements();
+  }
+
+  /** Store or update an entry point. */
+  upsert(ep: EntryPoint): void {
+    this.stmts.upsert.run(
+      ep.symbol_id,
+      ep.entry_type,
+      ep.framework,
+      ep.http_method,
+      ep.route_path,
+      ep.full_route,
+      JSON.stringify(ep.middleware),
+      ep.has_auth ? 1 : 0,
+      ep.controller,
+      ep.event_name,
+      ep.confidence
+    );
+  }
+
+  /** Batch upsert entry points. */
+  upsertBatch(entries: EntryPoint[]): void {
+    const transaction = this.db.transaction((items: EntryPoint[]) => {
+      for (const ep of items) this.upsert(ep);
+    });
+    transaction(entries);
+  }
+
+  /** Query entry points with filters. */
+  query(filters: EntryPointFilters): EntryPointQueryResult {
+    let sql = `
+      SELECT ep.*, s.name as symbol_name, f.relative_path as file_path, s.start_line
+      FROM entry_points ep
+      JOIN symbols s ON s.id = ep.symbol_id
+      JOIN files f ON f.id = s.file_id
+      WHERE 1=1
+    `;
+    const params: unknown[] = [];
+
+    if (filters.entryType) {
+      sql += ' AND ep.entry_type = ?';
+      params.push(filters.entryType);
+    }
+    if (filters.framework) {
+      sql += ' AND ep.framework = ?';
+      params.push(filters.framework);
+    }
+    if (filters.httpMethod) {
+      sql += ' AND ep.http_method = ?';
+      params.push(filters.httpMethod.toUpperCase());
+    }
+    if (filters.routePattern) {
+      sql += ' AND ep.full_route LIKE ?';
+      params.push(`%${filters.routePattern}%`);
+    }
+    if (filters.hasAuth !== undefined) {
+      sql += ' AND ep.has_auth = ?';
+      params.push(filters.hasAuth ? 1 : 0);
+    }
+    if (filters.filePath) {
+      sql += ' AND f.relative_path LIKE ?';
+      params.push(`%${filters.filePath}%`);
+    }
+
+    // Count
+    const countSql = sql.replace(/SELECT ep\.\*.*?FROM/, 'SELECT COUNT(*) as total FROM');
+    const totalRow = this.db.prepare(countSql).get(...params) as { total: number } | undefined;
+    const total = totalRow?.total ?? 0;
+
+    sql += ' ORDER BY ep.entry_type, ep.full_route LIMIT ?';
+    params.push(filters.limit);
+
+    const rows = this.db.prepare(sql).all(...params) as Array<EntryPoint & { middleware: string }>;
+    const results = rows.map(r => ({
+      ...r,
+      middleware: r.middleware ? JSON.parse(r.middleware as string) : [],
+      has_auth: Boolean(r.has_auth),
+    }));
+
+    // Summary
+    const typeSql = 'SELECT entry_type, COUNT(*) as count FROM entry_points GROUP BY entry_type';
+    const typeRows = this.db.prepare(typeSql).all() as Array<{ entry_type: string; count: number }>;
+    const byType: Record<string, number> = {};
+    for (const r of typeRows) byType[r.entry_type] = r.count;
+
+    const fwSql = 'SELECT framework, COUNT(*) as count FROM entry_points WHERE framework IS NOT NULL GROUP BY framework';
+    const fwRows = this.db.prepare(fwSql).all() as Array<{ framework: string; count: number }>;
+    const byFramework: Record<string, number> = {};
+    for (const r of fwRows) byFramework[r.framework] = r.count;
+
+    const authSql = 'SELECT has_auth, COUNT(*) as count FROM entry_points GROUP BY has_auth';
+    const authRows = this.db.prepare(authSql).all() as Array<{ has_auth: number; count: number }>;
+    const authCoverage = { withAuth: 0, withoutAuth: 0 };
+    for (const r of authRows) {
+      if (r.has_auth) authCoverage.withAuth = r.count;
+      else authCoverage.withoutAuth = r.count;
+    }
+
+    return { results, total, summary: { byType, byFramework, authCoverage } };
+  }
+
+  /** Delete entry point for a symbol. */
+  deleteBySymbol(symbolId: number): void {
+    this.stmts.deleteBySymbol.run(symbolId);
+  }
+
+  private ensureTable(): void {
+    this.db.exec(CREATE_TABLE);
+  }
+
+  private prepareStatements(): void {
+    this.stmts = {
+      upsert: this.db.prepare(`
+        INSERT OR REPLACE INTO entry_points
+          (symbol_id, entry_type, framework, http_method, route_path, full_route,
+           middleware, has_auth, controller, event_name, confidence, detected_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+      `),
+      deleteBySymbol: this.db.prepare('DELETE FROM entry_points WHERE symbol_id = ?'),
+    };
+  }
+}

package/src/engine/analyzers/entry-points/EntryPointTool.ts

@@ -0,0 +1,63 @@
+/**
+ * KSA-162: MCP Tool registration for find_entry_points.
+ */
+
+import Database from 'better-sqlite3';
+import { EntryPointDetector } from './EntryPointDetector.js';
+import type { EntryType } from './types.js';
+
+export const ENTRY_POINT_TOOL_DEFINITION = {
+  name: 'find_entry_points',
+  description: 'Find HTTP handlers, main functions, CLI commands, and event handlers in the codebase.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      entry_type: { type: 'string', description: 'Filter: HTTP_HANDLER, MAIN, CLI_COMMAND, EVENT_HANDLER, SCHEDULED' },
+      framework: { type: 'string', description: 'Filter by framework (express, nestjs, spring, fastapi, ktor, gin)' },
+      http_method: { type: 'string', description: 'Filter by HTTP method (GET, POST, PUT, DELETE, PATCH)' },
+      route_pattern: { type: 'string', description: 'Filter by route pattern (partial match)' },
+      has_auth: { type: 'boolean', description: 'Filter by auth presence' },
+      file_path: { type: 'string', description: 'Filter by file path' },
+      limit: { type: 'number', description: 'Max results (default: 30)' },
+    },
+  },
+};
+
+/** Handle find_entry_points tool call. */
+export function handleEntryPointTool(args: Record<string, unknown>, db: Database.Database): string {
+  const detector = new EntryPointDetector(db);
+
+  const result = detector.query({
+    entryType: args.entry_type as EntryType | undefined,
+    framework: args.framework as string | undefined,
+    httpMethod: args.http_method as string | undefined,
+    routePattern: args.route_pattern as string | undefined,
+    hasAuth: args.has_auth as boolean | undefined,
+    filePath: args.file_path as string | undefined,
+    limit: (args.limit as number) ?? 30,
+  });
+
+  if (result.results.length === 0) {
+    return 'No entry points found. Run indexing to detect entry points.';
+  }
+
+  const lines: string[] = [
+    `Entry Points — ${result.total} found\n`,
+    `By Type: ${Object.entries(result.summary.byType).map(([k, v]) => `${k}=${v}`).join(' ')}`,
+    `By Framework: ${Object.entries(result.summary.byFramework).map(([k, v]) => `${k}=${v}`).join(' ') || 'N/A'}`,
+    `Auth: ${result.summary.authCoverage.withAuth} with auth, ${result.summary.authCoverage.withoutAuth} without\n`,
+  ];
+
+  for (const ep of result.results) {
+    if (ep.entry_type === 'HTTP_HANDLER') {
+      const auth = ep.has_auth ? ' 🔒' : '';
+      lines.push(`  ${ep.http_method} ${ep.full_route}${auth} → ${ep.symbol_name}`);
+      lines.push(`    ${ep.file_path}:${ep.start_line} [${ep.framework}]`);
+    } else {
+      lines.push(`  [${ep.entry_type}] ${ep.symbol_name}${ep.event_name ? ` (${ep.event_name})` : ''}`);
+      lines.push(`    ${ep.file_path}:${ep.start_line}`);
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/engine/analyzers/entry-points/FrameworkDetector.ts

@@ -0,0 +1,57 @@
+/**
+ * KSA-162: Framework Detector — Identifies frameworks from import statements.
+ */
+
+import type { FrameworkInfo } from './types.js';
+import { PatternRegistry } from './PatternRegistry.js';
+
+export class FrameworkDetector {
+  private registry: PatternRegistry;
+
+  constructor(registry: PatternRegistry) {
+    this.registry = registry;
+  }
+
+  /** Detect framework from file source code (import analysis). */
+  detect(source: string, language: string): FrameworkInfo | null {
+    const frameworks = this.registry.getFrameworksForLanguage(language);
+    if (frameworks.length === 0) return null;
+
+    let bestMatch: { name: string; score: number } | null = null;
+
+    for (const { name, patterns } of frameworks) {
+      let score = 0;
+      for (const importPattern of patterns.imports) {
+        if (source.includes(importPattern)) {
+          score++;
+        }
+      }
+      if (score > 0 && (!bestMatch || score > bestMatch.score)) {
+        bestMatch = { name, score };
+      }
+    }
+
+    if (!bestMatch) return null;
+
+    return {
+      name: bestMatch.name,
+      language,
+      confidence: bestMatch.score >= 2 ? 'High' : 'Medium',
+    };
+  }
+
+  /** Detect framework from a list of import strings (from relationships table). */
+  detectFromImports(imports: string[], language: string): FrameworkInfo | null {
+    const frameworks = this.registry.getFrameworksForLanguage(language);
+    if (frameworks.length === 0) return null;
+
+    for (const { name, patterns } of frameworks) {
+      for (const importPattern of patterns.imports) {
+        if (imports.some(imp => imp.includes(importPattern))) {
+          return { name, language, confidence: 'High' };
+        }
+      }
+    }
+    return null;
+  }
+}

package/src/engine/analyzers/entry-points/PatternRegistry.ts

@@ -0,0 +1,114 @@
+/**
+ * KSA-162: Pattern Registry — Manages framework detection patterns.
+ */
+
+import type { PatternConfig, FrameworkPatterns } from './types.js';
+
+const DEFAULT_PATTERNS: PatternConfig = {
+  frameworks: {
+    fastapi: {
+      language: 'python',
+      imports: ['fastapi', 'from fastapi'],
+      decorators: {
+        handler: ['app.get', 'app.post', 'app.put', 'app.delete', 'app.patch',
+                  'router.get', 'router.post', 'router.put', 'router.delete', 'router.patch'],
+        prefix: ['APIRouter(prefix='],
+      },
+      auth_indicators: ['Depends(get_current_user)', 'Security(', 'Depends(auth'],
+    },
+    express: {
+      language: 'typescript',
+      imports: ['express', "from 'express'", 'from "express"'],
+      call_patterns: {
+        handler: ['app.get', 'app.post', 'app.put', 'app.delete', 'app.patch',
+                  'router.get', 'router.post', 'router.put', 'router.delete', 'router.patch'],
+        mount: ['app.use'],
+      },
+      auth_indicators: ['authenticate', 'passport', 'authMiddleware', 'requireAuth'],
+    },
+    nestjs: {
+      language: 'typescript',
+      imports: ['@nestjs/common', '@nestjs/core'],
+      decorators: {
+        handler: ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Head', 'Options', 'All'],
+        prefix: ['Controller'],
+      },
+      auth_indicators: ['UseGuards', 'AuthGuard', '@Auth', 'JwtAuthGuard'],
+    },
+    spring: {
+      language: 'java',
+      imports: ['org.springframework.web', 'org.springframework.boot'],
+      decorators: {
+        handler: ['GetMapping', 'PostMapping', 'PutMapping', 'DeleteMapping', 'PatchMapping', 'RequestMapping'],
+        prefix: ['RequestMapping', 'RestController'],
+      },
+      auth_indicators: ['@PreAuthorize', '@Secured', '@RolesAllowed'],
+    },
+    ktor: {
+      language: 'kotlin',
+      imports: ['io.ktor.server', 'io.ktor.routing'],
+      call_patterns: {
+        handler: ['get(', 'post(', 'put(', 'delete(', 'patch(', 'route('],
+        mount: ['routing {', 'install('],
+      },
+      auth_indicators: ['authenticate(', 'principal', 'jwt {'],
+    },
+    gin: {
+      language: 'go',
+      imports: ['github.com/gin-gonic/gin'],
+      call_patterns: {
+        handler: ['GET(', 'POST(', 'PUT(', 'DELETE(', 'PATCH(', 'Handle('],
+        mount: ['Group('],
+      },
+      auth_indicators: ['AuthMiddleware', 'authRequired', 'JWTAuth'],
+    },
+  },
+  main_patterns: {
+    python: { pattern: 'if __name__ == "__main__":', type: 'MAIN' },
+    typescript: { pattern: 'process.argv', type: 'MAIN' },
+    javascript: { pattern: 'process.argv', type: 'MAIN' },
+    java: { pattern: 'public static void main(String', type: 'MAIN' },
+    kotlin: { pattern: 'fun main(', type: 'MAIN' },
+    go: { pattern: 'func main()', type: 'MAIN' },
+  },
+};
+
+export class PatternRegistry {
+  private config: PatternConfig;
+
+  constructor(customConfig?: Partial<PatternConfig>) {
+    this.config = customConfig
+      ? { ...DEFAULT_PATTERNS, ...customConfig }
+      : DEFAULT_PATTERNS;
+  }
+
+  /** Get framework patterns by name. */
+  getFramework(name: string): FrameworkPatterns | null {
+    return this.config.frameworks[name] ?? null;
+  }
+
+  /** Get all framework names. */
+  getFrameworkNames(): string[] {
+    return Object.keys(this.config.frameworks);
+  }
+
+  /** Get frameworks for a specific language. */
+  getFrameworksForLanguage(language: string): Array<{ name: string; patterns: FrameworkPatterns }> {
+    return Object.entries(this.config.frameworks)
+      .filter(([_, p]) => p.language === language)
+      .map(([name, patterns]) => ({ name, patterns }));
+  }
+
+  /** Get main pattern for a language. */
+  getMainPattern(language: string): { pattern: string; type: string } | null {
+    return this.config.main_patterns[language] ?? null;
+  }
+
+  /** Get all import patterns for framework detection. */
+  getAllImportPatterns(): Array<{ framework: string; imports: string[] }> {
+    return Object.entries(this.config.frameworks).map(([name, p]) => ({
+      framework: name,
+      imports: p.imports,
+    }));
+  }
+}

package/src/engine/analyzers/entry-points/RouteResolver.ts

@@ -0,0 +1,44 @@
+/**
+ * KSA-162: Route Resolver — Resolves full routes from controller prefix + method path.
+ */
+
+export class RouteResolver {
+  /** Resolve full route: controller prefix + method path. */
+  resolve(controllerPrefix: string | null, methodPath: string): string {
+    const prefix = this.normalizePath(controllerPrefix ?? '');
+    const path = this.normalizePath(methodPath);
+
+    if (!prefix) return path || '/';
+    if (!path || path === '/') return prefix;
+    return `${prefix}${path}`;
+  }
+
+  /** Normalize route params: :id, {id}, <int:id> → {id}. */
+  normalizeParams(path: string): string {
+    return path
+      // Express-style :param → {param}
+      .replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}')
+      // Flask-style <type:param> → {param}
+      .replace(/<(?:[a-z]+:)?([a-zA-Z_][a-zA-Z0-9_]*)>/g, '{$1}')
+      // Already normalized {param} stays as-is
+      ;
+  }
+
+  /** Extract route path from a decorator/annotation argument string. */
+  extractPathFromArg(arg: string): string {
+    // Remove quotes
+    let path = arg.replace(/^['"`]|['"`]$/g, '').trim();
+    // Normalize params
+    path = this.normalizeParams(path);
+    return path;
+  }
+
+  private normalizePath(path: string): string {
+    if (!path) return '';
+    // Ensure starts with /
+    if (!path.startsWith('/')) path = '/' + path;
+    // Remove trailing slash (except root)
+    if (path.length > 1 && path.endsWith('/')) path = path.slice(0, -1);
+    return path;
+  }
+}

package/src/engine/analyzers/entry-points/detectors/CLIDetector.ts

@@ -0,0 +1,48 @@
+/**
+ * KSA-162: CLI Command Detector — Detects CLI command entry points.
+ */
+
+import type { EntryPoint } from '../types.js';
+
+const CLI_PATTERNS = [
+  { pattern: 'commander', indicator: '.command(' },
+  { pattern: 'yargs', indicator: '.command(' },
+  { pattern: 'click', indicator: '@click.command' },
+  { pattern: 'argparse', indicator: 'add_subparsers' },
+  { pattern: 'cobra', indicator: 'cobra.Command' },
+  { pattern: 'clap', indicator: '#[command' },
+];
+
+export class CLIDetector {
+  /** Detect CLI command entry points. */
+  detect(
+    symbols: Array<{ id: number; name: string; decorators?: string[]; filePath: string; startLine: number }>,
+    source: string
+  ): EntryPoint[] {
+    const results: EntryPoint[] = [];
+
+    // Check if file uses a CLI framework
+    const cliFramework = CLI_PATTERNS.find(p => source.includes(p.pattern));
+    if (!cliFramework) return [];
+
+    for (const sym of symbols) {
+      const decorators = sym.decorators ?? [];
+      const isCLI = decorators.some(d => d.includes('command') || d.includes('cli')) ||
+                    sym.name.includes('command') || sym.name.includes('cmd') ||
+                    sym.name.startsWith('cli_');
+
+      if (isCLI) {
+        results.push({
+          symbol_id: sym.id, symbol_name: sym.name,
+          file_path: sym.filePath, start_line: sym.startLine,
+          entry_type: 'CLI_COMMAND', framework: cliFramework.pattern,
+          http_method: null, route_path: null, full_route: null,
+          middleware: [], has_auth: false, controller: null,
+          event_name: sym.name, confidence: 'Medium',
+        });
+      }
+    }
+
+    return results;
+  }
+}

package/src/engine/analyzers/entry-points/detectors/EventDetector.ts

@@ -0,0 +1,77 @@
+/**
+ * KSA-162: Event/MQ/Scheduled Handler Detector.
+ */
+
+import type { EntryPoint } from '../types.js';
+
+const EVENT_INDICATORS = [
+  { pattern: '@EventHandler', type: 'EVENT_HANDLER' as const },
+  { pattern: '@Scheduled', type: 'SCHEDULED' as const },
+  { pattern: '@Cron', type: 'SCHEDULED' as const },
+  { pattern: 'on_event', type: 'EVENT_HANDLER' as const },
+  { pattern: '.on(', type: 'EVENT_HANDLER' as const },
+  { pattern: '.subscribe(', type: 'EVENT_HANDLER' as const },
+  { pattern: '@RabbitListener', type: 'EVENT_HANDLER' as const },
+  { pattern: '@KafkaListener', type: 'EVENT_HANDLER' as const },
+  { pattern: '@SqsListener', type: 'EVENT_HANDLER' as const },
+  { pattern: 'setInterval', type: 'SCHEDULED' as const },
+  { pattern: 'cron.schedule', type: 'SCHEDULED' as const },
+];
+
+export class EventDetector {
+  /** Detect event/scheduled handlers. */
+  detect(
+    symbols: Array<{ id: number; name: string; decorators?: string[]; filePath: string; startLine: number }>,
+    source: string
+  ): EntryPoint[] {
+    const results: EntryPoint[] = [];
+
+    for (const sym of symbols) {
+      const decorators = sym.decorators ?? [];
+      const symContext = this.getContext(source, sym.startLine);
+
+      for (const indicator of EVENT_INDICATORS) {
+        const found = decorators.some(d => d.includes(indicator.pattern)) ||
+                      symContext.includes(indicator.pattern);
+
+        if (found) {
+          const eventName = this.extractEventName(decorators, symContext, indicator.pattern);
+          results.push({
+            symbol_id: sym.id, symbol_name: sym.name,
+            file_path: sym.filePath, start_line: sym.startLine,
+            entry_type: indicator.type, framework: null,
+            http_method: null, route_path: null, full_route: null,
+            middleware: [], has_auth: false, controller: null,
+            event_name: eventName ?? sym.name, confidence: 'Medium',
+          });
+          break; // One entry per symbol
+        }
+      }
+    }
+
+    return results;
+  }
+
+  private extractEventName(decorators: string[], context: string, pattern: string): string | null {
+    for (const dec of decorators) {
+      if (dec.includes(pattern)) {
+        const match = dec.match(/['"`]([^'"`]+)['"`]/);
+        if (match) return match[1];
+      }
+    }
+    const idx = context.indexOf(pattern);
+    if (idx >= 0) {
+      const after = context.slice(idx + pattern.length);
+      const match = after.match(/['"`]([^'"`]+)['"`]/);
+      if (match) return match[1];
+    }
+    return null;
+  }
+
+  private getContext(source: string, startLine: number): string {
+    const lines = source.split('\n');
+    const start = Math.max(0, startLine - 2);
+    const end = Math.min(lines.length, startLine + 3);
+    return lines.slice(start, end).join('\n');
+  }
+}