rubik 0.1.0

data/lib/rubik/ast/graph.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require_relative "symbol"
+require_relative "extractor"
+require_relative "cache_store"
+
+module Rubik
+  module AST
+    class SymbolMap < Hash
+      attr_reader :qualified_symbols
+
+      def initialize(plain = {}, qualified = {})
+        super()
+        @qualified_symbols = qualified
+        replace(plain)
+      end
+
+      def [](key)
+        super || @qualified_symbols[key]
+      end
+
+      # Checks whether a symbol key exists in either the plain or qualified symbol maps.
+      #
+      # @param key [String] the symbol name or qualified key to look up
+      # @return [Boolean] true if the key is present in either map
+      def key?(key)
+        super || @qualified_symbols.key?(key)
+      end
+
+      # deprecated: use #key?; kept for callers using the legacy Hash#has_key? spelling.
+      alias has_key? key?
+    end
+
+    class Graph
+      def initialize
+        @symbols = {}
+        @qualified_symbols = {}
+        @file_symbols = Hash.new { |h, k| h[k] = [] }
+        @mutex = Mutex.new
+      end
+
+      def symbols
+        @mutex.synchronize do
+          SymbolMap.new(@symbols.dup, @qualified_symbols.dup)
+        end
+      end
+
+      def file_symbols
+        @mutex.synchronize { @file_symbols.dup }
+      end
+
+      def clear
+        @mutex.synchronize do
+          @symbols.clear
+          @qualified_symbols.clear
+          @file_symbols.clear
+        end
+      end
+
+      def index_file(file_path, content = nil)
+        @mutex.synchronize do
+          _index_file_unlocked(file_path, content)
+        end
+      end
+
+      def remove_file(file_path)
+        @mutex.synchronize do
+          _remove_file_unlocked(file_path)
+        end
+      end
+
+      def load_from_cache(cache_store)
+        return 0 unless cache_store
+
+        loaded_files = cache_store.load
+        return 0 if loaded_files.nil? || loaded_files.empty?
+
+        @mutex.synchronize do
+          total_symbols = 0
+          loaded_files.each do |file_path, syms|
+            ext = File.extname(file_path).downcase
+            lang = CacheStore::LANGUAGE_MAP[ext] || "code"
+
+            @file_symbols[file_path] = syms.dup
+            syms.each do |sym|
+              @symbols[sym.name] = sym
+              q_key = "#{lang}:#{file_path}##{sym.name}"
+              @qualified_symbols[q_key] = sym
+              total_symbols += 1
+            end
+          end
+          total_symbols
+        end
+      end
+
+      def save_to_cache(cache_store)
+        return false unless cache_store
+
+        snapshot = @mutex.synchronize { @file_symbols.dup }
+        cache_store.save(snapshot)
+      end
+
+      # Duplicate-free symbol search: iterates the live map under the mutex
+      # instead of copying it via #symbols (callers only read immutable
+      # attributes, so handing out the Symbol objects is as safe as the
+      # snapshot was — it shared the very same objects).
+      def search_symbols(query)
+        q = query.to_s.downcase
+        @mutex.synchronize do
+          @symbols.values.select { |sym| sym.name.downcase.include?(q) }
+        end
+      end
+
+      # The callers of `symbol_name` are the symbols whose `calls` list
+      # actually references it. `symbol_name` may arrive either as a plain
+      # identifier (e.g. "add") or as a qualified key (e.g.
+      # "rust:src/lib.rs##Config::new") — the `!refs` / callers flow does the
+      # latter. We resolve it to the set of concrete callee spellings it maps
+      # to (plain name plus every qualified key that owns that name), then keep
+      # the symbols whose calls contain one of those spellings. This mirrors the
+      # plain-then-qualified lookup used by #smart_context_for / #symbol_definition
+      # and avoids the previous backwards test, which flagged any symbol merely
+      # mentioning the substring as a caller.
+      def callers_of(symbol_name)
+        @mutex.synchronize do
+          target_names = caller_targets(symbol_name)
+          return [] if target_names.empty?
+
+          @symbols.values.uniq.select do |sym|
+            sym.calls.any? { |c| target_names.include?(c) }
+          end
+        end
+      end
+
+      def smart_context_for(symbol_name)
+        @mutex.synchronize do
+          target = @symbols[symbol_name] ||
+                   @qualified_symbols[symbol_name] ||
+                   @symbols.values.find { |s| s.name == symbol_name || s.name.end_with?("##{symbol_name}") }
+          return "" unless target
+
+          context_blocks = []
+          context_blocks << "# Target symbol: #{target.name} (#{target.file}:#{target.line_start}-#{target.line_end})"
+          context_blocks << target.body if target.body
+
+          target.calls.each do |called_name|
+            matching = @symbols[called_name] ||
+                       @qualified_symbols[called_name] ||
+                       @symbols.values.find { |s| s.name == called_name || s.name.end_with?("##{called_name}") }
+            if matching
+              context_blocks << "# Dependency signature: #{matching.name}"
+              context_blocks << matching.signature
+            end
+          end
+
+          context_blocks.join("\n\n")
+        end
+      end
+
+      def outline_for(file_path)
+        @mutex.synchronize do
+          syms = _get_file_symbols_unlocked(file_path)
+          syms = _index_file_unlocked(file_path) if syms.empty? && File.exist?(file_path)
+
+          return "No symbols found in '#{file_path}'." if syms.empty?
+
+          lines = ["=== Outline for #{file_path} (#{syms.size} symbols) ==="]
+          syms.sort_by(&:line_start).each do |sym|
+            indent = [:class, :struct, :module, :interface, :type].include?(sym.kind) ? "" : "  "
+            lines << "#{indent}• [#{sym.kind.to_s.upcase}] #{sym.name} (lines #{sym.line_start}-#{sym.line_end}) -> #{sym.signature}"
+          end
+          lines.join("\n")
+        end
+      end
+
+      def symbol_definition(symbol_name)
+        @mutex.synchronize do
+          target = @symbols[symbol_name] ||
+                   @qualified_symbols[symbol_name] ||
+                   @symbols.values.find do |s|
+                     s.name.downcase == symbol_name.downcase ||
+                       s.name.end_with?("##{symbol_name}") ||
+                       s.name.end_with?(".#{symbol_name}")
+                   end
+          return nil unless target
+
+          {
+            name: target.name,
+            kind: target.kind,
+            file: target.file,
+            line_start: target.line_start,
+            line_end: target.line_end,
+            signature: target.signature,
+            body: target.body,
+            docstring: target.docstring,
+            calls: target.calls
+          }
+        end
+      end
+
+      private
+
+      # Concrete callee spellings that a reference to `symbol_name` might use.
+      # `symbol_name` may be a bare identifier ("Config::new") or a qualified key
+      # ("rust:src/lib.rs##Config::new"); we pull the trailing identifier in both
+      # cases and collect every symbol that owns that name so a call site is
+      # matched whether it wrote the bare identifier or the fully-qualified key.
+      # Caller MUST hold @mutex.
+      def caller_targets(symbol_name)
+        bare = symbol_name.split("##").last.to_s
+        return [] if bare.empty?
+
+        names = [bare]
+        @symbols.each_value do |sym|
+          names << sym.name if sym.name == bare || sym.name.end_with?("##{bare}")
+        end
+        names.uniq
+      end
+
+      def _index_file_unlocked(file_path, content = nil)
+        _remove_file_unlocked(file_path)
+
+        extracted = Extractor.extract(file_path, content)
+        ext = File.extname(file_path).downcase
+        lang = CacheStore::LANGUAGE_MAP[ext] || "code"
+
+        extracted.each do |sym|
+          @symbols[sym.name] = sym
+          q_key = "#{lang}:#{file_path}##{sym.name}"
+          @qualified_symbols[q_key] = sym
+          @file_symbols[file_path] << sym
+        end
+        extracted
+      end
+
+      def _remove_file_unlocked(file_path)
+        existing = @file_symbols.delete(file_path)
+        if existing.nil? || existing.empty?
+          canonical_target = Rubik::Platform.normalize_path(File.expand_path(file_path))
+          matching_key = @file_symbols.keys.find do |k|
+            Rubik::Platform.path_equal?(k, file_path) ||
+              Rubik::Platform.normalize_path(File.expand_path(k)) == canonical_target
+          end
+          existing = @file_symbols.delete(matching_key) if matching_key
+        end
+
+        return unless existing && !existing.empty?
+
+        ext = File.extname(file_path).downcase
+        lang = CacheStore::LANGUAGE_MAP[ext] || "code"
+
+        existing.each do |sym|
+          @symbols.delete(sym.name) if @symbols[sym.name] == sym
+          @qualified_symbols.delete("#{lang}:#{file_path}##{sym.name}")
+          @qualified_symbols.delete("#{lang}:#{sym.file}##{sym.name}") if sym.file
+        end
+      end
+
+      def _get_file_symbols_unlocked(file_path)
+        syms = @file_symbols[file_path]
+        return syms if syms && !syms.empty?
+
+        canonical_target = Rubik::Platform.normalize_path(File.expand_path(file_path))
+        matching_key = @file_symbols.keys.find do |k|
+          Rubik::Platform.path_equal?(k, file_path) ||
+            Rubik::Platform.normalize_path(File.expand_path(k)) == canonical_target
+        end
+        (matching_key && @file_symbols[matching_key]) || []
+      end
+    end
+  end
+end

data/lib/rubik/ast/python_extractor.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative "symbol"
+require_relative "body_loader"
+
+module Rubik
+  module AST
+    class PythonExtractor
+      include BodyLoader
+
+      EXCLUDED_KEYWORDS = Set.new(
+        ["def", "async", "if", "elif", "else", "for", "while", "return", "print", "len", "range", "super"]
+      ).freeze
+
+      def self.extract(file_path, content = nil)
+        new(file_path, content).extract
+      end
+
+      def initialize(file_path, content = nil)
+        @file_path = file_path
+        @content = content || (File.exist?(file_path) ? File.read(file_path) : "")
+        @lines = @content.lines
+      end
+
+      def extract
+        symbols = []
+        return symbols if @content.empty?
+
+        current_class = nil
+        i = 0
+
+        while i < @lines.size
+          line = @lines[i]
+          line_num = i + 1
+          indent = line[/^\s*/].size
+          stripped = line.strip
+
+          if stripped.start_with?("import ") || stripped.start_with?("from ")
+            symbols << Symbol.new(
+              name: stripped,
+              kind: :import,
+              file: @file_path,
+              line_start: line_num,
+              line_end: line_num,
+              signature: stripped
+            )
+          elsif (match = stripped.match(/^class\s+([A-Za-z0-9_]+)(?:\((.*?)\))?:/))
+            class_name = match[1]
+            current_class = class_name
+            end_line = find_block_end(i, indent)
+            symbols << Symbol.new(
+              name: class_name,
+              kind: :class,
+              file: @file_path,
+              line_start: line_num,
+              line_end: end_line,
+              signature: stripped,
+              body_loader: body_loader_for(line_num, end_line)
+            )
+          elsif (match = stripped.match(/^(?:async\s+)?def\s+([A-Za-z0-9_]+)\s*\((.*?)\):/))
+            fn_name = match[1]
+            full_name = indent.positive? && current_class ? "#{current_class}.#{fn_name}" : fn_name
+            end_line = find_block_end(i, indent)
+            body_for_calls = extract_lines(line_num, end_line)
+            calls = extract_calls(body_for_calls, fn_name)
+
+            symbols << Symbol.new(
+              name: full_name,
+              kind: :function,
+              file: @file_path,
+              line_start: line_num,
+              line_end: end_line,
+              signature: stripped,
+              calls: calls,
+              body_loader: body_loader_for(line_num, end_line)
+            )
+          end
+
+          current_class = nil if indent.zero? && !stripped.start_with?("class ") && !stripped.empty?
+
+          i += 1
+        end
+
+        symbols
+      end
+
+      private
+
+      def extract_calls(body, self_name)
+        calls = Set.new
+        body.scan(/\b[A-Za-z0-9_]+(?=\s*\()/) do |c|
+          calls << c unless c == self_name || EXCLUDED_KEYWORDS.include?(c)
+        end
+        calls.to_a
+      end
+
+      def find_block_end(start_idx, base_indent)
+        last_line = start_idx + 1
+
+        ((start_idx + 1)..(@lines.size - 1)).each do |idx|
+          line = @lines[idx]
+          next if line.strip.empty? || line.strip.start_with?("#")
+
+          indent = line[/^\s*/].size
+          return last_line if indent <= base_indent
+
+          last_line = idx + 1
+        end
+
+        @lines.size
+      end
+
+      def extract_lines(start_line, end_line)
+        s_idx = [start_line - 1, 0].max
+        e_idx = [end_line - 1, @lines.size - 1].min
+        @lines[s_idx..e_idx].join
+      end
+    end
+  end
+end

data/lib/rubik/ast/ruby_extractor.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require_relative "symbol"
+require_relative "body_loader"
+require_relative "fallback_cleaner"
+
+module Rubik
+  module AST
+    class RubyExtractor
+      EXCLUDED_CALLS = Set.new(["def", "if", "unless", "case", "return", "raise", "puts", "p", "print", "require"]).freeze
+      begin
+        require "prism"
+        PRISM_AVAILABLE = true
+      rescue LoadError
+        PRISM_AVAILABLE = false
+      end
+
+      include BodyLoader
+
+      def self.extract(file_path, content = nil)
+        new(file_path, content).extract
+      end
+
+      def initialize(file_path, content = nil, force_fallback: false)
+        @file_path = file_path
+        @content = content || (File.exist?(file_path) ? File.read(file_path) : "")
+        @lines = nil
+        # force_fallback exists so the Prism-less scanner stays testable even
+        # on installs where prism is available (PRISM_AVAILABLE cannot be
+        # stubbed; it is resolved at require time).
+        @use_prism = PRISM_AVAILABLE && !force_fallback
+        @code_lines = nil
+      end
+
+      # Line array is materialized on demand: the Prism walk only needs AST
+      # locations, so a parse-only session over a file whose bodies are never
+      # read never pays for String#lines. The fallback scanner and the lazy
+      # body loader share this memo.
+      def lines
+        @lines ||= @content.lines
+      end
+
+      # Quote/comment/heredoc-cleaned view of the source for the fallback
+      # scanner only (Plan 54 D-7); body loading keeps reading the raw lines.
+      def code_lines
+        @code_lines ||= FallbackCleaner.code_lines(lines)
+      end
+
+      def extract
+        symbols = []
+        return symbols if @content.empty?
+
+        if @use_prism
+          extract_via_prism(symbols)
+        else
+          extract_via_fallback(symbols)
+        end
+        symbols
+      end
+
+      private
+
+      def extract_via_prism(symbols)
+        result = Prism.parse(@content)
+        return unless result.value
+
+        walk_node(result.value, nil, symbols)
+      end
+
+      def walk_node(node, current_scope, symbols)
+        return unless node
+
+        case node
+        when Prism::ClassNode
+          name = node.name.to_s
+          line_start = node.location.start_line
+          line_end = node.location.end_line
+          symbols << Symbol.new(
+            name: name,
+            kind: :class,
+            file: @file_path,
+            line_start: line_start,
+            line_end: line_end,
+            signature: "class #{name}"
+          )
+          node.compact_child_nodes.each { |child| walk_node(child, name, symbols) }
+
+        when Prism::ModuleNode
+          name = node.name.to_s
+          line_start = node.location.start_line
+          line_end = node.location.end_line
+          symbols << Symbol.new(
+            name: name,
+            kind: :module,
+            file: @file_path,
+            line_start: line_start,
+            line_end: line_end,
+            signature: "module #{name}"
+          )
+          node.compact_child_nodes.each { |child| walk_node(child, name, symbols) }
+
+        when Prism::DefNode
+          method_name = node.name.to_s
+          full_name = current_scope ? "#{current_scope}##{method_name}" : method_name
+          line_start = node.location.start_line
+          line_end = node.location.end_line
+          calls = extract_calls_from_node(node, method_name)
+
+          symbols << Symbol.new(
+            name: full_name,
+            kind: :function,
+            file: @file_path,
+            line_start: line_start,
+            line_end: line_end,
+            signature: "def #{method_name}",
+            calls: calls,
+            body_loader: body_loader_for(line_start, line_end)
+          )
+
+        when Prism::CallNode
+          name = node.name.to_s
+          if ["require", "require_relative"].include?(name)
+            line_num = node.location.start_line
+            args_node = node.arguments&.arguments
+            arg = args_node&.first&.slice.to_s
+            symbols << Symbol.new(
+              name: "#{name} #{arg}",
+              kind: :import,
+              file: @file_path,
+              line_start: line_num,
+              line_end: line_num,
+              signature: "#{name} #{arg}"
+            )
+          end
+          node.compact_child_nodes.each { |child| walk_node(child, current_scope, symbols) }
+
+        when Prism::ProgramNode, Prism::StatementsNode
+          node.compact_child_nodes.each { |child| walk_node(child, current_scope, symbols) }
+        else
+          node.compact_child_nodes.each { |child| walk_node(child, current_scope, symbols) } if node.respond_to?(:compact_child_nodes)
+        end
+      end
+
+      def extract_calls_from_node(node, self_name)
+        calls = []
+        queue = [node]
+
+        while (curr = queue.pop)
+          if curr.is_a?(Prism::CallNode)
+            cname = curr.name.to_s
+            calls << cname unless cname == self_name || ["require", "require_relative", "raise", "puts", "p", "print"].include?(cname)
+          end
+          queue.concat(curr.compact_child_nodes) if curr.respond_to?(:compact_child_nodes)
+        end
+
+        calls.uniq
+      end
+
+      def extract_via_fallback(symbols)
+        current_class_or_module = nil
+        i = 0
+
+        while i < code_lines.size
+          line = code_lines[i]
+          line_num = i + 1
+          stripped = line.strip
+
+          if stripped.start_with?("class ") || stripped.start_with?("module ")
+            kind = stripped.start_with?("class ") ? :class : :module
+            name = stripped.split(/\s+/)[1].to_s.split("<").first.to_s.strip
+            current_class_or_module = name
+            end_line = find_matching_end(i)
+
+            symbols << Symbol.new(
+              name: name,
+              kind: kind,
+              file: @file_path,
+              line_start: line_num,
+              line_end: end_line,
+              signature: stripped
+            )
+          elsif stripped.start_with?("def ")
+            method_name = stripped.sub(/^def\s+/, "").split(/[(\s;]/).first.strip
+            full_name = current_class_or_module ? "#{current_class_or_module}##{method_name}" : method_name
+            end_line = find_matching_end(i)
+            calls_src = lines[(line_num - 1)..(end_line - 1)]&.join.to_s
+            calls = []
+            calls_src.scan(/\b([a-z_][a-zA-Z0-9_]*)\s*\(/) do |m|
+              c = m[0]
+              calls << c unless c == method_name || EXCLUDED_CALLS.include?(c) || calls.include?(c)
+            end
+
+            symbols << Symbol.new(
+              name: full_name,
+              kind: :function,
+              file: @file_path,
+              line_start: line_num,
+              line_end: end_line,
+              signature: stripped,
+              calls: calls,
+              body_loader: body_loader_for(line_num, end_line)
+            )
+          elsif stripped.start_with?("require ") || stripped.start_with?("require_relative ")
+            symbols << Symbol.new(
+              name: stripped,
+              kind: :import,
+              file: @file_path,
+              line_start: line_num,
+              line_end: line_num,
+              signature: stripped
+            )
+          end
+
+          i += 1
+        end
+      end
+
+      def find_matching_end(start_idx)
+        depth = 0
+        (start_idx..(code_lines.size - 1)).each do |idx|
+          line = code_lines[idx]
+          next if line.strip.empty?
+
+          depth += openers_in(line)
+          depth -= line.scan(/\bend\b/).size
+          return idx + 1 if depth <= 0 && idx >= start_idx
+        end
+        start_idx + 1
+      end
+
+      # End-matching counts end-consuming openers (class/module/def/do/case/
+      # begin/for plus statement-position if/unless/while/until) against
+      # `end` tokens over FallbackCleaner lines (Plan 54 D-7). Modifier
+      # conditionals and endless defs consume no end and are excluded.
+      def openers_in(line)
+        count = line.scan(/\b(?:class|module|def|do|case|begin|for)\b/).size
+        count -= 1 if endless_def?(line)
+        count += 1 if line.match?(/\A\s*(?:if|unless|while|until)\b/)
+        count += line.scan(/[=;]\s*(?:if|unless|while|until)\b/).size
+        count
+      end
+
+      # `def name = body` and `def name(x) = body` consume no end. Setter defs
+      # (`def name=(v)`) do, so a `=` immediately followed by `(` is excluded.
+      def endless_def?(line)
+        m = line.match(/\A\s*def\s+[\w.]+(?:\([^)]*\))?/)
+        return false unless m
+
+        rest = line[m[0].size..].to_s
+        rest.match?(/\A\s*=\s*\S/) && !rest.match?(/\A\s*=\s*\(/)
+      end
+
+      def extract_lines(start_line, end_line)
+        s_idx = [start_line - 1, 0].max
+        e_idx = [end_line - 1, lines.size - 1].min
+        lines[s_idx..e_idx].join
+      end
+    end
+  end
+end