rubik 0.1.0

data/lib/rubik/ast/treesitter/rust_walker.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "base_walker"
+
+module Rubik
+  module AST
+    module TreeSitter
+      class RustWalker < BaseWalker
+        def walk(root_node)
+          symbols = []
+          return symbols unless root_node
+
+          walk_children(root_node, symbols, nil)
+          symbols
+        end
+
+        private
+
+        def walk_children(node, symbols, impl_type)
+          (0...node.named_child_count).each do |i|
+            child = node.named_child(i)
+            case child.kind
+            when "struct_item"
+              walk_struct(child, symbols)
+            when "enum_item"
+              walk_enum(child, symbols)
+            when "impl_item"
+              walk_impl(child, symbols)
+            when "function_item"
+              walk_function(child, symbols, impl_type)
+            when "use_declaration"
+              walk_use(child, symbols)
+            else
+              walk_children(child, symbols, impl_type)
+            end
+          end
+        end
+
+        def walk_struct(node, symbols)
+          name_node = node.child_by_field_name("name")
+          return unless name_node
+
+          name = text_for(name_node)
+          sig = clean_signature(node)
+          symbols << build_symbol(
+            name: name,
+            kind: :struct,
+            node: node,
+            signature: sig.empty? ? "struct #{name}" : sig
+          )
+        end
+
+        def walk_enum(node, symbols)
+          name_node = node.child_by_field_name("name")
+          return unless name_node
+
+          name = text_for(name_node)
+          sig = clean_signature(node)
+          symbols << build_symbol(
+            name: name,
+            kind: :enum,
+            node: node,
+            signature: sig.empty? ? "enum #{name}" : sig
+          )
+        end
+
+        def walk_impl(node, symbols)
+          type_node = node.child_by_field_name("type")
+          impl_name = type_node ? text_for(type_node).strip : nil
+
+          body = node.child_by_field_name("body")
+          walk_children(body, symbols, impl_name) if body
+        end
+
+        def walk_function(node, symbols, impl_type)
+          name_node = node.child_by_field_name("name")
+          return unless name_node
+
+          fn_name = text_for(name_node)
+          full_name = impl_type ? "#{impl_type}::#{fn_name}" : fn_name
+          body = node.child_by_field_name("body")
+          calls = extract_rust_calls(body)
+
+          sig = clean_signature(node)
+          symbols << build_symbol(
+            name: full_name,
+            kind: :function,
+            node: node,
+            signature: sig.empty? ? "fn #{fn_name}()" : sig,
+            calls: calls
+          )
+        end
+
+        def walk_use(node, symbols)
+          raw = text_for(node).strip.sub(/;\z/, "")
+          symbols << build_symbol(
+            name: raw,
+            kind: :import,
+            node: node,
+            signature: raw
+          )
+        end
+
+        def extract_rust_calls(body_node)
+          calls = []
+          return calls unless body_node
+
+          stack = [body_node]
+          while (n = stack.pop)
+            if n.kind == "call_expression"
+              fn = n.child_by_field_name("function")
+              if fn
+                fn_text = text_for(fn).split("::").last&.strip
+                calls << fn_text if fn_text && !fn_text.empty?
+              end
+            elsif n.kind == "macro_invocation"
+              macro = n.child_by_field_name("macro") || n.named_child(0)
+              if macro
+                macro_text = text_for(macro).sub(/!\z/, "").split("::").last&.strip
+                calls << macro_text if macro_text && !macro_text.empty?
+              end
+            end
+            (0...n.named_child_count).reverse_each { |i| stack.push(n.named_child(i)) }
+          end
+          calls.uniq
+        end
+      end
+    end
+  end
+end

data/lib/rubik/ast/treesitter/typescript_walker.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "base_walker"
+
+module Rubik
+  module AST
+    module TreeSitter
+      class TypeScriptWalker < BaseWalker
+        def walk(root_node)
+          symbols = []
+          return symbols unless root_node
+
+          walk_children(root_node, symbols, nil)
+          symbols
+        end
+
+        private
+
+        def walk_children(node, symbols, current_class)
+          (0...node.named_child_count).each do |i|
+            child = node.named_child(i)
+            case child.kind
+            when "export_statement"
+              walk_export(child, symbols, current_class)
+            when "interface_declaration"
+              walk_interface(child, symbols)
+            when "enum_declaration"
+              walk_enum(child, symbols)
+            when "class_declaration"
+              walk_class(child, symbols)
+            when "function_declaration"
+              walk_function(child, symbols)
+            when "lexical_declaration", "variable_declaration"
+              walk_variable_declaration(child, symbols)
+            when "import_statement"
+              walk_import(child, symbols)
+            else
+              walk_children(child, symbols, current_class)
+            end
+          end
+        end
+
+        def walk_export(node, symbols, current_class)
+          (0...node.named_child_count).each do |i|
+            child = node.named_child(i)
+            case child.kind
+            when "interface_declaration" then walk_interface(child, symbols)
+            when "enum_declaration" then walk_enum(child, symbols)
+            when "class_declaration" then walk_class(child, symbols)
+            when "function_declaration" then walk_function(child, symbols)
+            when "lexical_declaration", "variable_declaration" then walk_variable_declaration(child, symbols)
+            else walk_children(child, symbols, current_class)
+            end
+          end
+        end
+
+        def walk_interface(node, symbols)
+          name_node = node.child_by_field_name("name")
+          return unless name_node
+
+          name = text_for(name_node)
+          sig = clean_signature(node)
+          symbols << build_symbol(
+            name: name,
+            kind: :interface,
+            node: node,
+            signature: sig.empty? ? "interface #{name}" : sig
+          )
+        end
+
+        def walk_enum(node, symbols)
+          name_node = node.child_by_field_name("name")
+          return unless name_node
+
+          name = text_for(name_node)
+          sig = clean_signature(node)
+          symbols << build_symbol(
+            name: name,
+            kind: :enum,
+            node: node,
+            signature: sig.empty? ? "enum #{name}" : sig
+          )
+        end
+
+        def walk_class(node, symbols)
+          name_node = node.child_by_field_name("name")
+          return unless name_node
+
+          class_name = text_for(name_node)
+          sig = clean_signature(node)
+          symbols << build_symbol(
+            name: class_name,
+            kind: :class,
+            node: node,
+            signature: sig.empty? ? "class #{class_name}" : sig
+          )
+
+          body = node.child_by_field_name("body")
+          walk_class_body(body, symbols, class_name) if body
+        end
+
+        def walk_class_body(body_node, symbols, class_name)
+          (0...body_node.named_child_count).each do |i|
+            child = body_node.named_child(i)
+            next unless child.kind == "method_definition"
+
+            name_node = child.child_by_field_name("name")
+            next unless name_node
+
+            method_name = text_for(name_node)
+            full_name = "#{class_name}##{method_name}"
+            body = child.child_by_field_name("body")
+            calls = extract_calls(body, ["call_expression"])
+
+            sig = clean_signature(child)
+            symbols << build_symbol(
+              name: full_name,
+              kind: :function,
+              node: child,
+              signature: sig.empty? ? "#{class_name}.#{method_name}()" : sig,
+              calls: calls
+            )
+          end
+        end
+
+        def walk_function(node, symbols)
+          name_node = node.child_by_field_name("name")
+          return unless name_node
+
+          fn_name = text_for(name_node)
+          body = node.child_by_field_name("body")
+          calls = extract_calls(body, ["call_expression"])
+
+          sig = clean_signature(node)
+          symbols << build_symbol(
+            name: fn_name,
+            kind: :function,
+            node: node,
+            signature: sig.empty? ? "function #{fn_name}()" : sig,
+            calls: calls
+          )
+        end
+
+        def walk_variable_declaration(node, symbols)
+          (0...node.named_child_count).each do |i|
+            decl = node.named_child(i)
+            next unless decl.kind == "variable_declarator"
+
+            val = decl.child_by_field_name("value")
+            next unless val && ["arrow_function", "function_expression"].include?(val.kind)
+
+            name_node = decl.child_by_field_name("name")
+            next unless name_node
+
+            fn_name = text_for(name_node)
+            body = val.child_by_field_name("body")
+            calls = extract_calls(body, ["call_expression"])
+
+            sig = clean_signature(node)
+            symbols << build_symbol(
+              name: fn_name,
+              kind: :function,
+              node: node,
+              signature: sig.empty? ? "const #{fn_name} = () =>" : sig,
+              calls: calls
+            )
+          end
+        end
+
+        def walk_import(node, symbols)
+          raw = text_for(node).strip.sub(/;\z/, "")
+          symbols << build_symbol(
+            name: raw,
+            kind: :import,
+            node: node,
+            signature: raw
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubik/ast/treesitter/zig_walker.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "base_walker"
+
+module Rubik
+  module AST
+    module TreeSitter
+      class ZigWalker < BaseWalker
+        FN_KINDS = ["FnProto", "ProtoDecl", "FunctionDecl", "function_definition"].freeze
+        private_constant :FN_KINDS
+
+        def walk(root_node)
+          symbols = []
+          return symbols unless root_node
+
+          walk_children(root_node, symbols)
+          symbols
+        end
+
+        private
+
+        def walk_children(node, symbols)
+          (0...node.named_child_count).each do |i|
+            child = node.named_child(i)
+            case child.kind
+            when "Decl"
+              walk_decl(child, symbols)
+            else
+              walk_children(child, symbols)
+            end
+          end
+        end
+
+        def walk_decl(node, symbols)
+          raw = text_for(node).strip
+
+          if raw.include?("@import") && (raw.start_with?("const ") || raw.start_with?("pub const "))
+            sig = raw.sub(/;\z/, "").strip
+            symbols << build_symbol(
+              name: sig,
+              kind: :import,
+              node: node,
+              signature: sig
+            )
+          elsif (m = raw.match(/(?:pub\s+)?const\s+([A-Za-z0-9_]+)\s*=\s*(struct|enum)\b/))
+            name = m[1]
+            kind = m[2].to_sym
+            sig = clean_signature(node)
+            symbols << build_symbol(
+              name: name,
+              kind: kind,
+              node: node,
+              signature: sig.empty? ? "const #{name} = #{kind}" : sig
+            )
+          else
+            # Check for a function definition inside this Decl. The function
+            # name lives on the `identifier` child of a function_definition
+            # node — the old `child_by_field_name("function")` lookup only
+            # exists on call expressions and is nil on a function decl, which
+            # silently dropped every Zig function from the symbol graph.
+            fn_def = find_function(node)
+            if fn_def
+              name_node = fn_def.child_by_field_name("function") ||
+                          fn_def.child_by_field_name("name") ||
+                          find_identifier(fn_def)
+              if name_node
+                fn_name = text_for(name_node).strip
+                calls = extract_calls(node, ["FieldOrFnCall", "call_expression"])
+                sig = clean_signature(fn_def)
+                symbols << build_symbol(
+                  name: fn_name,
+                  kind: :function,
+                  node: node,
+                  signature: sig.empty? ? "fn #{fn_name}()" : sig,
+                  calls: calls
+                )
+              end
+            end
+          end
+        end
+
+        # Locates the node that owns this Decl's function definition. Zig
+        # exposes it under several kind names across grammar versions, so we
+        # accept every one we know about rather than only "FnProto".
+        def find_function(node)
+          return node if FN_KINDS.include?(node.kind)
+
+          (0...node.named_child_count).each do |i|
+            found = find_function(node.named_child(i))
+            return found if found
+          end
+          nil
+        end
+
+        # Walks the subtree for the first identifier node — used as a fallback
+        # when the grammar does not expose the function name as a named field.
+        def find_identifier(node)
+          return node if node.kind == "identifier"
+
+          (0...node.named_child_count).each do |i|
+            found = find_identifier(node.named_child(i))
+            return found if found
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubik/ast/treesitter_extractor.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+begin
+  require "tree_sitter_language_pack"
+  TREE_SITTER_AVAILABLE = true
+rescue LoadError
+  TREE_SITTER_AVAILABLE = false
+end
+
+require_relative "treesitter/base_walker"
+require_relative "treesitter/python_walker"
+require_relative "treesitter/go_walker"
+require_relative "treesitter/rust_walker"
+require_relative "treesitter/typescript_walker"
+require_relative "treesitter/c_walker"
+require_relative "treesitter/zig_walker"
+
+module Rubik
+  module AST
+    class TreeSitterExtractor
+      LANGUAGE_MAP = {
+        ".py" => { parser: "python", walker: TreeSitter::PythonWalker },
+        ".go" => { parser: "go", walker: TreeSitter::GoWalker },
+        ".rs" => { parser: "rust", walker: TreeSitter::RustWalker },
+        ".ts" => { parser: "typescript", walker: TreeSitter::TypeScriptWalker },
+        ".tsx" => { parser: "tsx", walker: TreeSitter::TypeScriptWalker },
+        ".js" => { parser: "javascript", walker: TreeSitter::TypeScriptWalker },
+        ".jsx" => { parser: "javascript", walker: TreeSitter::TypeScriptWalker },
+        ".c" => { parser: "c", walker: TreeSitter::CWalker },
+        ".h" => { parser: "c", walker: TreeSitter::CWalker },
+        ".cpp" => { parser: "cpp", walker: TreeSitter::CWalker },
+        ".hpp" => { parser: "cpp", walker: TreeSitter::CWalker },
+        ".zig" => { parser: "zig", walker: TreeSitter::ZigWalker }
+      }.freeze
+
+      class << self
+        def available?
+          TREE_SITTER_AVAILABLE && defined?(TreeSitterLanguagePack) && TreeSitterLanguagePack.respond_to?(:get_parser)
+        end
+
+        def supports?(ext)
+          LANGUAGE_MAP.key?(ext.to_s.downcase)
+        end
+
+        def supported_extensions
+          LANGUAGE_MAP.keys
+        end
+
+        def parser_for(lang_name)
+          Thread.current[:rubik_ts_parsers] ||= {}
+          Thread.current[:rubik_ts_parsers][lang_name] ||= TreeSitterLanguagePack.get_parser(lang_name)
+        end
+
+        def clear_parsers!
+          Thread.current[:rubik_ts_parsers]&.clear
+        end
+
+        def extract(file_path, content = nil)
+          return nil unless available?
+
+          ext = File.extname(file_path).downcase
+          mapping = LANGUAGE_MAP[ext]
+          return nil unless mapping
+
+          code = content || (File.exist?(file_path) ? File.read(file_path) : "")
+          return [] if code.empty?
+
+          code = code.encode("UTF-8", invalid: :replace, undef: :replace) unless code.valid_encoding?
+
+          parser = parser_for(mapping[:parser])
+          return nil unless parser
+
+          tree = parser.parse(code)
+          return nil unless tree&.root_node
+
+          walker = mapping[:walker].new(file_path, code)
+          symbols = walker.walk(tree.root_node)
+          has_err = if tree.root_node.respond_to?(:has_error?)
+                      tree.root_node.has_error?
+                    elsif tree.root_node.respond_to?(:has_error)
+                      tree.root_node.has_error
+                    end
+          return nil if has_err && (symbols.nil? || symbols.empty?)
+
+          symbols
+        rescue StandardError, SystemStackError, ScriptError => e
+          warn "[WARN] TreeSitter extraction failed for #{file_path}: #{e.message}" if ENV["RUBIK_DEBUG"]
+          nil
+        end
+      end
+    end
+  end
+end