@flisk/analyze-tracking 0.5.1 → 0.6.0

package/README.md

@@ -6,9 +6,9 @@ Automatically document your analytics setup by analyzing tracking code and gener
 
 
 ## Why Use @flisk/analyze-tracking?
-📊 **Understand Your Tracking** – Effortlessly analyze your codebase for `track` calls so you can see all your analytics events, properties, and triggers in one place. No more guessing what’s being tracked!
+📊 **Understand Your Tracking** – Effortlessly analyze your codebase for `track` calls so you can see all your analytics events, properties, and triggers in one place. No more guessing what's being tracked!
 
-🔍 **Auto-Document Events** – Generates a complete YAML schema that captures all events and properties, including where they’re implemented in your codebase.
+🔍 **Auto-Document Events** – Generates a complete YAML schema that captures all events and properties, including where they're implemented in your codebase.
 
 🕵️‍♂️ **Track Changes Over Time** – Easily spot unintended changes or ensure your analytics setup remains consistent across updates.
 
@@ -26,7 +26,7 @@ npx @flisk/analyze-tracking /path/to/project [options]
 ### Key Options:
 - `-g, --generateDescription`: Generate descriptions of fields (default: `false`)
 - `-p, --provider <provider>`: Specify a provider (options: `openai`, `gemini`)
-- `-m, --model <model>`: Specify a model (ex: `gpt-4o-mini`, `gemini-2.0-flash-lite-001`)
+- `-m, --model <model>`: Specify a model (ex: `gpt-4.1-nano`, `gpt-4o-mini`, `gemini-2.0-flash-lite-001`)
 - `-o, --output <output_file>`: Name of the output file (default: `tracking-schema.yaml`)
 - `-c, --customFunction <function_name>`: Specify a custom tracking function
 
@@ -46,9 +46,9 @@ npx @flisk/analyze-tracking /path/to/project [options]
 </details>
 
 
-## What’s Generated?
+## What's Generated?
 A clear YAML schema that shows where your events are tracked, their properties, and more.
-Here’s an example:
+Here's an example:
 
 ```yaml
 version: 1
@@ -71,18 +71,36 @@ events:
         type: <property_type>
 ```
 
-Use this to understand where your events live in the code and how they’re being tracked.
+Use this to understand where your events live in the code and how they're being tracked.
 
 Your LLM of choice is used for generating descriptions of events, properties, and implementations.
 
 See [schema.json](schema.json) for a JSON Schema of the output.
 
 
-## Supported tracking libraries
+## Supported tracking libraries & languages
+
+| Library | JavaScript/TypeScript | Python | Ruby |
+|---------|:---------------------:|:------:|:----:|
+| Google Analytics | ✅ | ❌ | ❌ |
+| Segment | ✅ | ✅ | ✅ |
+| Mixpanel | ✅ | ✅ | ✅ |
+| Amplitude | ✅ | ✅ | ❌ |
+| Rudderstack | ✅ | ✅ | ❌ |
+| mParticle | ✅ | ✅ | ❌ |
+| PostHog | ✅ | ✅ | ✅ |
+| Pendo | ✅ | ✅ | ❌ |
+| Heap | ✅ | ✅ | ❌ |
+| Snowplow | ✅ | ✅ | ✅ |
+| Custom Function | ✅ | ✅ | ✅ |
+
+
+## SDKs for supported libraries
 
 <details>
   <summary>Google Analytics</summary>
 
+  **JavaScript/TypeScript**
   ```js
   gtag('event', '<event_name>', {
     <event_parameters>
@@ -93,126 +111,245 @@ See [schema.json](schema.json) for a JSON Schema of the output.
 <details>
   <summary>Segment</summary>
 
+  **JavaScript/TypeScript**
   ```js
   analytics.track('<event_name>', {
     <event_parameters>
   });
   ```
+
+  **Python**
+  ```python
+  analytics.track('<event_name>', {
+    '<property_name>': '<property_value>'
+  })
+  ```
+
+  **Ruby**
+  ```ruby
+  Analytics.track(
+    event: '<event_name>',
+    properties: {
+      <event_parameters>
+    }
+  )
+  ```
 </details>
 
 <details>
   <summary>Mixpanel</summary>
 
+  **JavaScript/TypeScript**
   ```js
   mixpanel.track('<event_name>', {
     <event_parameters>
   });
   ```
+
+  **Python**
+  ```python
+  mixpanel.track('<event_name>', {
+    '<property_name>': '<property_value>'
+  })
+  ```
+
+  **Ruby**
+  ```ruby
+  tracker.track('distinct_id', '<event_name>', {
+    '<property_name>': '<property_value>'
+  })
+  ```
 </details>
 
 <details>
   <summary>Amplitude</summary>
 
+  **JavaScript/TypeScript**
   ```js
   amplitude.logEvent('<event_name>', {
     <event_parameters>
   });
   ```
+
+  **Python**
+  ```python
+  amplitude.track('<event_name>', {
+    '<property_name>': '<property_value>'
+  })
+  ```
 </details>
 
 <details>
   <summary>Rudderstack</summary>
 
+  **JavaScript/TypeScript**
   ```js
   rudderanalytics.track('<event_name>', {
     <event_parameters>
   });
   ```
+
+  **Python**
+  ```python
+  rudderanalytics.track('<event_name>', {
+    '<property_name>': '<property_value>'
+  })
+  ```
 </details>
 
 <details>
   <summary>mParticle</summary>
 
+  **JavaScript/TypeScript**
   ```js
   mParticle.logEvent('<event_name>', {
     <event_parameters>
   });
   ```
+
+  **Python**
+  ```python
+  mParticle.logEvent('<event_name>', {
+    '<property_name>': '<property_value>'
+  })
+  ```
 </details>
 
 <details>
   <summary>PostHog</summary>
 
+  **JavaScript/TypeScript**
   ```js
   posthog.capture('<event_name>', {
     <event_parameters>
   });
   ```
+
+  **Python**
+  ```python
+  posthog.capture(
+    'distinct_id',
+    '<event_name>',
+    {
+      '<property_name>': '<property_value>'
+    }
+  )
+  # Or
+  posthog.capture(
+    'distinct_id',
+    event='<event_name>',
+    properties={
+      '<property_name>': '<property_value>'
+    }
+  )
+  ```
+
+  **Ruby**
+  ```ruby
+  posthog.capture({
+    distinct_id: '<distinct_id>',
+    event: '<event_name>',
+    properties: {
+      '<property_name>': '<property_value>'
+    }
+  })
+  ```
 </details>
 
 <details>
   <summary>Pendo</summary>
 
+  **JavaScript/TypeScript**
   ```js
   pendo.track('<event_name>', {
     <event_parameters>
   });
   ```
+
+  **Python**
+  ```python
+  pendo.track('<event_name>', {
+    '<property_name>': '<property_value>'
+  })
+  ```
 </details>
 
 <details>
   <summary>Heap</summary>
 
+  **JavaScript/TypeScript**
   ```js
   heap.track('<event_name>', {
     <event_parameters>
   });
   ```
+
+  **Python**
+  ```python
+  heap.track('<event_name>', {
+    '<property_name>': '<property_value>'
+  })
+  ```
 </details>
 
 <details>
   <summary>Snowplow (struct events)</summary>
 
+  **JavaScript/TypeScript**
   ```js
   snowplow('trackStructEvent', {
     category: '<category>',
     action: '<action>',
     label: '<label>',
     property: '<property>',
-    value: '<value> '
+    value: '<value>'
   });
   ```
 
-  ```js
+  **Python**
+  ```python
+  # Direct tracking
   trackStructEvent({
-    category: '<category>',
-    action: '<action>',
-    label: '<label>',
-    property: '<property>',
-    value: '<value>'
-  });
+    'category': '<category>',
+    'action': '<action>',
+    'label': '<label>',
+    'property': '<property>',
+    'value': '<value>'
+  })
+  
+  # Builder pattern
+  buildStructEvent({
+    'category': '<category>',
+    'action': '<action>',
+    'label': '<label>',
+    'property': '<property>',
+    'value': '<value>'
+  })
+  
+  # Function call pattern
+  snowplow('trackStructEvent', {
+    'category': '<category>',
+    'action': '<action>',
+    'label': '<label>',
+    'property': '<property>',
+    'value': '<value>'
+  })
   ```
 
-  ```js
-  buildStructEvent({
+  **Ruby**
+  ```ruby
+  tracker.track_struct_event(
     category: '<category>',
     action: '<action>',
     label: '<label>',
     property: '<property>',
     value: '<value>'
-  });
+  )
   ```
 
   _Note: Snowplow Self Describing Events are coming soon!_
 </details>
 
 
-## Supported languages
-
-- JavaScript
-- TypeScript
-- Ruby (Experimental - only supports Segment for now)
-
-
 ## Contribute
-We’re actively improving this package. Found a bug? Want to request a feature? Open an issue or contribute directly!
+We're actively improving this package. Found a bug? Want to request a feature? Open an issue or contribute directly!

package/bin/help.js

@@ -57,10 +57,10 @@ const helpContent = [
       {
         name: 'model',
         alias: 'm',
-        description: 'Specify a model (ex: {italic gpt-4o-mini}, {italic gemini-2.0-flash-lite-001})',
+        description: 'Specify a model (ex: {italic gpt-4.1-nano, gpt-4o-mini}, {italic gemini-2.0-flash-lite-001})',
         type: String,
-        defaultValue: 'gpt-4o-mini',
-        typeLabel: '{underline gpt-4o-mini}'
+        defaultValue: 'gpt-4.1-nano',
+        typeLabel: '{underline gpt-4.1-nano}'
       },
       {
         name: 'output',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flisk/analyze-tracking",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Analyzes tracking code in a project and generates data schemas",
   "main": "src/index.js",
   "bin": {
@@ -20,9 +20,9 @@
   },
   "homepage": "https://github.com/fliskdata/analyze-tracking#readme",
   "dependencies": {
-    "@langchain/core": "^0.3.49",
-    "@langchain/google-vertexai": "^0.2.5",
-    "@langchain/openai": "^0.5.7",
+    "@langchain/core": "^0.3.56",
+    "@langchain/google-vertexai": "^0.2.9",
+    "@langchain/openai": "^0.5.10",
     "@ruby/prism": "^1.4.0",
     "@typescript-eslint/parser": "^8.1.0",
     "acorn": "^8.12.1",
@@ -33,6 +33,7 @@
     "command-line-usage": "^7.0.3",
     "isomorphic-git": "^1.27.1",
     "js-yaml": "^4.1.0",
+    "pyodide": "^0.27.6",
     "typescript": "^5.5.4",
     "zod": "^3.24.4"
   },

package/src/analyze/analyzePythonFile.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const path = require('path');
+
+let pyodide = null;
+
+async function initPyodide() {
+  if (!pyodide) {
+    const { loadPyodide } = await import('pyodide');
+    pyodide = await loadPyodide();
+    await pyodide.loadPackagesFromImports('import ast, json');
+  }
+  return pyodide;
+}
+
+async function analyzePythonFile(filePath, customFunction) {
+  try {
+    const code = fs.readFileSync(filePath, 'utf8');
+    const py = await initPyodide();
+    
+    // Read the Python analyzer code
+    const analyzerPath = path.join(__dirname, 'pythonTrackingAnalyzer.py');
+    const analyzerCode = fs.readFileSync(analyzerPath, 'utf8');
+    
+    // Add file content and analyzer code to Python environment
+    py.globals.set('code', code);
+    py.globals.set('filepath', filePath);
+    py.globals.set('custom_function', customFunction || null);
+    
+    // Run the Python analyzer
+    py.runPython(analyzerCode);
+    const result = py.runPython('analyze_python_code(code, filepath, custom_function)');
+    const events = JSON.parse(result);
+    
+    return events;
+  } catch (error) {
+    console.error(`Error analyzing Python file ${filePath}:`, error);
+    return [];
+  }
+}
+
+module.exports = { analyzePythonFile };

package/src/analyze/analyzeRubyFile.js

@@ -4,12 +4,13 @@ let parse = null;
 
 // Create a visitor to traverse the AST
 class TrackingVisitor {
-  constructor(code, filePath) {
+  constructor(code, filePath, customFunction=null) {
     this.code = code;
     this.lines = code.split('\n');
     this.ancestors = [];
     this.events = [];
     this.filePath = filePath;
+    this.customFunction = customFunction;
   }
 
   getLineNumber(location) {
@@ -40,13 +41,27 @@ class TrackingVisitor {
   detectSource(node) {
     if (!node) return null;
   
-    // Check for other analytics libraries
+    // Check for analytics libraries
     if (node.receiver) {
       const objectName = node.receiver.name;
       const methodName = node.name;
 
+      // Segment
       if (objectName === 'Analytics' && methodName === 'track') return 'segment';
+      
+      // Mixpanel (Ruby SDK uses Mixpanel::Tracker instance)
+      if (methodName === 'track' && node.receiver.type === 'CallNode' && 
+          node.receiver.name === 'tracker') return 'mixpanel';
+      
+      // PostHog
+      if (objectName === 'posthog' && methodName === 'capture') return 'posthog';
     }
+    
+    // Snowplow (typically tracker.track_struct_event)
+    if (node.name === 'track_struct_event') return 'snowplow';
+    
+    // Custom tracking function
+    if (this.customFunction && node.name === this.customFunction) return 'custom';
   
     return null;
   }
@@ -58,6 +73,38 @@ class TrackingVisitor {
       return eventProperty?.value?.unescaped?.value || null;
     }
 
+    if (source === 'mixpanel') {
+      // Mixpanel Ruby SDK format: tracker.track('distinct_id', 'event_name', {...})
+      const args = node.arguments_.arguments_;
+      if (args && args.length > 1 && args[1]?.unescaped?.value) {
+        return args[1].unescaped.value;
+      }
+    }
+
+    if (source === 'posthog') {
+      // PostHog Ruby SDK format: posthog.capture({distinct_id: '...', event: '...', properties: {...}})
+      const hashArg = node.arguments_.arguments_[0];
+      if (hashArg && hashArg.elements) {
+        const eventProperty = hashArg.elements.find(elem => elem?.key?.unescaped?.value === 'event');
+        return eventProperty?.value?.unescaped?.value || null;
+      }
+    }
+
+    if (source === 'snowplow') {
+      // Snowplow Ruby SDK: tracker.track_struct_event(category: '...', action: '...', ...)
+      const params = node.arguments_.arguments_[0].elements;
+      const actionProperty = params.find(param => param?.key?.unescaped?.value === 'action');
+      return actionProperty?.value?.unescaped?.value || null;
+    }
+    
+    if (source === 'custom') {
+      // Custom function format: customFunction('event_name', {...})
+      const args = node.arguments_.arguments_;
+      if (args && args.length > 0 && args[0]?.unescaped?.value) {
+        return args[0].unescaped.value;
+      }
+    }
+
     return null;
   }
 
@@ -106,6 +153,78 @@ class TrackingVisitor {
       return properties;
     }
 
+    if (source === 'mixpanel') {
+      // Mixpanel Ruby SDK: tracker.track('distinct_id', 'event_name', {properties})
+      const args = node.arguments_.arguments_;
+      const properties = {};
+      
+      // Add distinct_id as property
+      if (args && args.length > 0 && args[0]?.unescaped?.value) {
+        properties.distinct_id = {
+          type: 'string'
+        };
+      }
+      
+      // Extract properties from third argument if it exists
+      if (args && args.length > 2 && args[2] instanceof HashNode) {
+        const propsHash = await this.extractHashProperties(args[2]);
+        Object.assign(properties, propsHash);
+      }
+      
+      return properties;
+    }
+
+    if (source === 'posthog') {
+      // PostHog Ruby SDK: posthog.capture({distinct_id: '...', event: '...', properties: {...}})
+      const hashArg = node.arguments_.arguments_[0];
+      const properties = {};
+      
+      if (hashArg && hashArg.elements) {
+        // Extract distinct_id if present
+        const distinctIdProperty = hashArg.elements.find(elem => elem?.key?.unescaped?.value === 'distinct_id');
+        if (distinctIdProperty?.value) {
+          properties.distinct_id = {
+            type: await this.getValueType(distinctIdProperty.value)
+          };
+        }
+        
+        // Extract properties
+        const propsProperty = hashArg.elements.find(elem => elem?.key?.unescaped?.value === 'properties');
+        if (propsProperty?.value instanceof HashNode) {
+          const props = await this.extractHashProperties(propsProperty.value);
+          Object.assign(properties, props);
+        }
+      }
+      
+      return properties;
+    }
+
+    if (source === 'snowplow') {
+      // Snowplow Ruby SDK: tracker.track_struct_event(category: '...', action: '...', ...)
+      const params = node.arguments_.arguments_[0].elements;
+      const properties = {};
+      
+      // Extract all struct event parameters except 'action' (which is used as the event name)
+      for (const param of params) {
+        const key = param?.key?.unescaped?.value;
+        if (key && key !== 'action') {
+          properties[key] = {
+            type: await this.getValueType(param.value)
+          };
+        }
+      }
+      
+      return properties;
+    }
+    
+    if (source === 'custom') {
+      // Custom function format: customFunction('event_name', {properties})
+      const args = node.arguments_.arguments_;
+      if (args && args.length > 1 && args[1] instanceof HashNode) {
+        return await this.extractHashProperties(args[1]);
+      }
+    }
+
     return null;
   }
 
@@ -257,7 +376,7 @@ class TrackingVisitor {
   }
 }
 
-async function analyzeRubyFile(filePath) {
+async function analyzeRubyFile(filePath, customFunction) {
   // Lazy load the ruby prism parser
   if (!parse) {
     const { loadPrism } = await import('@ruby/prism');
@@ -275,7 +394,7 @@ async function analyzeRubyFile(filePath) {
     }
 
     // Traverse the AST starting from the program node
-    const visitor = new TrackingVisitor(code, filePath);
+    const visitor = new TrackingVisitor(code, filePath, customFunction);
     await visitor.visit(ast.value);
 
     return visitor.events;

package/src/analyze/index.js

@@ -3,6 +3,7 @@ const ts = require('typescript');
 const { getAllFiles } = require('../fileProcessor');
 const { analyzeJsFile } = require('./analyzeJsFile');
 const { analyzeTsFile } = require('./analyzeTsFile');
+const { analyzePythonFile } = require('./analyzePythonFile');
 const { analyzeRubyFile } = require('./analyzeRubyFile');
 
 async function analyzeDirectory(dirPath, customFunction) {
@@ -20,14 +21,17 @@ async function analyzeDirectory(dirPath, customFunction) {
 
     const isJsFile = /\.(jsx?)$/.test(file);
     const isTsFile = /\.(tsx?)$/.test(file);
+    const isPythonFile = /\.(py)$/.test(file);
     const isRubyFile = /\.(rb)$/.test(file);
 
     if (isJsFile) {
       events = analyzeJsFile(file, customFunction);
     } else if (isTsFile) {
       events = analyzeTsFile(file, tsProgram, customFunction);
+    } else if (isPythonFile) {
+      events = await analyzePythonFile(file, customFunction);
     } else if (isRubyFile) {
-      events = await analyzeRubyFile(file);
+      events = await analyzeRubyFile(file, customFunction);
     } else {
       console.info(`Skipping file ${file} because it is not a supported file type`);
       continue;

package/src/analyze/pythonTrackingAnalyzer.py

@@ -0,0 +1,439 @@
+import ast
+import json
+
+class TrackingVisitor(ast.NodeVisitor):
+    def __init__(self, filepath, custom_function=None):
+        self.events = []
+        self.filepath = filepath
+        self.current_function = 'global'
+        self.function_stack = []
+        # Track variable types in the current scope
+        self.var_types = {}
+        # Stack of variable type scopes
+        self.var_types_stack = []
+        # Custom tracking function name
+        self.custom_function = custom_function
+        
+    def visit_FunctionDef(self, node):
+        # Save previous function context and variable types
+        self.function_stack.append(self.current_function)
+        self.var_types_stack.append(self.var_types)
+        
+        # Create new scope for variable types
+        self.var_types = {}
+        self.current_function = node.name
+        
+        # Extract parameter type annotations
+        for arg in node.args.args:
+            if arg.annotation:
+                # Store the type annotation for this parameter
+                self.var_types[arg.arg] = self.extract_type_annotation(arg.annotation)
+        
+        # Visit children
+        self.generic_visit(node)
+        
+        # Restore function context and variable types
+        self.current_function = self.function_stack.pop()
+        self.var_types = self.var_types_stack.pop()
+    
+    def extract_type_annotation(self, annotation):
+        """Extract type information from a type annotation node"""
+        if isinstance(annotation, ast.Name):
+            # Simple types like int, str, bool
+            type_name = annotation.id
+            if type_name == 'int' or type_name == 'float':
+                return 'number'
+            elif type_name == 'str':
+                return 'string'
+            elif type_name == 'bool':
+                return 'boolean'
+            elif type_name == 'None' or type_name == 'NoneType':
+                return 'null'
+            # Could add more type mappings here
+        elif isinstance(annotation, ast.Subscript):
+            # Handle generic types like List[int], Dict[str, int]
+            if hasattr(annotation.value, 'id'):
+                container_type = annotation.value.id
+                if container_type in ('List', 'Tuple', 'Set', 'list', 'tuple', 'set'):
+                    # Try to get the type parameter
+                    if isinstance(annotation.slice, ast.Name):
+                        element_type = self.extract_type_annotation(annotation.slice)
+                        return {
+                            'type': 'array',
+                            'items': {'type': element_type}
+                        }
+                    return 'array'
+                elif container_type in ('Dict', 'dict'):
+                    return 'object'
+        # Default for unknown or complex types
+        return 'any'
+    
+    def visit_AnnAssign(self, node):
+        """Visit variable assignments with type annotations"""
+        if isinstance(node.target, ast.Name) and node.annotation:
+            # Store the type annotation for this variable
+            self.var_types[node.target.id] = self.extract_type_annotation(node.annotation)
+        self.generic_visit(node)
+    
+    def visit_Assign(self, node):
+        """Visit regular assignments to track simple type inferences"""
+        if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
+            var_name = node.targets[0].id
+            # Try to infer type from literal values
+            if isinstance(node.value, ast.Constant):
+                self.var_types[var_name] = self.get_value_type(node.value.value)
+        self.generic_visit(node)
+        
+    def visit_ClassDef(self, node):
+        # Track class context for methods
+        class_name = node.name
+        self.function_stack.append(self.current_function)
+        self.var_types_stack.append(self.var_types)
+        
+        # Create new scope for the class
+        self.var_types = {}
+        self.current_function = class_name
+        
+        self.generic_visit(node)
+        
+        # Restore context
+        self.current_function = self.function_stack.pop()
+        self.var_types = self.var_types_stack.pop()
+    
+    def visit_Call(self, node):
+        # Check for analytics tracking calls
+        source = self.detect_source(node)
+        if source:
+            event_name = self.extract_event_name(node, source)
+            if event_name:
+                properties = self.extract_properties(node, source)
+                self.events.append({
+                    "eventName": event_name,
+                    "source": source,
+                    "properties": properties,
+                    "filePath": self.filepath,
+                    "line": node.lineno,
+                    "functionName": self.current_function
+                })
+        
+        # Continue visiting child nodes
+        self.generic_visit(node)
+    
+    def detect_source(self, node):
+        # Check for analytics tracking libraries
+        if isinstance(node.func, ast.Attribute):
+            if hasattr(node.func.value, 'id'):
+                obj_id = node.func.value.id
+                method_name = node.func.attr
+                
+                # Segment analytics
+                if obj_id == 'analytics' and method_name == 'track':
+                    return 'segment'
+                # Mixpanel
+                if obj_id == 'mixpanel' and method_name == 'track':
+                    return 'mixpanel'
+                # Amplitude
+                if obj_id == 'amplitude' and method_name == 'track':
+                    return 'amplitude'
+                # Rudderstack
+                if obj_id == 'rudderanalytics' and method_name == 'track':
+                    return 'rudderstack'
+                # mParticle
+                if obj_id == 'mParticle' and method_name == 'logEvent':
+                    return 'mparticle'
+                # PostHog
+                if obj_id == 'posthog' and method_name == 'capture':
+                    return 'posthog'
+                # Pendo
+                if obj_id == 'pendo' and method_name == 'track':
+                    return 'pendo'
+                # Heap
+                if obj_id == 'heap' and method_name == 'track':
+                    return 'heap'
+        
+        # Check for Snowplow struct event patterns
+        if isinstance(node.func, ast.Name) and node.func.id in ['trackStructEvent', 'buildStructEvent']:
+            return 'snowplow'
+        
+        # Check for Snowplow's snowplow('trackStructEvent', {...}) pattern
+        if isinstance(node.func, ast.Name) and node.func.id == 'snowplow':
+            if len(node.args) >= 1 and isinstance(node.args[0], ast.Constant):
+                if node.args[0].value == 'trackStructEvent':
+                    return 'snowplow'
+        
+        # Check for custom tracking function
+        if self.custom_function and isinstance(node.func, ast.Name) and node.func.id == self.custom_function:
+            return 'custom'
+        
+        return None
+    
+    def extract_event_name(self, node, source):
+        try:
+            if source in ['segment', 'mixpanel', 'amplitude', 'rudderstack', 'pendo', 'heap', 'custom']:
+                # Standard format: library.track('event_name', {...})
+                # Custom function follows same format: customFunction('event_name', {...})
+                if len(node.args) >= 1 and isinstance(node.args[0], ast.Constant):
+                    return node.args[0].value
+            
+            elif source == 'mparticle':
+                # mParticle: mParticle.logEvent('event_name', {...})
+                if len(node.args) >= 1 and isinstance(node.args[0], ast.Constant):
+                    return node.args[0].value
+            
+            elif source == 'posthog':
+                # PostHog has multiple formats:
+                # 1. posthog.capture('distinct_id', 'event_name', {...})
+                # 2. posthog.capture('distinct_id', event='event_name', properties={...})
+                
+                # Check for named parameters first (event='event_name')
+                for keyword in node.keywords:
+                    if keyword.arg == 'event' and isinstance(keyword.value, ast.Constant):
+                        return keyword.value.value
+                
+                # If no named event parameter, check positional args (second arg is event name)
+                if len(node.args) >= 2 and isinstance(node.args[1], ast.Constant):
+                    return node.args[1].value
+            
+            elif source == 'snowplow':
+                # Snowplow struct events use 'action' as the event name
+                if len(node.args) >= 1:
+                    # Handle different snowplow call patterns
+                    props_node = None
+                    
+                    # Direct trackStructEvent/buildStructEvent call
+                    if isinstance(node.func, ast.Name) and node.func.id in ['trackStructEvent', 'buildStructEvent']:
+                        if len(node.args) >= 1:
+                            props_node = node.args[0]
+                    
+                    # snowplow('trackStructEvent', {...}) pattern
+                    elif isinstance(node.func, ast.Name) and node.func.id == 'snowplow':
+                        if len(node.args) >= 2:
+                            props_node = node.args[1]
+                    
+                    # Extract 'action' from properties
+                    if props_node and isinstance(props_node, ast.Dict):
+                        for i, key_node in enumerate(props_node.keys):
+                            if isinstance(key_node, ast.Constant) and key_node.value == 'action':
+                                value_node = props_node.values[i]
+                                if isinstance(value_node, ast.Constant):
+                                    return value_node.value
+        except:
+            pass
+        return None
+    
+    def extract_properties(self, node, source):
+        properties = {}
+        try:
+            props_node = None
+            
+            # Get the properties object based on source
+            if source in ['segment', 'mixpanel', 'amplitude', 'rudderstack', 'mparticle', 'pendo', 'heap', 'custom']:
+                # Standard format: library.track('event_name', {properties})
+                # Custom function follows same format: customFunction('event_name', {...})
+                if len(node.args) > 1:
+                    props_node = node.args[1]
+            
+            elif source == 'posthog':
+                # PostHog has multiple formats
+                is_anonymous = False
+                distinct_id = None
+                
+                # Check for properties in named parameters first
+                for keyword in node.keywords:
+                    if keyword.arg == 'properties' and isinstance(keyword.value, ast.Dict):
+                        props_node = keyword.value
+                        
+                        # Check if event is anonymous
+                        for i, key_node in enumerate(props_node.keys):
+                            if (isinstance(key_node, ast.Constant) and 
+                                key_node.value == '$process_person_profile'):
+                                value_node = props_node.values[i]
+                                if (isinstance(value_node, ast.Constant) and 
+                                    value_node.value is False):
+                                    is_anonymous = True
+                
+                # If no named properties, check positional args (third arg)
+                if props_node is None and len(node.args) > 2:
+                    props_node = node.args[2]
+                
+                # Add distinct_id as property if it exists and event is not anonymous
+                if not is_anonymous and len(node.args) > 0 and isinstance(node.args[0], ast.Constant):
+                    distinct_id = node.args[0].value
+                    if distinct_id:
+                        properties["distinct_id"] = {"type": "string"}
+            
+            elif source == 'snowplow':
+                # For Snowplow struct events
+                if isinstance(node.func, ast.Name) and node.func.id in ['trackStructEvent', 'buildStructEvent']:
+                    if len(node.args) >= 1:
+                        props_node = node.args[0]
+                
+                # snowplow('trackStructEvent', {...}) pattern
+                elif isinstance(node.func, ast.Name) and node.func.id == 'snowplow':
+                    if len(node.args) >= 2:
+                        props_node = node.args[1]
+            
+            # Extract properties from the dictionary
+            if props_node and isinstance(props_node, ast.Dict):
+                for i, key_node in enumerate(props_node.keys):
+                    if isinstance(key_node, ast.Constant) and hasattr(key_node, 'value'):
+                        key = key_node.value
+                        value_node = props_node.values[i]
+                        
+                        # Special handling for PostHog $set and $set_once
+                        if source == 'posthog' and key in ['$set', '$set_once']:
+                            if isinstance(value_node, ast.Dict):
+                                nested_props = self.extract_nested_dict(value_node)
+                                for nested_key, nested_value in nested_props.items():
+                                    properties[f"{key}.{nested_key}"] = nested_value
+                            continue
+                        
+                        # Skip PostHog internal properties
+                        if source == 'posthog' and key == '$process_person_profile':
+                            continue
+                        
+                        # Handle different value types
+                        if isinstance(value_node, ast.Constant):
+                            value_type = self.get_value_type(value_node.value)
+                            properties[key] = {"type": value_type}
+                        elif isinstance(value_node, ast.Name):
+                            # Check if we know the type of this variable
+                            var_name = value_node.id
+                            if var_name in self.var_types:
+                                # Get the type for this variable
+                                var_type = self.var_types[var_name]
+                                
+                                # Handle structured types (arrays or objects)
+                                if isinstance(var_type, dict):
+                                    properties[key] = var_type
+                                else:
+                                    properties[key] = {"type": var_type}
+                            else:
+                                properties[key] = {"type": "any"}
+                        elif isinstance(value_node, ast.Dict):
+                            # Nested dictionary
+                            nested_props = self.extract_nested_dict(value_node)
+                            properties[key] = {
+                                "type": "object",
+                                "properties": nested_props
+                            }
+                        elif isinstance(value_node, ast.List) or isinstance(value_node, ast.Tuple):
+                            # Array/list/tuple
+                            item_type = self.infer_sequence_item_type(value_node)
+                            properties[key] = {
+                                "type": "array",
+                                "items": item_type
+                            }
+        except:
+            pass
+        return properties
+    
+    def infer_sequence_item_type(self, seq_node):
+        """Analyze a sequence (list or tuple) to determine the type of its items"""
+        if not hasattr(seq_node, 'elts') or not seq_node.elts:
+            return {"type": "any"}
+        
+        # Get types of all elements
+        element_types = []
+        for element in seq_node.elts:
+            if isinstance(element, ast.Constant):
+                element_types.append(self.get_value_type(element.value))
+            elif isinstance(element, ast.Name):
+                if element.id in self.var_types:
+                    element_types.append(self.var_types[element.id])
+                else:
+                    element_types.append("any")
+            elif isinstance(element, ast.Dict):
+                element_types.append("object")
+            elif isinstance(element, ast.List) or isinstance(element, ast.Tuple):
+                element_types.append("array")
+            else:
+                element_types.append("any")
+        
+        # Check if all elements are the same type
+        if len(set(element_types)) == 1:
+            return {"type": element_types[0]}
+        
+        # Check if all types are either number or string (common mixed case)
+        if set(element_types) <= {"number", "string"}:
+            return {"type": "string"}
+        
+        # Check if all types are either number or boolean
+        if set(element_types) <= {"number", "boolean"}:
+            return {"type": "number"}
+        
+        # Otherwise, it's a mixed type array
+        return {"type": "any"}
+    
+    def extract_nested_dict(self, dict_node):
+        nested_props = {}
+        for i, key_node in enumerate(dict_node.keys):
+            if isinstance(key_node, ast.Constant) and hasattr(key_node, 'value'):
+                key = key_node.value
+                value_node = dict_node.values[i]
+                
+                if isinstance(value_node, ast.Constant):
+                    value_type = self.get_value_type(value_node.value)
+                    nested_props[key] = {"type": value_type}
+                elif isinstance(value_node, ast.Name):
+                    # Check if we know the type of this variable
+                    var_name = value_node.id
+                    if var_name in self.var_types:
+                        nested_props[key] = {"type": self.var_types[var_name]}
+                    else:
+                        nested_props[key] = {"type": "any"}
+                elif isinstance(value_node, ast.Dict):
+                    sub_props = self.extract_nested_dict(value_node)
+                    nested_props[key] = {
+                        "type": "object",
+                        "properties": sub_props
+                    }
+                elif isinstance(value_node, ast.List) or isinstance(value_node, ast.Tuple):
+                    # Array/list/tuple
+                    item_type = self.infer_sequence_item_type(value_node)
+                    nested_props[key] = {
+                        "type": "array",
+                        "items": item_type
+                    }
+        return nested_props
+    
+    def get_value_type(self, value):
+        if isinstance(value, str):
+            return "string"
+        elif isinstance(value, (int, float)):
+            return "number"
+        elif isinstance(value, bool):
+            return "boolean"
+        elif value is None:
+            return "null"
+        return "any"
+
+def analyze_python_code(code, filepath, custom_function=None):
+    # Parse the Python code
+    tree = ast.parse(code)
+    visitor = TrackingVisitor(filepath, custom_function)
+    visitor.visit(tree)
+    
+    # Return events as JSON
+    return json.dumps(visitor.events)
+
+if __name__ == "__main__":
+    import sys
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Analyze Python code for tracking calls')
+    parser.add_argument('file', help='Python file to analyze')
+    parser.add_argument('-c', '--custom-function', help='Name of custom tracking function')
+    args = parser.parse_args()
+    
+    try:
+        with open(args.file, 'r') as f:
+            code = f.read()
+        result = analyze_python_code(code, args.file, args.custom_function)
+        print(result)
+    except FileNotFoundError:
+        print(f"Error: File '{args.file}' not found")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error analyzing file: {str(e)}")
+        sys.exit(1)

package/src/index.js

@@ -12,13 +12,13 @@ async function run(targetDir, outputPath, customFunction, customSourceDetails, g
     let llm;
     if (provider === 'openai') {
       llm = new ChatOpenAI({
-        modelName: model,
+        model: model,
         temperature: 0,
       });
     }
     if (provider === 'gemini') {
       llm = new ChatVertexAI({
-        modelName: model,
+        model: model,
         temperature: 0,
       });
     }