fcis 0.1.0

package/src/detection/detect-markers.ts

@@ -0,0 +1,480 @@
+/**
+ * Marker Detection - Pure Core
+ *
+ * Detects impurity markers in extracted functions. This is a PURE module -
+ * all functions take data in and return data out with no I/O.
+ *
+ * Marker categories:
+ * - Async/Await: await expressions indicate I/O suspension
+ * - Database: Prisma/db calls
+ * - Network: fetch, axios, http calls
+ * - File System: fs operations
+ * - Environment: process.env access
+ * - Logging: console, logger calls
+ * - Queue/Events: enqueue, emit calls
+ */
+
+import type {
+  DetectionContext,
+  ExtractedFunction,
+  ImpurityMarker,
+} from '../types.js'
+
+/**
+ * Database operations that indicate impurity
+ */
+const DATABASE_OPERATIONS = new Set([
+  'findFirst',
+  'findMany',
+  'findUnique',
+  'findUniqueOrThrow',
+  'findFirstOrThrow',
+  'create',
+  'createMany',
+  'update',
+  'updateMany',
+  'delete',
+  'deleteMany',
+  'upsert',
+  'aggregate',
+  'count',
+  'groupBy',
+  '$transaction',
+  '$queryRaw',
+  '$executeRaw',
+])
+
+/**
+ * Telemetry/analytics patterns
+ */
+const TELEMETRY_PATTERNS = [
+  /^track[A-Z]/,
+  /^analytics\./,
+  /^segment\./,
+  /^mixpanel\./,
+  /^amplitude\./,
+  /^posthog\./,
+  /^gtag\(/,
+  /^ga\(/,
+]
+
+/**
+ * Detect all impurity markers in a function
+ *
+ * @param fn - The extracted function to analyze
+ * @param context - Detection context including imports
+ * @returns Array of detected impurity markers
+ */
+export function detectMarkers(
+  fn: ExtractedFunction,
+  context: DetectionContext,
+): ImpurityMarker[] {
+  const markers: ImpurityMarker[] = []
+
+  // Detect await expressions
+  detectAwaitMarkers(fn, markers)
+
+  // Detect database calls
+  detectDatabaseMarkers(fn, markers)
+
+  // Detect network calls
+  detectNetworkMarkers(fn, context, markers)
+
+  // Detect file system usage
+  detectFileSystemMarkers(fn, context, markers)
+
+  // Detect environment access
+  detectEnvMarkers(fn, markers)
+
+  // Detect logging
+  detectLoggingMarkers(fn, context, markers)
+
+  // Detect telemetry
+  detectTelemetryMarkers(fn, markers)
+
+  // Detect queue operations
+  detectQueueMarkers(fn, markers)
+
+  // Detect event emissions
+  detectEventMarkers(fn, markers)
+
+  return markers
+}
+
+/**
+ * Detect await expressions
+ */
+function detectAwaitMarkers(
+  fn: ExtractedFunction,
+  markers: ImpurityMarker[],
+): void {
+  if (fn.hasAwait) {
+    // Find awaited call sites for details
+    const awaitedCalls = fn.callSites.filter(cs => cs.isAwaited)
+    if (awaitedCalls.length > 0) {
+      for (const call of awaitedCalls) {
+        markers.push({
+          type: 'await-expression',
+          detail: `await ${call.expression}`,
+          line: call.line,
+        })
+      }
+    } else {
+      // Await on something other than a call (e.g., await promise variable)
+      markers.push({
+        type: 'await-expression',
+        detail: 'await expression',
+      })
+    }
+  }
+}
+
+/**
+ * Detect database calls (Prisma pattern: db.<entity>.<operation>)
+ */
+function detectDatabaseMarkers(
+  fn: ExtractedFunction,
+  markers: ImpurityMarker[],
+): void {
+  for (const callSite of fn.callSites) {
+    if (isDatabaseCall(callSite.expression)) {
+      markers.push({
+        type: 'database-call',
+        detail: callSite.expression,
+        line: callSite.line,
+      })
+    }
+  }
+}
+
+/**
+ * Check if an expression is a database call
+ */
+function isDatabaseCall(expression: string): boolean {
+  // Match patterns like: db.user.findFirst, prisma.user.create, ctx.db.user.findMany
+  const parts = expression.split('.')
+
+  // Need at least 3 parts: db.entity.operation
+  if (parts.length < 3) {
+    // Check for direct prisma operations like prisma.$transaction
+    if (parts.length === 2) {
+      const [base, operation] = parts
+      if (
+        (base === 'db' || base === 'prisma') &&
+        operation &&
+        DATABASE_OPERATIONS.has(operation)
+      ) {
+        return true
+      }
+    }
+    return false
+  }
+
+  // Check if any part is 'db' or 'prisma' and the last part is a database operation
+  const lastPart = parts[parts.length - 1]
+  if (!lastPart || !DATABASE_OPERATIONS.has(lastPart)) {
+    return false
+  }
+
+  // Check for db or prisma in the chain
+  return parts.some(
+    part => part === 'db' || part === 'prisma' || part === 'database',
+  )
+}
+
+/**
+ * Detect network/HTTP calls
+ *
+ * Note: We only detect actual call sites, not file-level imports.
+ * A function is only marked with network markers if it actually calls
+ * fetch, axios, or other HTTP client functions.
+ */
+function detectNetworkMarkers(
+  fn: ExtractedFunction,
+  _context: DetectionContext,
+  markers: ImpurityMarker[],
+): void {
+  // Check for fetch calls
+  for (const callSite of fn.callSites) {
+    if (
+      callSite.expression === 'fetch' ||
+      callSite.expression.endsWith('.fetch')
+    ) {
+      markers.push({
+        type: 'network-fetch',
+        detail: callSite.expression,
+        line: callSite.line,
+      })
+    }
+
+    // Check for axios calls
+    if (
+      callSite.expression.startsWith('axios') ||
+      callSite.expression === 'axios'
+    ) {
+      markers.push({
+        type: 'network-http',
+        detail: callSite.expression,
+        line: callSite.line,
+      })
+    }
+  }
+}
+
+/**
+ * Detect file system usage
+ *
+ * Note: We only detect actual call sites, not file-level imports.
+ * A function is only marked with fs markers if it actually calls
+ * fs functions like readFile, writeFile, etc.
+ */
+function detectFileSystemMarkers(
+  fn: ExtractedFunction,
+  _context: DetectionContext,
+  markers: ImpurityMarker[],
+): void {
+  // Check for fs calls in the function
+  for (const callSite of fn.callSites) {
+    if (isFsCall(callSite.expression)) {
+      markers.push({
+        type: 'fs-call',
+        detail: callSite.expression,
+        line: callSite.line,
+      })
+    }
+  }
+}
+
+/**
+ * Check if an expression is a file system call
+ */
+function isFsCall(expression: string): boolean {
+  const parts = expression.split('.')
+  return parts.some(
+    part => part === 'fs' || part === 'readFile' || part === 'writeFile',
+  )
+}
+
+/**
+ * Detect environment variable access
+ */
+function detectEnvMarkers(
+  fn: ExtractedFunction,
+  markers: ImpurityMarker[],
+): void {
+  for (const chain of fn.propertyAccessChains) {
+    if (chain.startsWith('process.env')) {
+      markers.push({
+        type: 'env-access',
+        detail: chain,
+      })
+    }
+  }
+}
+
+/**
+ * Detect logging calls
+ *
+ * Note: We only detect actual call sites, not file-level imports.
+ * A function is only marked with logging markers if it actually calls
+ * console.log, logger.info, log(), etc.
+ */
+function detectLoggingMarkers(
+  fn: ExtractedFunction,
+  _context: DetectionContext,
+  markers: ImpurityMarker[],
+): void {
+  for (const callSite of fn.callSites) {
+    // Console logging
+    if (isConsoleLog(callSite.expression)) {
+      markers.push({
+        type: 'console-log',
+        detail: callSite.expression,
+        line: callSite.line,
+      })
+    }
+
+    // Logger calls
+    if (isLoggerCall(callSite.expression)) {
+      markers.push({
+        type: 'logging',
+        detail: callSite.expression,
+        line: callSite.line,
+      })
+    }
+  }
+}
+
+/**
+ * Check if an expression is a console.log call
+ */
+function isConsoleLog(expression: string): boolean {
+  return (
+    expression === 'console.log' ||
+    expression === 'console.error' ||
+    expression === 'console.warn' ||
+    expression === 'console.info' ||
+    expression === 'console.debug'
+  )
+}
+
+/**
+ * Check if an expression is a logger call
+ */
+function isLoggerCall(expression: string): boolean {
+  const parts = expression.split('.')
+  if (parts.length < 2) {
+    return expression === 'log'
+  }
+
+  const base = parts[0]
+  const method = parts[parts.length - 1]
+
+  if (base === 'logger' || base === 'log') {
+    return true
+  }
+
+  // Check for common logger methods
+  const logMethods = new Set([
+    'info',
+    'warn',
+    'error',
+    'debug',
+    'trace',
+    'fatal',
+  ])
+  return (
+    (parts.includes('logger') || parts.includes('log')) &&
+    method !== undefined &&
+    logMethods.has(method)
+  )
+}
+
+/**
+ * Detect telemetry/analytics calls
+ */
+function detectTelemetryMarkers(
+  fn: ExtractedFunction,
+  markers: ImpurityMarker[],
+): void {
+  for (const callSite of fn.callSites) {
+    if (isTelemetryCall(callSite.expression)) {
+      markers.push({
+        type: 'telemetry',
+        detail: callSite.expression,
+        line: callSite.line,
+      })
+    }
+  }
+}
+
+/**
+ * Check if an expression is a telemetry call
+ */
+function isTelemetryCall(expression: string): boolean {
+  return TELEMETRY_PATTERNS.some(pattern => pattern.test(expression))
+}
+
+/**
+ * Detect queue operations
+ */
+function detectQueueMarkers(
+  fn: ExtractedFunction,
+  markers: ImpurityMarker[],
+): void {
+  for (const callSite of fn.callSites) {
+    if (isQueueCall(callSite.expression)) {
+      markers.push({
+        type: 'queue-enqueue',
+        detail: callSite.expression,
+        line: callSite.line,
+      })
+    }
+  }
+}
+
+/**
+ * Check if an expression is a queue operation
+ */
+function isQueueCall(expression: string): boolean {
+  return (
+    expression.endsWith('.enqueue') ||
+    expression.endsWith('.add') ||
+    expression.endsWith('.publish') ||
+    expression.includes('queue.') ||
+    expression.includes('Queue.')
+  )
+}
+
+/**
+ * Detect event emissions
+ */
+function detectEventMarkers(
+  fn: ExtractedFunction,
+  markers: ImpurityMarker[],
+): void {
+  for (const callSite of fn.callSites) {
+    if (isEventEmit(callSite.expression)) {
+      markers.push({
+        type: 'event-emit',
+        detail: callSite.expression,
+        line: callSite.line,
+      })
+    }
+  }
+}
+
+/**
+ * Check if an expression is an event emission
+ */
+function isEventEmit(expression: string): boolean {
+  return (
+    expression.endsWith('.emit') ||
+    expression.endsWith('.dispatch') ||
+    expression.endsWith('.trigger') ||
+    expression.endsWith('.fire')
+  )
+}
+
+/**
+ * Create detection context from file imports
+ */
+export function createDetectionContext(
+  imports: import('../types.js').FileImports,
+): DetectionContext {
+  // Identify imports from .pure files
+  const pureFileImports = new Set<string>()
+
+  for (const imp of imports.imports) {
+    if (
+      imp.moduleSpecifier.endsWith('.pure') ||
+      imp.moduleSpecifier.includes('.pure/')
+    ) {
+      pureFileImports.add(imp.moduleSpecifier)
+    }
+  }
+
+  return {
+    imports,
+    pureFileImports,
+  }
+}
+
+/**
+ * Get the names of functions imported from .pure files
+ */
+export function getPureImportedFunctions(
+  context: DetectionContext,
+): Set<string> {
+  const pureFunctions = new Set<string>()
+
+  for (const imp of context.imports.imports) {
+    if (context.pureFileImports.has(imp.moduleSpecifier)) {
+      for (const name of imp.namedImports) {
+        pureFunctions.add(name)
+      }
+    }
+  }
+
+  return pureFunctions
+}