aidp 0.5.0 → 0.7.0

data/lib/aidp/analysis/seams.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Analysis
+    module Seams
+      # I/O and OS integration patterns
+      IO_PATTERNS = [
+        /^File\./, /^IO\./, /^Kernel\.system$/, /^Open3\./, /^Net::HTTP/,
+        /Socket|TCPSocket|UDPSocket/, /^Dir\./, /^ENV/, /^ARGV/,
+        /^STDIN|^STDOUT|^STDERR/, /^Process\./, /^Thread\./, /^Timeout\./
+      ].freeze
+
+      # Database and external service patterns
+      EXTERNAL_SERVICE_PATTERNS = [
+        /ActiveRecord|Sequel|DataMapper/, /Redis|Memcached/, /Elasticsearch/,
+        /AWS::|Google::|Azure::/, /HTTParty|Faraday|Net::HTTP/,
+        /Sidekiq|Resque|DelayedJob/, /ActionMailer|Mail/
+      ].freeze
+
+      # Global and singleton patterns
+      GLOBAL_PATTERNS = [
+        /^\$[a-zA-Z_]/, /^@@[a-zA-Z_]/, /^::[A-Z]/, /^Kernel\./,
+        /include Singleton/, /extend Singleton/, /@singleton/
+      ].freeze
+
+      # Constructor with work indicators
+      CONSTRUCTOR_WORK_INDICATORS = [
+        /File\./, /IO\./, /Net::/, /HTTP/, /Database/, /Redis/,
+        /system\(/, /exec\(/, /spawn\(/, /fork\(/
+      ].freeze
+
+      def self.io_call?(receiver, method)
+        fq = [receiver, method].compact.join(".")
+        IO_PATTERNS.any? { |pattern| fq.match?(pattern) }
+      end
+
+      def self.external_service_call?(receiver, method)
+        fq = [receiver, method].compact.join(".")
+        EXTERNAL_SERVICE_PATTERNS.any? { |pattern| fq.match?(pattern) }
+      end
+
+      def self.global_or_singleton?(ast_node_texts)
+        ast_node_texts.any? { |text| GLOBAL_PATTERNS.any? { |pattern| text.match?(pattern) } }
+      end
+
+      def self.constructor_with_work?(node, metrics)
+        return false unless node[:type] == "method" && node[:name] == "initialize"
+
+        # Check if constructor has significant work based on metrics
+        metrics[:branch_count].to_i > 2 ||
+          metrics[:fan_out].to_i > 3 ||
+          metrics[:lines].to_i > 10
+      end
+
+      def self.detect_seams_in_ast(ast_nodes, file_path)
+        seams = []
+
+        ast_nodes.each do |node|
+          case node[:type]
+          when "method"
+            seams.concat(detect_method_seams(node, file_path))
+          when "class", "module"
+            seams.concat(detect_class_module_seams(node, file_path))
+          end
+        end
+
+        seams
+      end
+
+      def self.detect_method_seams(method_node, file_path)
+        seams = []
+
+        # Check for I/O calls in method body
+        if (io_calls = extract_io_calls(method_node))
+          io_calls.each do |call|
+            seams << {
+              kind: "io_integration",
+              file: file_path,
+              line: call[:line],
+              symbol_id: "#{file_path}:#{method_node[:line]}:#{method_node[:name]}",
+              detail: {
+                call: call[:call],
+                receiver: call[:receiver],
+                method: call[:method]
+              },
+              suggestion: "Consider extracting I/O operations to a separate service class"
+            }
+          end
+        end
+
+        # Check for external service calls
+        if (service_calls = extract_external_service_calls(method_node))
+          service_calls.each do |call|
+            seams << {
+              kind: "external_service",
+              file: file_path,
+              line: call[:line],
+              symbol_id: "#{file_path}:#{method_node[:line]}:#{method_node[:name]}",
+              detail: {
+                call: call[:call],
+                service: call[:service]
+              },
+              suggestion: "Consider using dependency injection for external service calls"
+            }
+          end
+        end
+
+        # Check for global/singleton usage
+        if (global_usage = extract_global_usage(method_node))
+          global_usage.each do |usage|
+            seams << {
+              kind: "global_singleton",
+              file: file_path,
+              line: usage[:line],
+              symbol_id: "#{file_path}:#{method_node[:line]}:#{method_node[:name]}",
+              detail: {
+                usage: usage[:usage],
+                type: usage[:type]
+              },
+              suggestion: "Consider passing global state as parameters or using dependency injection"
+            }
+          end
+        end
+
+        seams
+      end
+
+      def self.detect_class_module_seams(class_node, file_path)
+        seams = []
+
+        # Check for singleton pattern
+        if class_node[:content]&.include?("include Singleton")
+          seams << {
+            kind: "singleton_pattern",
+            file: file_path,
+            line: class_node[:line],
+            symbol_id: "#{file_path}:#{class_node[:line]}:#{class_node[:name]}",
+            detail: {
+              pattern: "Singleton",
+              class_name: class_node[:name]
+            },
+            suggestion: "Consider using dependency injection instead of singleton pattern"
+          }
+        end
+
+        # Check for global state in class/module
+        if (global_state = extract_global_state(class_node))
+          global_state.each do |state|
+            seams << {
+              kind: "global_state",
+              file: file_path,
+              line: state[:line],
+              symbol_id: "#{file_path}:#{class_node[:line]}:#{class_node[:name]}",
+              detail: {
+                state: state[:state],
+                type: state[:type]
+              },
+              suggestion: "Consider encapsulating global state or using configuration objects"
+            }
+          end
+        end
+
+        seams
+      end
+
+      private_class_method def self.extract_io_calls(_method_node)
+        # This would extract I/O calls from the method's AST
+        # For now, return mock data
+        []
+      end
+
+      private_class_method def self.extract_external_service_calls(_method_node)
+        # This would extract external service calls from the method's AST
+        []
+      end
+
+      private_class_method def self.extract_global_usage(_method_node)
+        # This would extract global variable usage from the method's AST
+        []
+      end
+
+      private_class_method def self.extract_global_state(_class_node)
+        # This would extract global state from the class/module AST
+        []
+      end
+    end
+  end
+end

data/lib/aidp/analysis/tree_sitter_grammar_loader.rb

@@ -0,0 +1,493 @@
+# frozen_string_literal: true
+
+require "tree_sitter"
+require "fileutils"
+
+module Aidp
+  module Analysis
+    class TreeSitterGrammarLoader
+      # Default grammar configurations
+      GRAMMAR_CONFIGS = {
+        "ruby" => {
+          name: "tree-sitter-ruby",
+          version: "0.20.0",
+          source: "https://github.com/tree-sitter/tree-sitter-ruby",
+          file_patterns: ["**/*.rb"],
+          node_types: {
+            class: "class",
+            module: "module",
+            method: "method",
+            call: "call",
+            require: "call",
+            require_relative: "call"
+          }
+        },
+        "javascript" => {
+          name: "tree-sitter-javascript",
+          version: "0.20.0",
+          source: "https://github.com/tree-sitter/tree-sitter-javascript",
+          file_patterns: ["**/*.js", "**/*.jsx"],
+          node_types: {
+            class: "class_declaration",
+            function: "function_declaration",
+            call: "call_expression",
+            import: "import_statement"
+          }
+        },
+        "typescript" => {
+          name: "tree-sitter-typescript",
+          version: "0.20.0",
+          source: "https://github.com/tree-sitter/tree-sitter-typescript",
+          file_patterns: ["**/*.ts", "**/*.tsx"],
+          node_types: {
+            class: "class_declaration",
+            function: "function_declaration",
+            call: "call_expression",
+            import: "import_statement"
+          }
+        },
+        "python" => {
+          name: "tree-sitter-python",
+          version: "0.20.0",
+          source: "https://github.com/tree-sitter/tree-sitter-python",
+          file_patterns: ["**/*.py"],
+          node_types: {
+            class: "class_definition",
+            function: "function_definition",
+            call: "call",
+            import: "import_statement"
+          }
+        }
+      }.freeze
+
+      def initialize(project_dir = Dir.pwd)
+        @project_dir = project_dir
+        @grammars_dir = File.join(project_dir, ".aidp", "grammars")
+        @loaded_grammars = {}
+      end
+
+      # Load grammar for a specific language
+      def load_grammar(language)
+        return @loaded_grammars[language] if @loaded_grammars[language]
+
+        config = GRAMMAR_CONFIGS[language]
+        raise "Unsupported language: #{language}" unless config
+
+        ensure_grammar_available(language, config)
+        @loaded_grammars[language] = create_parser(language, config)
+      end
+
+      # Get supported languages
+      def supported_languages
+        GRAMMAR_CONFIGS.keys
+      end
+
+      # Get file patterns for a language
+      def file_patterns_for_language(language)
+        config = GRAMMAR_CONFIGS[language]
+        return [] unless config
+
+        config[:file_patterns]
+      end
+
+      # Get node types for a language
+      def node_types_for_language(language)
+        config = GRAMMAR_CONFIGS[language]
+        return {} unless config
+
+        config[:node_types]
+      end
+
+      private
+
+      def ensure_grammar_available(language, config)
+        grammar_path = File.join(@grammars_dir, language)
+
+        unless File.exist?(grammar_path)
+          puts "Installing Tree-sitter grammar for #{language}..."
+          install_grammar(language, config)
+        end
+      end
+
+      def install_grammar(language, config)
+        FileUtils.mkdir_p(@grammars_dir)
+
+        # For now, we'll use the system-installed grammars
+        # In a production setup, you might want to download and compile grammars
+        grammar_path = File.join(@grammars_dir, language)
+
+        # Create a placeholder file to indicate the grammar is "installed"
+        # The actual grammar loading will be handled by tree_sitter
+        FileUtils.mkdir_p(grammar_path)
+        require "json"
+        File.write(File.join(grammar_path, "grammar.json"), JSON.generate(config))
+
+        puts "Grammar for #{language} marked as available"
+      end
+
+      def create_parser(language, config)
+        # Create a Tree-sitter parser for the language
+        # This is a simplified version - in practice you'd need to handle
+        # the actual grammar loading from the ruby_tree_sitter gem
+
+        {
+          language: language,
+          config: config,
+          parser: create_tree_sitter_parser(language)
+        }
+      end
+
+      def create_tree_sitter_parser(language)
+        create_real_parser(language)
+      end
+
+      def create_real_parser(language)
+        parser = TreeSitter::Parser.new
+        language_obj = TreeSitter.lang(language)
+        parser.language = language_obj
+
+        {
+          parse: ->(source_code) { parse_with_tree_sitter(parser, source_code) },
+          language: language,
+          real: true
+        }
+      rescue TreeSitter::ParserNotFoundError => e
+        puts "Warning: Tree-sitter parser not found for #{language}: #{e.message}"
+        create_mock_parser(language)
+      end
+
+      def create_mock_parser(language)
+        case language
+        when "ruby"
+          create_ruby_parser
+        when "javascript"
+          create_javascript_parser
+        when "typescript"
+          create_typescript_parser
+        when "python"
+          create_python_parser
+        else
+          raise "Unsupported language: #{language}"
+        end
+      end
+
+      def parse_with_tree_sitter(parser, source_code)
+        tree = parser.parse_string(nil, source_code)
+        root = tree.root_node
+
+        # Convert Tree-sitter AST to our internal format
+        convert_tree_sitter_ast(root, source_code)
+      end
+
+      def convert_tree_sitter_ast(node, source_code)
+        children = []
+
+        node.each do |child|
+          child_data = {
+            type: child.type,
+            name: extract_node_name(child, source_code),
+            line: child.start_point.row + 1,
+            start_column: child.start_point.column,
+            end_column: child.end_point.column
+          }
+
+          # Recursively process child nodes
+          if child.child_count > 0
+            child_data[:children] = convert_tree_sitter_ast(child, source_code)
+          end
+
+          children << child_data
+        end
+
+        {
+          type: node.type,
+          children: children
+        }
+      end
+
+      def extract_node_name(node, source_code)
+        # Extract meaningful names from nodes
+        case node.type.to_s
+        when "class", "module"
+          # Look for the class/module name in the source, handling nested constants
+          lines = source_code.lines
+          line_content = lines[node.start_point.row] || ""
+          # Handle patterns like: class Foo, class Foo::Bar, module A::B::C
+          if (match = line_content.match(/(?:class|module)\s+((?:\w+::)*\w+)/))
+            match[1]
+          else
+            node.type.to_s
+          end
+        when "method"
+          # Look for method name, handling various definition styles
+          lines = source_code.lines
+          line_content = lines[node.start_point.row] || ""
+          # Handle: def foo, def foo(args), def foo=(value), def []=(key, value)
+          if (match = line_content.match(/def\s+([\w\[\]=!?]+)/))
+            match[1]
+          else
+            node.type.to_s
+          end
+        when "singleton_method"
+          # Look for singleton method name, handling class methods
+          lines = source_code.lines
+          line_content = lines[node.start_point.row] || ""
+          # Handle: def self.foo, def ClassName.foo, def obj.method_name
+          if (match = line_content.match(/def\s+(?:self|[\w:]+)\.([\w\[\]=!?]+)/))
+            match[1]
+          else
+            node.type.to_s
+          end
+        when "constant"
+          # Extract constant names
+          lines = source_code.lines
+          line_content = lines[node.start_point.row] || ""
+          # Handle: CONSTANT = value, A::B::CONSTANT = value
+          if (match = line_content.match(/((?:\w+::)*[A-Z_][A-Z0-9_]*)\s*=/))
+            match[1]
+          else
+            node.type.to_s
+          end
+        else
+          node.type.to_s
+        end
+      end
+
+      def create_ruby_parser
+        # Mock Ruby parser - fallback when Tree-sitter is not available
+        {
+          parse: ->(source_code) { parse_ruby_source(source_code) },
+          language: "ruby",
+          real: false
+        }
+      end
+
+      def create_javascript_parser
+        {
+          parse: ->(source_code) { parse_javascript_source(source_code) },
+          language: "javascript",
+          real: false
+        }
+      end
+
+      def create_typescript_parser
+        {
+          parse: ->(source_code) { parse_typescript_source(source_code) },
+          language: "typescript",
+          real: false
+        }
+      end
+
+      def create_python_parser
+        {
+          parse: ->(source_code) { parse_python_source(source_code) },
+          language: "python",
+          real: false
+        }
+      end
+
+      # Mock parsing methods - these would be replaced with actual Tree-sitter parsing
+      def parse_ruby_source(source_code)
+        # This would use the actual ruby_tree_sitter gem
+        # For now, return a mock AST structure
+        {
+          type: "program",
+          children: extract_ruby_nodes(source_code)
+        }
+      end
+
+      def parse_javascript_source(source_code)
+        {
+          type: "program",
+          children: extract_javascript_nodes(source_code)
+        }
+      end
+
+      def parse_typescript_source(source_code)
+        {
+          type: "program",
+          children: extract_typescript_nodes(source_code)
+        }
+      end
+
+      def parse_python_source(source_code)
+        {
+          type: "module",
+          children: extract_python_nodes(source_code)
+        }
+      end
+
+      # Simple regex-based extraction for demonstration
+      # In practice, these would be replaced with actual Tree-sitter node extraction
+      def extract_ruby_nodes(source_code)
+        nodes = []
+        lines = source_code.lines
+
+        lines.each_with_index do |line, index|
+          line_number = index + 1
+
+          # Extract class definitions (including nested constants)
+          if (match = line.match(/^\s*class\s+((?:\w+::)*\w+)/))
+            nodes << {
+              type: "class",
+              name: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+
+          # Extract module definitions (including nested constants)
+          if (match = line.match(/^\s*module\s+((?:\w+::)*\w+)/))
+            nodes << {
+              type: "module",
+              name: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+
+          # Extract method definitions (including special methods)
+          if (match = line.match(/^\s*def\s+([\w\[\]=!?]+)/))
+            nodes << {
+              type: "method",
+              name: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+
+          # Extract singleton/class method definitions
+          if (match = line.match(/^\s*def\s+(?:self|[\w:]+)\.([\w\[\]=!?]+)/))
+            nodes << {
+              type: "singleton_method",
+              name: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+
+          # Extract require statements
+          if (match = line.match(/^\s*require\s+['"]([^'"]+)['"]/))
+            nodes << {
+              type: "require",
+              target: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+
+          # Extract require_relative statements
+          if (match = line.match(/^\s*require_relative\s+['"]([^'"]+)['"]/))
+            nodes << {
+              type: "require_relative",
+              target: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+        end
+
+        nodes
+      end
+
+      def extract_javascript_nodes(source_code)
+        nodes = []
+        lines = source_code.lines
+
+        lines.each_with_index do |line, index|
+          line_number = index + 1
+
+          # Extract class declarations
+          if (match = line.match(/class\s+(\w+)/))
+            nodes << {
+              type: "class",
+              name: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+
+          # Extract function declarations
+          if (match = line.match(/function\s+(\w+)/))
+            nodes << {
+              type: "function",
+              name: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+
+          # Extract import statements
+          if (match = line.match(/import\s+.*from\s+['"]([^'"]+)['"]/))
+            nodes << {
+              type: "import",
+              target: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+        end
+
+        nodes
+      end
+
+      def extract_typescript_nodes(source_code)
+        # Similar to JavaScript but with TypeScript-specific patterns
+        extract_javascript_nodes(source_code)
+      end
+
+      def extract_python_nodes(source_code)
+        nodes = []
+        lines = source_code.lines
+
+        lines.each_with_index do |line, index|
+          line_number = index + 1
+
+          # Extract class definitions
+          if (match = line.match(/class\s+(\w+)/))
+            nodes << {
+              type: "class",
+              name: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+
+          # Extract function definitions
+          if (match = line.match(/def\s+(\w+)/))
+            nodes << {
+              type: "function",
+              name: match[1],
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+
+          # Extract import statements
+          if (match = line.match(/import\s+([^#\n]+)/))
+            nodes << {
+              type: "import",
+              target: match[1].strip,
+              line: line_number,
+              start_column: line.index(match[0]),
+              end_column: line.index(match[0]) + match[0].length
+            }
+          end
+        end
+
+        nodes
+      end
+    end
+  end
+end