@flisk/analyze-tracking 0.7.1 → 0.7.3

package/src/analyze/helpers.js

@@ -1,217 +0,0 @@
-const ts = require('typescript');
-
-function detectSourceJs(node, customFunction) {
-  if (!node.callee) return 'unknown';
-
-  if (node.callee.type === 'Identifier' && node.callee.name === 'gtag') {
-    return 'googleanalytics';
-  }
-
-  if (node.callee.type === 'MemberExpression') {
-    const objectName = node.callee.object.name;
-    const methodName = node.callee.property.name;
-
-    if (objectName === 'analytics' && methodName === 'track') return 'segment';
-    if (objectName === 'mixpanel' && methodName === 'track') return 'mixpanel';
-    if (objectName === 'amplitude' && methodName === 'logEvent') return 'amplitude';
-    if (objectName === 'rudderanalytics' && methodName === 'track') return 'rudderstack';
-    if (objectName === 'mParticle' && methodName === 'logEvent') return 'mparticle';
-    if (objectName === 'posthog' && methodName === 'capture') return 'posthog';
-    if (objectName === 'pendo' && methodName === 'track') return 'pendo';
-    if (objectName === 'heap' && methodName === 'track') return 'heap';
-  }
-
-  if (node.callee.type === 'Identifier' && node.callee.name === 'snowplow') {
-    return 'snowplow';
-  }
-
-  if (node.callee.type === 'Identifier' && node.callee.name === customFunction) {
-    return 'custom';
-  }
-
-  return 'unknown';
-}
-
-function detectSourceTs(node, customFunction) {
-  if (!node.expression) return 'unknown';
-
-  if (ts.isIdentifier(node.expression) && node.expression.escapedText === 'gtag') {
-    return 'googleanalytics';
-  }
-  
-  if (ts.isPropertyAccessExpression(node.expression)) {
-    const objectName = node.expression.expression.escapedText;
-    const methodName = node.expression.name.escapedText;
-
-    if (objectName === 'analytics' && methodName === 'track') return 'segment';
-    if (objectName === 'mixpanel' && methodName === 'track') return 'mixpanel';
-    if (objectName === 'amplitude' && methodName === 'logEvent') return 'amplitude';
-    if (objectName === 'rudderanalytics' && methodName === 'track') return 'rudderstack';
-    if (objectName === 'mParticle' && methodName === 'logEvent') return 'mparticle';
-    if (objectName === 'posthog' && methodName === 'capture') return 'posthog';
-    if (objectName === 'pendo' && methodName === 'track') return 'pendo';
-    if (objectName === 'heap' && methodName === 'track') return 'heap';
-  }
-  
-  if (ts.isIdentifier(node.expression) && node.expression.escapedText === 'snowplow') {
-    return 'snowplow';
-  }
-
-  if (ts.isIdentifier(node.expression) && node.expression.escapedText === customFunction) {
-    return 'custom';
-  }
-
-  return 'unknown';
-}
-
-function findWrappingFunctionTs(node) {
-  let current = node;
-  while (current) {
-    if (ts.isFunctionDeclaration(current) || ts.isMethodDeclaration(current) || ts.isArrowFunction(current)) {
-      return current.name ? current.name.escapedText : 'anonymous';
-    }
-    current = current.parent;
-  }
-  return 'global';
-}
-
-function findWrappingFunctionJs(node, ancestors) {
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    const current = ancestors[i];
-
-    // Handle direct variable assignments (e.g., const myFunc = () => {})
-    if (current.type === 'VariableDeclarator' && current.init === node) {
-      return current.id.name;
-    }
-
-    // Handle arrow functions or function expressions assigned to variables
-    if (current.type === 'VariableDeclarator' && (current.init.type === 'ArrowFunctionExpression' || current.init.type === 'FunctionExpression')) {
-      return current.id.name;
-    }
-
-    // Handle named function declarations
-    if (current.type === 'FunctionDeclaration') {
-      return current.id ? current.id.name : 'anonymous';
-    }
-
-    // Handle exported variable/function (e.g., export const myFunc = () => {})
-    if (current.type === 'ExportNamedDeclaration' && current.declaration) {
-      const declaration = current.declaration.declarations ? current.declaration.declarations[0] : null;
-      if (declaration && (declaration.init.type === 'ArrowFunctionExpression' || declaration.init.type === 'FunctionExpression')) {
-        return declaration.id.name;
-      }
-    }
-
-    // Handle methods within object literals
-    if (current.type === 'Property' && current.value === node) {
-      return current.key.name || current.key.value;
-    }
-  }
-  return 'global';
-}
-
-function extractJsProperties(node) {
-  const properties = {};
-
-  node.properties.forEach((prop) => {
-    const key = prop.key?.name || prop.key?.value;
-    if (key) {
-      let valueType = typeof prop.value.value;
-      if (prop.value.type === 'ObjectExpression') {
-        properties[key] = {
-          type: 'object',
-          properties: extractJsProperties(prop.value),
-        };
-      } else {
-        if (valueType === 'undefined') {
-          valueType = 'any';
-        } else if (valueType === 'object') {
-          valueType = 'any';
-        }
-        properties[key] = { type: valueType };
-      }
-    }
-  });
-
-  return properties;
-}
-
-function extractTsProperties(checker, node) {
-  const properties = {};
-
-  for (const prop of node.properties) {
-    const key = !!prop.name ? prop.name.text : (!!prop.key ? (prop.key.text || prop.key.value) : undefined);
-    if (!key) continue;
-    let valueType = 'any';
-
-    if (ts.isShorthandPropertyAssignment(prop)) {
-      const symbol = checker.getSymbolAtLocation(prop.name);
-      if (symbol) {
-        valueType = getTypeOfNode(checker, symbol.valueDeclaration);
-        properties[key] = { type: valueType };
-      }
-    } else if (prop.initializer) {
-      if (ts.isObjectLiteralExpression(prop.initializer)) {
-        properties[key] = {
-          type: 'object',
-          properties: extractTsProperties(checker, prop.initializer),
-        };
-      } else if (ts.isArrayLiteralExpression(prop.initializer)) {
-        properties[key] = {
-          type: 'array',
-          items: {
-            type: getTypeOfNode(checker, prop.initializer.elements[0]) || 'any',
-          },
-        };
-      } else {
-        // Handle hard-coded values
-        switch (prop.initializer.kind) {
-          case ts.SyntaxKind.StringLiteral:
-            valueType = 'string';
-            break;
-          case ts.SyntaxKind.NumericLiteral:
-            valueType = 'number';
-            break;
-          case ts.SyntaxKind.TrueKeyword:
-          case ts.SyntaxKind.FalseKeyword:
-            valueType = 'boolean';
-            break;
-          case ts.SyntaxKind.ArrayLiteralExpression:
-            valueType = 'array';
-            break;
-          case ts.SyntaxKind.ObjectLiteralExpression:
-            valueType = 'object';
-            break;
-          default:
-            valueType = 'any';
-        }
-
-        if (valueType === 'any') {
-          valueType = getTypeOfNode(checker, prop.initializer) || 'any';
-        }
-
-        properties[key] = { type: valueType };
-      }
-    } else if (prop.type) {
-      valueType = checker.typeToString(checker.getTypeFromTypeNode(prop.type)) || 'any';
-      properties[key] = { type: valueType };
-    }
-  }
-
-  return properties;
-}
-
-function getTypeOfNode(checker, node) {
-  const type = checker.getTypeAtLocation(node);
-  return checker.typeToString(type);
-}
-
-module.exports = {
-  detectSourceJs,
-  detectSourceTs,
-  findWrappingFunctionTs,
-  findWrappingFunctionJs,
-  extractJsProperties,
-  extractTsProperties,
-  getTypeOfNode,
-};

package/src/analyze/pythonTrackingAnalyzer.py

@@ -1,439 +0,0 @@
-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 == 'rudder_analytics' 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)