@flisk/analyze-tracking 0.8.3 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flisk/analyze-tracking",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Analyzes tracking code in a project and generates data schemas",
   "main": "src/index.js",
   "bin": {

package/src/analyze/index.js

@@ -4,73 +4,169 @@
  */
 
 const path = require('path');
+const { execSync } = require('child_process');
 
 const { parseCustomFunctionSignature } = require('./utils/customFunctionParser');
 const { getAllFiles } = require('../utils/fileProcessor');
 const { analyzeJsFile } = require('./javascript');
-const { analyzeTsFile } = require('./typescript');
+const { analyzeTsFiles } = require('./typescript');
 const { analyzePythonFile } = require('./python');
-const { analyzeRubyFile } = require('./ruby');
+const { analyzeRubyFile, prebuildConstantMaps } = require('./ruby');
 const { analyzeGoFile } = require('./go');
 
+/**
+ * Analyzes a single file for analytics tracking calls
+ * 
+ * Note: typescript files are handled separately by analyzeTsFiles, which is a batch processor
+ * 
+ * @param {string} file - Path to the file to analyze
+ * @param {Array<string>} customFunctionSignatures - Custom function signatures to detect
+ * @returns {Promise<Array<Object>>} Array of events found in the file
+ */
+async function analyzeFile(file, customFunctionSignatures) {
+  if (/\.jsx?$/.test(file)) return analyzeJsFile(file, customFunctionSignatures)
+  if (/\.py$/.test(file))   return analyzePythonFile(file, customFunctionSignatures)
+  if (/\.rb$/.test(file))   return analyzeRubyFile(file, customFunctionSignatures)
+  if (/\.go$/.test(file))   return analyzeGoFile(file, customFunctionSignatures)
+  return []
+}
+
+/**
+ * Adds an event to the events collection, merging properties if event already exists
+ * 
+ * @param {Object} allEvents - Collection of all events
+ * @param {Object} event - Event to add
+ * @param {string} baseDir - Base directory for relative path calculation
+ */
+function addEventToCollection(allEvents, event, baseDir) {
+  const relativeFilePath = path.relative(baseDir, event.filePath);
+  
+  const implementation = {
+    path: relativeFilePath,
+    line: event.line,
+    function: event.functionName,
+    destination: event.source
+  };
+
+  if (!allEvents[event.eventName]) {
+    allEvents[event.eventName] = {
+      implementations: [implementation],
+      properties: event.properties,
+    };
+  } else {
+    allEvents[event.eventName].implementations.push(implementation);
+    allEvents[event.eventName].properties = {
+      ...allEvents[event.eventName].properties,
+      ...event.properties,
+    };
+  }
+}
+
+/**
+ * Processes all files that are not TypeScript files in parallel
+ * 
+ * Checks the system's file descriptor limit and uses 80% of it to avoid running out of file descriptors
+ * Creates a promise pool and launches one analysis for each file in parallel
+ * When a slot frees up, the next file is launched
+ * Waits for the remaining work to complete
+ * 
+ * @param {Array<string>} files - Array of file paths
+ * @param {Object} allEvents - Collection to add events to
+ * @param {string} baseDir - Base directory for relative paths
+ * @param {Array} customFunctionSignatures - Custom function signatures to detect
+ */
+async function processFiles(files, allEvents, baseDir, customFunctionSignatures) {
+  // Default concurrency limit
+  let concurrencyLimit = 64;
+
+  // Detect soft file descriptor limit from the system using `ulimit -n` (POSIX shells)
+  try {
+    const stdout = execSync('sh -c "ulimit -n"', { encoding: 'utf8' }).trim();
+    if (stdout !== 'unlimited') {
+      const limit = parseInt(stdout, 10);
+      if (!Number.isNaN(limit) && limit > 0) {
+        // Use 80% of the limit to keep head-room for other descriptors
+        concurrencyLimit = Math.max(4, Math.floor(limit * 0.8));
+      }
+    }
+  } catch (_) {}
+
+  let next = 0;                   // index of the next file to start
+  const inFlight = new Set();     // promises currently running
+
+  // helper: launch one analysis and wire bookkeeping
+  const launch = (file) => {
+    const p = analyzeFile(file, customFunctionSignatures)
+      .then((events) => {
+        if (events) events.forEach(e => addEventToCollection(allEvents, e, baseDir))
+      })
+      .finally(() => inFlight.delete(p));
+    inFlight.add(p);
+  }
+
+  // prime the pool
+  while (next < Math.min(concurrencyLimit, files.length)) {
+    launch(files[next++]);
+  }
+
+  // whenever a slot frees up, start the next file
+  while (next < files.length) {
+    await Promise.race(inFlight); // wait for one to finish
+    launch(files[next++]);        // and immediately fill the slot
+  }
+
+  // wait for the remaining work
+  await Promise.all(inFlight);
+}
+
+/**
+ * Analyze a directory recursively for analytics tracking calls
+ * 
+ * This function scans all supported files in a directory tree and identifies analytics tracking calls,
+ * handling different file types appropriately.
+ * 
+ * @param {string} dirPath - Path to the directory to analyze
+ * @param {Array<string>} [customFunctions=null] - Array of custom tracking function signatures to detect
+ * @returns {Promise<Object>} Object mapping event names to their tracking implementations
+ */
 async function analyzeDirectory(dirPath, customFunctions) {
   const allEvents = {};
 
-  const customFunctionSignatures = (customFunctions && customFunctions?.length > 0) ? customFunctions.map(parseCustomFunctionSignature) : null;
+  const customFunctionSignatures = (customFunctions?.length > 0) 
+    ? customFunctions.map(parseCustomFunctionSignature) 
+    : null;
 
   const files = getAllFiles(dirPath);
-
+  
+  // Separate TypeScript files from others for optimized processing
+  const tsFiles = [];
+  const nonTsFiles = [];
+  const rubyFiles = [];
+  
   for (const file of files) {
-    let events = [];
-
-    const isJsFile = /\.(jsx?)$/.test(file);
     const isTsFile = /\.(tsx?)$/.test(file);
-    const isPythonFile = /\.(py)$/.test(file);
-    const isRubyFile = /\.(rb)$/.test(file);
-    const isGoFile = /\.(go)$/.test(file);
-
-    if (isJsFile) {
-      events = analyzeJsFile(file, customFunctionSignatures);
-    } else if (isTsFile) {
-      // Pass null program so analyzeTsFile will create a per-file program using the file's nearest tsconfig.json
-      events = analyzeTsFile(file, null, customFunctionSignatures);
-    } else if (isPythonFile) {
-      events = await analyzePythonFile(file, customFunctionSignatures);
-    } else if (isRubyFile) {
-      events = await analyzeRubyFile(file, customFunctionSignatures);
-    } else if (isGoFile) {
-      events = await analyzeGoFile(file, customFunctionSignatures);
+    if (isTsFile) {
+      tsFiles.push(file);
     } else {
-      continue;
+      nonTsFiles.push(file);
+      if (/\.rb$/.test(file)) {
+        rubyFiles.push(file);
+      }
     }
+  }
 
-    events.forEach((event) => {
-      const relativeFilePath = path.relative(dirPath, event.filePath);
-
-      if (!allEvents[event.eventName]) {
-        allEvents[event.eventName] = {
-          implementations: [{
-            path: relativeFilePath,
-            line: event.line,
-            function: event.functionName,
-            destination: event.source
-          }],
-          properties: event.properties,
-        };
-      } else {
-        allEvents[event.eventName].implementations.push({
-          path: relativeFilePath,
-          line: event.line,
-          function: event.functionName,
-          destination: event.source
-        });
-
-        allEvents[event.eventName].properties = {
-          ...allEvents[event.eventName].properties,
-          ...event.properties,
-        };
-      }
-    });
+  // Prebuild constant maps for all Ruby directories to ensure constant resolution across files
+  if (rubyFiles.length > 0) {
+    await prebuildConstantMaps(rubyFiles);
+  }
+
+  // First process non-TypeScript files
+  await processFiles(nonTsFiles, allEvents, dirPath, customFunctionSignatures);
+
+  // Process TypeScript files with optimized batch processing
+  if (tsFiles.length > 0) {
+    const tsEvents = analyzeTsFiles(tsFiles, customFunctionSignatures);
+    tsEvents.forEach(event => addEventToCollection(allEvents, event, dirPath));
   }
 
   return allEvents;

package/src/analyze/javascript/extractors/event-extractor.js

@@ -161,11 +161,18 @@ function extractCustomEvent(node, constantMap, customConfig) {
 function processEventData(eventData, source, filePath, line, functionName, customConfig) {
   const { eventName, propertiesNode } = eventData;
 
-  if (!eventName || !propertiesNode || propertiesNode.type !== NODE_TYPES.OBJECT_EXPRESSION) {
+  // Must at least have an event name – properties are optional.
+  if (!eventName) {
     return null;
   }
 
-  let properties = extractProperties(propertiesNode);
+  // Default to empty properties when none are supplied.
+  let properties = {};
+
+  // Only attempt extraction when we have a literal object expression.
+  if (propertiesNode && propertiesNode.type === NODE_TYPES.OBJECT_EXPRESSION) {
+    properties = extractProperties(propertiesNode);
+  }
 
   // Handle custom extra params
   if (source === 'custom' && customConfig && eventData.extraArgs) {

package/src/analyze/javascript/utils/function-finder.js

@@ -12,16 +12,74 @@ const { NODE_TYPES } = require('../constants');
  * @returns {string} The function name or 'global' if not in a function
  */
 function findWrappingFunction(node, ancestors) {
+  const REACT_HOOKS = new Set([
+    'useEffect',
+    'useLayoutEffect',
+    'useInsertionEffect',
+    'useCallback',
+    'useMemo',
+    'useReducer',
+    'useState',
+    'useImperativeHandle',
+    'useDeferredValue',
+    'useTransition'
+  ]);
+
+  let hookName = null; // e.g. "useEffect" or "useCallback(handleFoo)"
+  let componentName = null;
+  let firstNonHookFunction = null;
+
   // Traverse ancestors from closest to furthest
   for (let i = ancestors.length - 1; i >= 0; i--) {
     const current = ancestors[i];
-    const functionName = extractFunctionName(current, node, ancestors[i - 1]);
-    
-    if (functionName) {
-      return functionName;
+
+    // Detect React hook call (CallExpression with Identifier callee)
+    if (!hookName && current.type === NODE_TYPES.CALL_EXPRESSION && current.callee && current.callee.type === NODE_TYPES.IDENTIFIER && REACT_HOOKS.has(current.callee.name)) {
+      hookName = current.callee.name; // store plain hook name; we'll format later if needed
+    }
+
+    // Existing logic to extract named function contexts
+    const fnName = extractFunctionName(current, node, ancestors[i - 1]);
+    if (fnName) {
+      if (REACT_HOOKS.has(stripParens(fnName.split('.')[0]))) {
+        // fnName itself is a hook signature like "useCallback(handleFoo)" or "useEffect()"
+        if (!hookName) hookName = fnName;
+        continue;
+      }
+
+      // First non-hook function up the tree is treated as component/container name
+      if (!componentName) {
+        componentName = fnName;
+      }
+
+      // Early exit when we already have both pieces
+      if (hookName && componentName) {
+        break;
+      }
+
+      // Save first non-hook function for fallback when no hook detected
+      if (!firstNonHookFunction) {
+        firstNonHookFunction = fnName;
+      }
     }
   }
-  
+
+  // If we detected hook + component, compose them
+  if (hookName && componentName) {
+    const formattedHook = typeof hookName === 'string' && hookName.endsWith('()') ? hookName.slice(0, -2) : hookName;
+    return `${componentName}.${formattedHook}`;
+  }
+
+  // If only hook signature found (no component) – return the hook signature itself
+  if (hookName) {
+    return hookName;
+  }
+
+  // Fallbacks to previous behaviour
+  if (firstNonHookFunction) {
+    return firstNonHookFunction;
+  }
+
   return 'global';
 }
 
@@ -118,6 +176,13 @@ function isFunctionNode(node) {
   );
 }
 
+/**
+ * Utility to strip trailing parens from simple hook signatures
+ */
+function stripParens(name) {
+  return name.endsWith('()') ? name.slice(0, -2) : name;
+}
+
 module.exports = {
   findWrappingFunction
 };

package/src/analyze/python/index.js

@@ -8,6 +8,19 @@ const path = require('path');
 
 // Singleton instance of Pyodide
 let pyodide = null;
+// Cache indicator to ensure we load pythonTrackingAnalyzer.py only once per process
+let pythonAnalyzerLoaded = false;
+
+// Simple mutex to ensure calls into the single Pyodide interpreter are serialized
+let pyodideLock = Promise.resolve();
+
+async function withPyodide(callback) {
+  // Chain the callback onto the existing lock promise
+  const resultPromise = pyodideLock.then(callback, callback);
+  // Replace lock with a promise that resolves when current callback finishes
+  pyodideLock = resultPromise.then(() => {}, () => {});
+  return resultPromise;
+}
 
 /**
  * Initialize Pyodide runtime lazily
@@ -69,36 +82,42 @@ async function analyzePythonFile(filePath, customFunctionSignatures = null) {
     // Read the Python file only once
     const code = fs.readFileSync(filePath, 'utf8');
 
-    // Initialize Pyodide if not already done
-    const py = await initPyodide();
+    // All interaction with Pyodide must be serialized to avoid race conditions
+    const events = await withPyodide(async () => {
+      // Initialize Pyodide if not already done
+      const py = await initPyodide();
 
-    // Load the Python analyzer code (idempotent – redefining functions is fine)
-    const analyzerPath = path.join(__dirname, 'pythonTrackingAnalyzer.py');
-    if (!fs.existsSync(analyzerPath)) {
-      throw new Error(`Python analyzer not found at: ${analyzerPath}`);
-    }
-    const analyzerCode = fs.readFileSync(analyzerPath, 'utf8');
-    // Prevent the analyzer from executing any __main__ blocks that expect CLI usage
-    py.globals.set('__name__', null);
-    py.runPython(analyzerCode);
+      // Load the analyzer definitions into the Pyodide runtime once
+      if (!pythonAnalyzerLoaded) {
+        const analyzerPath = path.join(__dirname, 'pythonTrackingAnalyzer.py');
+        if (!fs.existsSync(analyzerPath)) {
+          throw new Error(`Python analyzer not found at: ${analyzerPath}`);
+        }
+        const analyzerCode = fs.readFileSync(analyzerPath, 'utf8');
+        // Prevent the analyzer from executing any __main__ blocks that expect CLI usage
+        py.globals.set('__name__', null);
+        py.runPython(analyzerCode);
+        pythonAnalyzerLoaded = true;
+      }
 
-    // Helper to run analysis with a given custom config (can be null)
-    const runAnalysis = (customConfig) => {
-      py.globals.set('code', code);
-      py.globals.set('filepath', filePath);
-      py.globals.set('custom_config_json', customConfig ? JSON.stringify(customConfig) : null);
-      py.runPython('import json');
-      py.runPython('custom_config = None if custom_config_json == None else json.loads(custom_config_json)');
-      const result = py.runPython('analyze_python_code(code, filepath, custom_config)');
-      return JSON.parse(result);
-    };
+      // Helper to run analysis with a given custom config (can be null)
+      const runAnalysis = (customConfig) => {
+        py.globals.set('code', code);
+        py.globals.set('filepath', filePath);
+        py.globals.set('custom_config_json', customConfig ? JSON.stringify(customConfig) : null);
+        py.runPython('import json');
+        py.runPython('custom_config = None if custom_config_json == None else json.loads(custom_config_json)');
+        const result = py.runPython('analyze_python_code(code, filepath, custom_config)');
+        return JSON.parse(result);
+      };
 
-    // Prepare config argument (array or null)
-    const configArg = Array.isArray(customFunctionSignatures) && customFunctionSignatures.length > 0
-      ? customFunctionSignatures
-      : null;
+      // Prepare config argument (array or null)
+      const configArg = Array.isArray(customFunctionSignatures) && customFunctionSignatures.length > 0
+        ? customFunctionSignatures
+        : null;
 
-    const events = runAnalysis(configArg);
+      return runAnalysis(configArg);
+    });
 
     return events;
   } catch (error) {

package/src/analyze/ruby/extractors.js

@@ -105,7 +105,7 @@ async function extractEventName(node, source, customConfig = null, constantMap =
  * @param {Object} customConfig - Custom configuration for custom functions
  * @returns {Object|null} - The extracted properties or null
  */
-async function extractProperties(node, source, customConfig = null) {
+async function extractProperties(node, source, customConfig = null, variableMap = null) {
   const { HashNode, ArrayNode } = await prismPromise;
 
   if (source === 'segment' || source === 'rudderstack') {
@@ -248,6 +248,20 @@ async function extractProperties(node, source, customConfig = null) {
     if (propsArg instanceof HashNode) {
       const hashProps = await extractHashProperties(propsArg);
       Object.assign(properties, hashProps);
+    } else {
+      // Attempt to resolve variable references (e.g., a local variable containing a hash)
+      const prism = await prismPromise;
+      const LocalVariableReadNode = prism.LocalVariableReadNode;
+
+      if (variableMap && LocalVariableReadNode && propsArg instanceof LocalVariableReadNode) {
+        const varName = propsArg.name;
+        if (variableMap[varName]) {
+          Object.assign(properties, variableMap[varName]);
+        }
+      } else if (variableMap && propsArg && typeof propsArg.name === 'string' && variableMap[propsArg.name]) {
+        // Fallback: match by variable name when node type isn't LocalVariableReadNode
+        Object.assign(properties, variableMap[propsArg.name]);
+      }
     }
 
     return Object.keys(properties).length > 0 ? properties : null;

package/src/analyze/ruby/index.js

@@ -7,6 +7,9 @@ const fs = require('fs');
 const path = require('path');
 const TrackingVisitor = require('./visitor');
 
+// New: cache constant maps so we don't rebuild for every file in the same directory
+const constantMapCache = {};
+
 // Lazy-loaded parse function from Ruby Prism
 let parse = null;
 
@@ -143,12 +146,21 @@ async function buildConstantMapForDirectory(directory) {
 
   if (!fs.existsSync(directory)) return constantMap;
 
+  // Return cached version if we've already built the map for this directory
+  if (constantMapCache[directory]) {
+    return constantMapCache[directory];
+  }
+
   const files = fs.readdirSync(directory).filter(f => f.endsWith('.rb'));
 
   for (const file of files) {
     const fullPath = path.join(directory, file);
     try {
       const content = fs.readFileSync(fullPath, 'utf8');
+      if (!parse) {
+        const { loadPrism } = await import('@ruby/prism');
+        parse = await loadPrism();
+      }
       const ast = await parse(content);
       await collectConstants(ast.value, [], constantMap);
     } catch (err) {
@@ -157,6 +169,8 @@ async function buildConstantMapForDirectory(directory) {
     }
   }
 
+  // Cache the result before returning so subsequent look-ups are instantaneous
+  constantMapCache[directory] = constantMap;
   return constantMap;
 }
 
@@ -182,6 +196,13 @@ async function analyzeRubyFile(filePath, customFunctionSignatures = null) {
     const currentDir = path.dirname(filePath);
     const constantMap = await buildConstantMapForDirectory(currentDir);
 
+    // Merge constants from all cached maps (to allow cross-directory resolution)
+    for (const dir in constantMapCache) {
+      if (dir !== currentDir) {
+        Object.assign(constantMap, constantMapCache[dir]);
+      }
+    }
+
     // Parse the Ruby code into an AST once
     let ast;
     try {
@@ -191,8 +212,14 @@ async function analyzeRubyFile(filePath, customFunctionSignatures = null) {
       return [];
     }
 
-    // Single visitor pass covering all custom configs, with constant map for resolution
-    const visitor = new TrackingVisitor(code, filePath, customFunctionSignatures || [], constantMap);
+    // Collect variable assignments to hash literals within the file
+    const variableMap = {};
+    try {
+      await collectVariableAssignments(ast.value, variableMap);
+    } catch (_) {}
+
+    // Single visitor pass covering all custom configs, with constant map and variable map for resolution
+    const visitor = new TrackingVisitor(code, filePath, customFunctionSignatures || [], constantMap, variableMap);
     const events = await visitor.analyze(ast);
 
     // Deduplicate events
@@ -210,4 +237,73 @@ async function analyzeRubyFile(filePath, customFunctionSignatures = null) {
   }
 }
 
-module.exports = { analyzeRubyFile };
+// New utility: collect local variable assignments that point to hash literals
+async function collectVariableAssignments(node, variableMap) {
+  if (!node) return;
+
+  const prism = await import('@ruby/prism');
+  const LocalVariableWriteNode = prism.LocalVariableWriteNode;
+  const HashNode = prism.HashNode;
+  const CallNode = prism.CallNode;
+
+  if (LocalVariableWriteNode && node instanceof LocalVariableWriteNode) {
+    if (node.value instanceof HashNode) {
+      const varName = node.name;
+      // Reuse existing extractor to turn HashNode into properties object
+      const { extractHashProperties } = require('./extractors');
+      const props = await extractHashProperties(node.value);
+      variableMap[varName] = props;
+    } else if (node.value instanceof CallNode) {
+      // Handle patterns like { ... }.compact or { ... }.compact!
+      const callNode = node.value;
+      const methodName = callNode.name;
+
+      // Check if the call is a compact/compact! call with a Hash receiver
+      if ((methodName === 'compact' || methodName === 'compact!') && callNode.receiver instanceof HashNode) {
+        const varName = node.name;
+        const { extractHashProperties } = require('./extractors');
+        const props = await extractHashProperties(callNode.receiver);
+        variableMap[varName] = props;
+      }
+    }
+  }
+
+  // Recurse similarly to collectConstants generic traversal
+  const keys = Object.keys(node);
+  for (const key of keys) {
+    const val = node[key];
+    if (!val) continue;
+
+    const traverseChild = async (child) => {
+      if (child && typeof child === 'object' && (child.location || child.constructor?.name?.endsWith('Node'))) {
+        await collectVariableAssignments(child, variableMap);
+      }
+    };
+
+    if (Array.isArray(val)) {
+      for (const c of val) {
+        await traverseChild(c);
+      }
+    } else {
+      await traverseChild(val);
+    }
+  }
+}
+
+// Helper to prebuild constant maps for all discovered ruby directories in a project
+async function prebuildConstantMaps(rubyFiles) {
+  const dirs = new Set(rubyFiles.map(f => path.dirname(f)));
+  for (const dir of dirs) {
+    try {
+      await buildConstantMapForDirectory(dir);
+    } catch (_) {
+      // ignore
+    }
+  }
+}
+
+module.exports = { 
+  analyzeRubyFile,
+  buildConstantMapForDirectory,
+  prebuildConstantMaps
+};

package/src/analyze/ruby/visitor.js

@@ -8,11 +8,12 @@ const { extractEventName, extractProperties } = require('./extractors');
 const { findWrappingFunction, traverseNode, getLineNumber } = require('./traversal');
 
 class TrackingVisitor {
-  constructor(code, filePath, customConfigs = [], constantMap = {}) {
+  constructor(code, filePath, customConfigs = [], constantMap = {}, variableMap = {}) {
     this.code = code;
     this.filePath = filePath;
     this.customConfigs = Array.isArray(customConfigs) ? customConfigs : [];
     this.constantMap = constantMap || {};
+    this.variableMap = variableMap || {};
     this.events = [];
   }
 
@@ -48,16 +49,10 @@ class TrackingVisitor {
 
       const line = getLineNumber(this.code, node.location);
       
-      // For module-scoped custom functions, use the custom function name as the functionName
-      // For simple custom functions, use the wrapping function name
-      let functionName;
-      if (source === 'custom' && matchedConfig && matchedConfig.functionName.includes('.')) {
-        functionName = matchedConfig.functionName;
-      } else {
-        functionName = await findWrappingFunction(node, ancestors);
-      }
+      // Always use the enclosing method/block/global context for the function name
+      const functionName = await findWrappingFunction(node, ancestors);
       
-      const properties = await extractProperties(node, source, matchedConfig);
+      const properties = await extractProperties(node, source, matchedConfig, this.variableMap);
 
       this.events.push({
         eventName,

package/src/analyze/typescript/extractors/event-extractor.js

@@ -186,26 +186,25 @@ function extractDefaultEvent(node, checker, sourceFile) {
 function processEventData(eventData, source, filePath, line, functionName, checker, sourceFile, customConfig) {
   const { eventName, propertiesNode } = eventData;
 
-  if (!eventName || !propertiesNode) {
+  // Require an event name – properties are optional.
+  if (!eventName) {
     return null;
   }
 
-  let properties = null;
+  let properties = {};
 
-  // Check if properties is an object literal
-  if (ts.isObjectLiteralExpression(propertiesNode)) {
-    properties = extractProperties(checker, propertiesNode);
-  }
-  // Check if properties is an identifier (variable reference)
-  else if (ts.isIdentifier(propertiesNode)) {
-    const resolvedNode = resolveIdentifierToInitializer(checker, propertiesNode, sourceFile);
-    if (resolvedNode && ts.isObjectLiteralExpression(resolvedNode)) {
-      properties = extractProperties(checker, resolvedNode);
+  if (propertiesNode) {
+    // Check if properties is an object literal
+    if (ts.isObjectLiteralExpression(propertiesNode)) {
+      properties = extractProperties(checker, propertiesNode);
+    }
+    // Check if properties is an identifier (variable reference)
+    else if (ts.isIdentifier(propertiesNode)) {
+      const resolvedNode = resolveIdentifierToInitializer(checker, propertiesNode, sourceFile);
+      if (resolvedNode && ts.isObjectLiteralExpression(resolvedNode)) {
+        properties = extractProperties(checker, resolvedNode);
+      }
     }
-  }
-
-  if (!properties) {
-    return null;
   }
 
   // Special handling for Snowplow: remove 'action' from properties

package/src/analyze/typescript/index.js

@@ -3,40 +3,130 @@
  * @module analyze/typescript
  */
 
-const { getProgram, findTrackingEvents, ProgramError, SourceFileError } = require('./parser');
+const { getProgram, findTrackingEvents, ProgramError, SourceFileError, DEFAULT_COMPILER_OPTIONS } = require('./parser');
+const ts = require('typescript');
+const path = require('path');
+
+/**
+ * Creates a standalone TypeScript program for a single file
+ * This is used as a fallback when the main program can't resolve the file
+ * @param {string} filePath - Path to the TypeScript file
+ * @returns {Object} TypeScript program
+ */
+function createStandaloneProgram(filePath) {
+  const compilerOptions = {
+    ...DEFAULT_COMPILER_OPTIONS,
+    // We intentionally allow module resolution here so that imported constants
+    // (e.g. event name strings defined in a sibling file) can be followed by the
+    // TypeScript compiler.
+    isolatedModules: true
+  };
+  
+  return ts.createProgram([filePath], compilerOptions);
+}
+
+/**
+ * Deduplicates events based on source, eventName, line, and functionName
+ * @param {Array<Object>} events - Array of events to deduplicate
+ * @returns {Array<Object>} Deduplicated events
+ */
+function deduplicateEvents(events) {
+  const uniqueEvents = new Map();
+  
+  for (const event of events) {
+    const key = `${event.source}|${event.eventName}|${event.line}|${event.functionName}`;
+    if (!uniqueEvents.has(key)) {
+      uniqueEvents.set(key, event);
+    }
+  }
+  
+  return Array.from(uniqueEvents.values());
+}
+
+/**
+ * Attempts to analyze a file using a standalone program as fallback
+ * @param {string} filePath - Path to the TypeScript file
+ * @param {Array} customFunctionSignatures - Custom function signatures to detect
+ * @returns {Array<Object>} Array of events or empty array if failed
+ */
+function tryStandaloneAnalysis(filePath, customFunctionSignatures) {
+  try {
+    console.warn(`Unable to resolve ${filePath} in main program. Attempting standalone analysis.`);
+    
+    const standaloneProgram = createStandaloneProgram(filePath);
+    const sourceFile = standaloneProgram.getSourceFile(filePath);
+    
+    if (!sourceFile) {
+      console.warn(`Standalone analysis failed: could not get source file for ${filePath}`);
+      return [];
+    }
+    
+    const checker = standaloneProgram.getTypeChecker();
+    const events = findTrackingEvents(sourceFile, checker, filePath, customFunctionSignatures || []);
+    
+    return deduplicateEvents(events);
+  } catch (standaloneError) {
+    console.warn(`Standalone analysis failed for ${filePath}: ${standaloneError.message}`);
+    return [];
+  }
+}
+
+/**
+ * Gets or creates a cached TypeScript program for efficient reuse
+ * @param {string} filePath - Path to the TypeScript file
+ * @param {Map} programCache - Map of tsconfig paths to programs
+ * @returns {Object} TypeScript program
+ */
+function getCachedTsProgram(filePath, programCache) {
+  // Locate nearest tsconfig.json (may be undefined)
+  const searchPath = path.dirname(filePath);
+  const configPath = ts.findConfigFile(searchPath, ts.sys.fileExists, 'tsconfig.json');
+
+  // We only cache when a tsconfig.json exists because the resulting program
+  // represents an entire project.  If no config is present we build a
+  // stand-alone program that should not be reused for other files – otherwise
+  // later files would be missing from the program (which is precisely what
+  // caused the regression we are fixing).
+  const shouldCache = Boolean(configPath);
+  const cacheKey = configPath; // undefined when shouldCache is false
+
+  if (shouldCache && programCache.has(cacheKey)) {
+    return programCache.get(cacheKey);
+  }
+
+  const program = getProgram(filePath, null);
+
+  if (shouldCache) {
+    programCache.set(cacheKey, program);
+  }
+
+  return program;
+}
 
 /**
  * Analyzes a TypeScript file for analytics tracking calls
  * @param {string} filePath - Path to the TypeScript file to analyze
  * @param {Object} [program] - Optional existing TypeScript program to reuse
- * @param {string} [customFunctionSignature] - Optional custom function signature to detect
+ * @param {Array} [customFunctionSignatures] - Optional custom function signatures to detect
  * @returns {Array<Object>} Array of tracking events found in the file
  */
 function analyzeTsFile(filePath, program = null, customFunctionSignatures = null) {
   try {
-    // Get or create TypeScript program (only once)
+    // Get or create TypeScript program
     const tsProgram = getProgram(filePath, program);
 
     // Get source file from program
     const sourceFile = tsProgram.getSourceFile(filePath);
     if (!sourceFile) {
-      throw new SourceFileError(filePath);
+      // Try standalone analysis as fallback
+      return tryStandaloneAnalysis(filePath, customFunctionSignatures);
     }
 
-    // Get type checker
+    // Get type checker and find tracking events
     const checker = tsProgram.getTypeChecker();
-
-    // Single-pass collection covering built-in + all custom configs
     const events = findTrackingEvents(sourceFile, checker, filePath, customFunctionSignatures || []);
 
-    // Deduplicate events
-    const unique = new Map();
-    for (const evt of events) {
-      const key = `${evt.source}|${evt.eventName}|${evt.line}|${evt.functionName}`;
-      if (!unique.has(key)) unique.set(key, evt);
-    }
-
-    return Array.from(unique.values());
+    return deduplicateEvents(events);
 
   } catch (error) {
     if (error instanceof ProgramError) {
@@ -46,9 +136,37 @@ function analyzeTsFile(filePath, program = null, customFunctionSignatures = null
     } else {
       console.error(`Error analyzing TypeScript file ${filePath}: ${error.message}`);
     }
+
+    return [];
   }
+}
 
-  return [];
+/**
+ * Analyzes multiple TypeScript files with program reuse for better performance
+ * @param {Array<string>} tsFiles - Array of TypeScript file paths
+ * @param {Array} customFunctionSignatures - Custom function signatures to detect
+ * @returns {Array<Object>} Array of all tracking events found across all files
+ */
+function analyzeTsFiles(tsFiles, customFunctionSignatures) {
+  const allEvents = [];
+  const tsProgramCache = new Map(); // tsconfig path -> program
+  
+  for (const file of tsFiles) {
+    try {
+      // Use cached program or create new one
+      const program = getCachedTsProgram(file, tsProgramCache);
+      const events = analyzeTsFile(file, program, customFunctionSignatures);
+      
+      allEvents.push(...events);
+    } catch (error) {
+      console.warn(`Error processing TypeScript file ${file}: ${error.message}`);
+    }
+  }
+  
+  return allEvents;
 }
 
-module.exports = { analyzeTsFile };
+module.exports = { 
+  analyzeTsFile,
+  analyzeTsFiles
+};

package/src/analyze/typescript/parser.js

@@ -32,6 +32,103 @@ class SourceFileError extends Error {
   }
 }
 
+/**
+ * Default TypeScript compiler options for analysis
+ */
+const DEFAULT_COMPILER_OPTIONS = {
+  target: ts.ScriptTarget.Latest,
+  module: ts.ModuleKind.CommonJS,
+  allowJs: true,
+  checkJs: false,
+  noEmit: true,
+  jsx: ts.JsxEmit.Preserve,
+  moduleResolution: ts.ModuleResolutionKind.NodeJs,
+  allowSyntheticDefaultImports: true,
+  esModuleInterop: true,
+  skipLibCheck: true
+};
+
+/**
+ * Maximum number of files to include in TypeScript program for performance
+ */
+const MAX_FILES_THRESHOLD = 10000;
+
+/**
+ * Attempts to parse tsconfig.json and extract compiler options and file names
+ * @param {string} configPath - Path to tsconfig.json
+ * @returns {Object|null} Parsed config with options and fileNames, or null if failed
+ */
+function parseTsConfig(configPath) {
+  try {
+    const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (readResult.error || !readResult.config) {
+      return null;
+    }
+
+    const parseResult = ts.parseJsonConfigFileContent(
+      readResult.config,
+      ts.sys,
+      path.dirname(configPath)
+    );
+
+    if (parseResult.errors && parseResult.errors.length > 0) {
+      return null;
+    }
+
+    return {
+      options: parseResult.options,
+      fileNames: parseResult.fileNames
+    };
+  } catch (error) {
+    console.warn(`Failed to parse tsconfig.json at ${configPath}. Error: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Determines the appropriate files to include in the TypeScript program
+ * @param {string} filePath - Target file path
+ * @param {string|null} configPath - Path to tsconfig.json if found
+ * @returns {Object} Configuration with compilerOptions and rootNames
+ */
+function getProgramConfiguration(filePath, configPath) {
+  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
+  let rootNames = [filePath];
+
+  if (!configPath) {
+    return { compilerOptions, rootNames };
+  }
+
+  const config = parseTsConfig(configPath);
+  if (!config) {
+    console.warn(`Failed to parse tsconfig.json at ${configPath}. Analyzing ${filePath} in isolation.`);
+    return { compilerOptions, rootNames };
+  }
+
+  // Inherit compiler options from tsconfig
+  compilerOptions = { ...compilerOptions, ...config.options };
+
+  // Determine file inclusion strategy based on project size
+  const projectFileCount = config.fileNames.length;
+
+  if (projectFileCount > 0 && projectFileCount <= MAX_FILES_THRESHOLD) {
+    // Small to medium project: include all files for better type checking
+    rootNames = [...config.fileNames];
+    if (!rootNames.includes(filePath)) {
+      rootNames.push(filePath);
+    }
+  } else if (projectFileCount > MAX_FILES_THRESHOLD) {
+    // Large project: only include the target file to avoid performance issues
+    console.warn(
+      `Large TypeScript project detected (${projectFileCount} files). ` +
+      `Analyzing ${filePath} in isolation for performance.`
+    );
+    rootNames = [filePath];
+  }
+
+  return { compilerOptions, rootNames };
+}
+
 /**
  * Gets or creates a TypeScript program for analysis
  * @param {string} filePath - Path to the TypeScript file
@@ -45,38 +142,15 @@ function getProgram(filePath, existingProgram) {
   }
 
   try {
-    // Try to locate a tsconfig.json nearest to the file to inherit compiler options (important for path aliases)
+    // Find the nearest tsconfig.json
     const searchPath = path.dirname(filePath);
     const configPath = ts.findConfigFile(searchPath, ts.sys.fileExists, 'tsconfig.json');
 
-    let compilerOptions = {
-      target: ts.ScriptTarget.Latest,
-      module: ts.ModuleKind.CommonJS,
-      allowJs: true,
-      checkJs: false,
-      noEmit: true,
-      jsx: ts.JsxEmit.Preserve
-    };
-    let rootNames = [filePath];
-
-    if (configPath) {
-      // Read and parse the tsconfig.json
-      const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
-      if (!readResult.error && readResult.config) {
-        const parseResult = ts.parseJsonConfigFileContent(
-          readResult.config,
-          ts.sys,
-          path.dirname(configPath)
-        );
-        if (!parseResult.errors || parseResult.errors.length === 0) {
-          compilerOptions = { ...compilerOptions, ...parseResult.options };
-          rootNames = parseResult.fileNames.length > 0 ? parseResult.fileNames : rootNames;
-        }
-      }
-    }
+    // Get program configuration
+    const { compilerOptions, rootNames } = getProgramConfiguration(filePath, configPath);
 
-    const program = ts.createProgram(rootNames, compilerOptions);
-    return program;
+    // Create and return the TypeScript program
+    return ts.createProgram(rootNames, compilerOptions);
   } catch (error) {
     throw new ProgramError(filePath, error);
   }
@@ -94,27 +168,37 @@ function findTrackingEvents(sourceFile, checker, filePath, customConfigs = []) {
   const events = [];
 
   /**
-   * Helper to test if a CallExpression matches a custom function name.
-   * We simply rely on node.expression.getText() which preserves the fully qualified name.
+   * Tests if a CallExpression matches a custom function name
+   * @param {Object} callNode - The call expression node
+   * @param {string} functionName - Function name to match
+   * @returns {boolean} True if matches
    */
-  const matchesCustomFn = (callNode, fnName) => {
-    if (!fnName) return false;
+  function matchesCustomFunction(callNode, functionName) {
+    if (!functionName || !callNode.expression) {
+      return false;
+    }
+    
     try {
-      return callNode.expression && callNode.expression.getText() === fnName;
+      return callNode.expression.getText() === functionName;
     } catch {
       return false;
     }
-  };
+  }
 
+  /**
+   * Recursively visits AST nodes to find tracking calls
+   * @param {Object} node - Current AST node
+   */
   function visit(node) {
     try {
       if (ts.isCallExpression(node)) {
-        let matchedCustom = null;
+        let matchedCustomConfig = null;
 
+        // Check for custom function matches
         if (Array.isArray(customConfigs) && customConfigs.length > 0) {
-          for (const cfg of customConfigs) {
-            if (cfg && matchesCustomFn(node, cfg.functionName)) {
-              matchedCustom = cfg;
+          for (const config of customConfigs) {
+            if (config && matchesCustomFunction(node, config.functionName)) {
+              matchedCustomConfig = config;
               break;
             }
           }
@@ -125,9 +209,12 @@ function findTrackingEvents(sourceFile, checker, filePath, customConfigs = []) {
           sourceFile,
           checker,
           filePath,
-          matchedCustom /* may be null */
+          matchedCustomConfig
         );
-        if (event) events.push(event);
+        
+        if (event) {
+          events.push(event);
+        }
       }
 
       ts.forEachChild(node, visit);
@@ -137,7 +224,6 @@ function findTrackingEvents(sourceFile, checker, filePath, customConfigs = []) {
   }
 
   ts.forEachChild(sourceFile, visit);
-
   return events;
 }
 
@@ -172,5 +258,6 @@ module.exports = {
   getProgram,
   findTrackingEvents,
   ProgramError,
-  SourceFileError
+  SourceFileError,
+  DEFAULT_COMPILER_OPTIONS
 };

package/src/analyze/typescript/utils/function-finder.js

@@ -12,19 +12,61 @@ const { isReactHookCall } = require('./type-resolver');
  * @returns {string} The function name or 'global' if not in a function
  */
 function findWrappingFunction(node) {
+  // ts is already required at module scope
+  const REACT_HOOKS = new Set([
+    'useEffect',
+    'useLayoutEffect',
+    'useInsertionEffect',
+    'useCallback',
+    'useMemo',
+    'useReducer',
+    'useState',
+    'useImperativeHandle',
+    'useDeferredValue',
+    'useTransition'
+  ]);
+
   let current = node;
+  let hookSignature = null; // e.g. useEffect(), useCallback(handleFoo)
+  let componentName = null;
+  let firstNonHookFunction = null;
 
   while (current) {
-    const functionName = extractFunctionName(current);
-
-    if (functionName) {
-      return functionName;
+    const fnName = extractFunctionName(current);
+
+    if (fnName) {
+      const baseName = fnName.split('(')[0].replace(/\s+/g, '');
+      const isHookSig = REACT_HOOKS.has(baseName);
+
+      if (isHookSig && !hookSignature) {
+        hookSignature = fnName; // capture complete signature (may include params)
+        // Continue searching upward for component
+      } else if (!isHookSig && !componentName) {
+        componentName = fnName;
+        if (hookSignature) {
+          break; // we have both
+        }
+      }
+
+      if (!firstNonHookFunction) {
+        firstNonHookFunction = fnName;
+      }
     }
 
     current = current.parent;
   }
 
-  return 'global';
+  if (hookSignature && componentName) {
+    // Remove trailing () for useEffect etc
+    const formattedHook = hookSignature.endsWith('()') ? hookSignature.slice(0, -2) : hookSignature;
+    return `${componentName}.${formattedHook}`;
+  }
+
+  if (hookSignature) {
+    return hookSignature;
+  }
+
+  return firstNonHookFunction || 'global';
 }
 
 /**