@flisk/analyze-tracking 0.7.2 → 0.7.4

package/src/analyze/pythonTrackingAnalyzer.py

@@ -1,541 +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 == 'mp' and method_name == 'track':
-                    return 'mixpanel'
-                # Rudderstack
-                if obj_id == 'rudder_analytics' and method_name == 'track':
-                    return 'rudderstack'
-                # PostHog
-                if obj_id == 'posthog' and method_name == 'capture':
-                    return 'posthog'
-                
-                # Amplitude - tracker with BaseEvent
-                if method_name == 'track' and len(node.args) >= 1:
-                    first_arg = node.args[0]
-                    # Check if the first argument is a BaseEvent call
-                    if isinstance(first_arg, ast.Call) and isinstance(first_arg.func, ast.Name):
-                        if first_arg.func.id == 'BaseEvent':
-                            return 'amplitude'
-                
-                # Snowplow - tracker with StructuredEvent
-                if method_name == 'track' and len(node.args) >= 1:
-                    first_arg = node.args[0]
-                    # Check if the first argument is a StructuredEvent call
-                    if isinstance(first_arg, ast.Call) and isinstance(first_arg.func, ast.Name):
-                        if first_arg.func.id == 'StructuredEvent':
-                            return 'snowplow'
-                    # Also check if it's a variable that might be a StructuredEvent
-                    elif isinstance(first_arg, ast.Name):
-                        # Check if we can find the assignment of this variable
-                        # For now, we'll assume any tracker.track() with a single argument is Snowplow
-                        if obj_id == 'tracker':
-                            return 'snowplow'
-        
-        # 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', 'rudderstack', 'mixpanel']:
-                # Segment/Rudderstack/Mixpanel format: library.track(user_id/distinct_id, 'event_name', {...})
-                if len(node.args) >= 2 and isinstance(node.args[1], ast.Constant):
-                    return node.args[1].value
-            elif source == 'amplitude':
-                # Amplitude format: client.track(BaseEvent(event_type='event_name', ...))
-                if len(node.args) >= 1 and isinstance(node.args[0], ast.Call):
-                    base_event_call = node.args[0]
-                    # Look for event_type in keyword arguments
-                    for keyword in base_event_call.keywords:
-                        if keyword.arg == 'event_type' and isinstance(keyword.value, ast.Constant):
-                            return keyword.value.value
-            elif source in ['custom']:
-                # Standard format: customFunction('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 has multiple patterns
-                if len(node.args) >= 1:
-                    first_arg = node.args[0]
-                    
-                    # Pattern 1: tracker.track(StructuredEvent(...))
-                    if isinstance(first_arg, ast.Call) and isinstance(first_arg.func, ast.Name):
-                        if first_arg.func.id == 'StructuredEvent':
-                            # Look for action in keyword arguments
-                            for keyword in first_arg.keywords:
-                                if keyword.arg == 'action' and isinstance(keyword.value, ast.Constant):
-                                    return keyword.value.value
-                
-                # Pattern 2 & 3: For other Snowplow patterns
-                # 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]
-        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', 'rudderstack']:
-                # Segment/Rudderstack format: analytics.track(user_id, 'event_name', {properties})
-                # Add user_id as a property if it's not null
-                if len(node.args) > 0:
-                    user_id_node = node.args[0]
-                    if isinstance(user_id_node, ast.Constant) and user_id_node.value is not None:
-                        properties["user_id"] = {"type": "string"}
-                    elif isinstance(user_id_node, ast.Name):
-                        # It's a variable reference, include it as a property
-                        properties["user_id"] = {"type": "string"}
-                
-                if len(node.args) > 2:
-                    props_node = node.args[2]
-            elif source == 'mixpanel':
-                # Mixpanel format: mp.track(distinct_id, 'event_name', {properties})
-                # Add distinct_id as a property if it's not null
-                if len(node.args) > 0:
-                    distinct_id_node = node.args[0]
-                    if isinstance(distinct_id_node, ast.Constant) and distinct_id_node.value is not None:
-                        properties["distinct_id"] = {"type": "string"}
-                    elif isinstance(distinct_id_node, ast.Name):
-                        # It's a variable reference, include it as a property
-                        properties["distinct_id"] = {"type": "string"}
-                
-                if len(node.args) > 2:
-                    props_node = node.args[2]
-            elif source == 'amplitude':
-                # Amplitude format: client.track(BaseEvent(event_type='...', user_id='...', event_properties={...}))
-                if len(node.args) >= 1 and isinstance(node.args[0], ast.Call):
-                    base_event_call = node.args[0]
-                    
-                    # First, check for user_id parameter
-                    for keyword in base_event_call.keywords:
-                        if keyword.arg == 'user_id':
-                            if isinstance(keyword.value, ast.Constant) and keyword.value.value is not None:
-                                properties["user_id"] = {"type": "string"}
-                            elif isinstance(keyword.value, ast.Name):
-                                # It's a variable reference, include it as a property
-                                properties["user_id"] = {"type": "string"}
-                    
-                    # Then look for event_properties
-                    for keyword in base_event_call.keywords:
-                        if keyword.arg == 'event_properties' and isinstance(keyword.value, ast.Dict):
-                            props_node = keyword.value
-                            break
-            elif source in ['custom']:
-                # Standard format: customFunction('event_name', {properties})
-                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]
-                
-                # Pattern: tracker.track(StructuredEvent(...))
-                elif len(node.args) >= 1:
-                    first_arg = node.args[0]
-                    if isinstance(first_arg, ast.Call) and isinstance(first_arg.func, ast.Name):
-                        if first_arg.func.id == 'StructuredEvent':
-                            # Extract all keyword arguments from StructuredEvent except 'action'
-                            for keyword in first_arg.keywords:
-                                if keyword.arg and keyword.arg != 'action':
-                                    # Map property_ to property for consistency
-                                    prop_name = 'property' if keyword.arg == 'property_' else keyword.arg
-                                    
-                                    if isinstance(keyword.value, ast.Constant):
-                                        value_type = self.get_value_type(keyword.value.value)
-                                        properties[prop_name] = {"type": value_type}
-                                    elif isinstance(keyword.value, ast.Name):
-                                        # Check if we know the type of this variable
-                                        var_name = keyword.value.id
-                                        if var_name in self.var_types:
-                                            var_type = self.var_types[var_name]
-                                            if isinstance(var_type, dict):
-                                                properties[prop_name] = var_type
-                                            else:
-                                                properties[prop_name] = {"type": var_type}
-                                        else:
-                                            properties[prop_name] = {"type": "any"}
-                                    elif isinstance(keyword.value, ast.Dict):
-                                        # Nested dictionary
-                                        nested_props = self.extract_nested_dict(keyword.value)
-                                        properties[prop_name] = {
-                                            "type": "object",
-                                            "properties": nested_props
-                                        }
-                                    elif isinstance(keyword.value, ast.List) or isinstance(keyword.value, ast.Tuple):
-                                        # Array/list/tuple
-                                        item_type = self.infer_sequence_item_type(keyword.value)
-                                        properties[prop_name] = {
-                                            "type": "array",
-                                            "items": item_type
-                                        }
-                            # Don't process props_node if we've already extracted properties
-                            props_node = None
-            
-            # 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, bool):
-            return "boolean"
-        elif isinstance(value, str):
-            return "string"
-        elif isinstance(value, (int, float)):
-            return "number"
-        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)