hind 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fa041a7ffe7e916e1f3715500d21a9dea2a3a6ce60990be8cf4e7578f704702
-  data.tar.gz: '0779f87c520ddc1edddf0448c96d596194982d5b87fa5c380bb3a1132500bd9e'
+  metadata.gz: 66f58f99f053b938815d051ff6404a478a4f340178f74556ce6ab63f0a93c2e4
+  data.tar.gz: 02e04a6c88687f9baf37013fc216dc7df52b5fa6e81f60170cbb31146335c91b
 SHA512:
-  metadata.gz: 397847759b6c959511602d276eee22f7e89959c5858d840cf8398b874a39ef6ccfeec8d876e9c0539d5cc0bc0cce77cb1e297b7fabc30c9a4562bfb7e85ddb7b
-  data.tar.gz: 5c823067473c8b784a4868bf696b4374735b548eb8eb9341fb887dc78028e9223aeaac7172c621c624d0e8a3de221b50e101e908177626f9c316797e8ce2de70
+  metadata.gz: 529d648a5f0677180c4c73daa8d316661f4b82b7bd4802318c8bb42a7ed7bd8d2ffb38b69a82a274483638ea7bc1c161ea9d6bb6f3c7f84e3ff75464a1968c75
+  data.tar.gz: dc734f7623cffa1c0cc6260627d14916e6e9809c3b06afcad1bd87015c8c32b8bbe979ed978abb922adc3af7a19c7c3099f3217c00016711260aacd5079fab6c

data/exe/hind

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'hind'
-require 'hind/cli'
+require_relative '../lib/hind'
+require_relative '../lib/hind/cli'
 
 Hind::CLI.start(ARGV)

data/lib/hind/cli.rb

@@ -4,6 +4,7 @@ require 'thor'
 require 'json'
 require 'pathname'
 require 'fileutils'
+require 'yaml'
 
 module Hind
   class CLI < Thor
@@ -16,43 +17,47 @@ module Hind
     method_option :glob, type: :string, aliases: '-g', default: '**/*.rb', desc: 'File pattern to match'
     method_option :force, type: :boolean, aliases: '-f', desc: 'Overwrite output file if it exists'
     method_option :exclude, type: :array, aliases: '-e', desc: 'Patterns to exclude'
+    method_option :workers, type: :numeric, aliases: '-w', default: 1, desc: 'Number of parallel workers'
     def lsif
-      validate_directory(options[:directory])
-      validate_output_file(options[:output], options[:force])
+      config = load_config(options[:config])
+      opts = config.merge(symbolize_keys(options))
 
-      files = find_files(options[:directory], options[:glob], options[:exclude])
-      abort "No files found matching pattern '#{options[:glob]}'" if files.empty?
+      validate_directory(opts[:directory])
+      validate_output_file(opts[:output], opts[:force])
 
-      say "Found #{files.length} files to process", :green if options[:verbose]
+      files = find_files(opts[:directory], opts[:glob], opts[:exclude])
+      abort "No files found matching pattern '#{opts[:glob]}'" if files.empty?
+
+      say "Found #{files.length} files to process", :green if opts[:verbose]
 
       begin
-        generate_lsif(files, options)
-        say "\nLSIF data has been written to: #{options[:output]}", :green if options[:verbose]
-      rescue => e
-        abort "Error generating LSIF: #{e.message}"
+        generate_lsif(files, opts)
+        say "\nLSIF data has been written to: #{opts[:output]}", :green if opts[:verbose]
+      rescue StandardError => e
+        handle_error(e, opts[:verbose])
       end
     end
 
-    desc 'scip', 'Generate SCIP index'
-    method_option :directory, type: :string, aliases: '-d', default: '.', desc: 'Root directory to process'
-    method_option :output, type: :string, aliases: '-o', default: 'index.scip', desc: 'Output file path'
-    method_option :glob, type: :string, aliases: '-g', default: '**/*.rb', desc: 'File pattern to match'
-    method_option :force, type: :boolean, aliases: '-f', desc: 'Overwrite output file if it exists'
-    method_option :exclude, type: :array, aliases: '-e', desc: 'Patterns to exclude'
-    def scip
-      validate_directory(options[:directory])
-      validate_output_file(options[:output], options[:force])
+    desc 'check', 'Check LSIF dump file for validity and provide insights'
+    method_option :file, type: :string, aliases: '-f', default: 'dump.lsif', desc: 'LSIF dump file to check'
+    method_option :json, type: :boolean, desc: 'Output results in JSON format'
+    method_option :strict, type: :boolean, desc: 'Treat warnings as errors'
+    def check
+      abort "Error: File '#{options[:file]}' does not exist" unless File.exist?(options[:file])
 
-      files = find_files(options[:directory], options[:glob], options[:exclude])
-      abort "No files found matching pattern '#{options[:glob]}'" if files.empty?
+      begin
+        checker = Hind::LSIF::Checker.new(options[:file])
+        results = checker.check
 
-      say "Found #{files.length} files to process", :green if options[:verbose]
+        if options[:json]
+          puts JSON.pretty_generate(results)
+        else
+          print_check_results(results)
+        end
 
-      begin
-        generate_scip(files, options)
-        say "\nSCIP data has been written to: #{options[:output]}", :green if options[:verbose]
-      rescue => e
-        abort "Error generating SCIP: #{e.message}"
+        exit(1) if !results[:valid] || (options[:strict] && results[:warnings].any?)
+      rescue StandardError => e
+        handle_error(e, options[:verbose])
       end
     end
 
@@ -61,14 +66,81 @@ module Hind
       say "Hind version #{Hind::VERSION}"
     end
 
+    desc 'init', 'Initialize Hind configuration file'
+    method_option :force, type: :boolean, aliases: '-f', desc: 'Overwrite existing configuration'
+    def init
+      config_file = '.hind.yml'
+      if File.exist?(config_file) && !options[:force]
+        abort "Configuration file already exists. Use --force to overwrite."
+      end
+
+      create_default_config(config_file)
+      say "Created configuration file: #{config_file}", :green
+    end
+
     private
 
+    def generate_lsif(files, options)
+      # Initialize generator with absolute project root
+      generator = Hind::LSIF::Generator.new(
+        {
+          vertex_id: 1,
+          initial: true,
+          projectRoot: File.expand_path(options[:directory])
+        }
+      )
+
+      # Create file content map with relative paths
+      file_contents = {}
+      files.each do |file|
+        absolute_path = File.expand_path(file)
+        relative_path = Pathname.new(absolute_path)
+                              .relative_path_from(Pathname.new(generator.metadata[:projectRoot]))
+                              .to_s
+        file_contents[relative_path] = File.read(absolute_path)
+      rescue StandardError => e
+        warn "Warning: Failed to read file '#{file}': #{e.message}"
+        next
+      end
+
+      File.open(options[:output], 'w') do |output_file|
+        say "First pass: Collecting declarations...", :cyan if options[:verbose]
+
+        # First pass: Process all files to collect declarations
+        declaration_data = generator.collect_declarations(file_contents)
+
+        say "Found #{declaration_data[:declarations].size} declarations", :cyan if options[:verbose]
+        say "Processing files...", :cyan if options[:verbose]
+
+        # Second pass: Process each file
+        file_contents.each do |relative_path, content|
+          if options[:verbose]
+            say "Processing file: #{relative_path}", :cyan
+          end
+
+          lsif_data = generator.process_file(
+            content: content,
+            uri: relative_path
+          )
+
+          output_file.puts(lsif_data.map(&:to_json).join("\n"))
+        end
+
+        # Write cross-reference data
+        say "Finalizing cross-references...", :cyan if options[:verbose]
+        cross_refs = generator.finalize_cross_references
+        output_file.puts(cross_refs.map(&:to_json).join("\n")) if cross_refs&.any?
+      end
+    end
+
     def validate_directory(directory)
       abort "Error: Directory '#{directory}' does not exist" unless Dir.exist?(directory)
     end
 
     def validate_output_file(output, force)
-      abort "Error: Output file '#{output}' already exists. Use --force to overwrite." if File.exist?(output) && !force
+      if File.exist?(output) && !force
+        abort "Error: Output file '#{output}' already exists. Use --force to overwrite."
+      end
 
       # Ensure output directory exists
       FileUtils.mkdir_p(File.dirname(output))
@@ -78,60 +150,109 @@ module Hind
       pattern = File.join(directory, glob)
       files = Dir.glob(pattern)
 
-      exclude_patterns&.each do |exclude|
-        files.reject! { |f| File.fnmatch?(exclude, f) }
+      if exclude_patterns
+        exclude_patterns.each do |exclude|
+          files.reject! { |f| File.fnmatch?(exclude, f) }
+        end
       end
 
       files
     end
 
-    def generate_lsif(files, options)
-      global_state = Hind::LSIF::GlobalState.new
-      vertex_id = 1
-      initial = true
+    def load_config(config_path)
+      return {} unless config_path && File.exist?(config_path)
 
-      File.open(options[:output], 'w') do |output_file|
-        files.each do |file|
-          say "Processing file: #{file}", :cyan if options[:verbose]
-
-          relative_path = Pathname.new(file).relative_path_from(Pathname.new(options[:directory])).to_s
-
-          begin
-            generator = Hind::LSIF::Generator.new(
-              {
-                uri: relative_path,
-                vertex_id: vertex_id,
-                initial: initial,
-                projectRoot: options[:directory]
-              },
-              global_state
-            )
-
-            output = generator.generate(File.read(file))
-            vertex_id = output.last[:id].to_i + 1
-            output_file.puts(output.map(&:to_json).join("\n"))
-            initial = false
-          rescue => e
-            warn "Warning: Failed to process file '#{file}': #{e.message}"
-            next
-          end
-        end
+      begin
+        YAML.load_file(config_path) || {}
+      rescue StandardError => e
+        abort "Error loading config file: #{e.message}"
       end
     end
 
-    def generate_scip(files, options)
-      raise NotImplementedError, 'SCIP generation not yet implemented'
-      # Similar to generate_lsif but using SCIP generator
+    def create_default_config(config_file)
+      config = {
+        'directory' => '.',
+        'output' => 'dump.lsif',
+        'glob' => '**/*.rb',
+        'exclude' => [
+          'test/**/*',
+          'spec/**/*',
+          'vendor/**/*'
+        ],
+        'workers' => 1
+      }
+
+      File.write(config_file, config.to_yaml)
+    end
+
+    def print_check_results(results)
+      print_check_status(results[:valid])
+      print_check_errors(results[:errors])
+      print_check_warnings(results[:warnings])
+      print_check_statistics(results[:statistics])
     end
 
-    def load_config(config_path)
-      return {} unless config_path && File.exist?(config_path)
+    def print_check_status(valid)
+      status = valid ? "✅ LSIF dump is valid" : "❌ LSIF dump contains errors"
+      say(status, valid ? :green : :red)
+      puts
+    end
 
-      begin
-        YAML.load_file(config_path) || {}
-      rescue => e
-        abort "Error loading config file: #{e.message}"
+    def print_check_errors(errors)
+      return if errors.empty?
+
+      say "Errors:", :red
+      errors.each do |error|
+        say "  • #{error}", :red
+      end
+      puts
+    end
+
+    def print_check_warnings(warnings)
+      return if warnings.empty?
+
+      say "Warnings:", :yellow
+      warnings.each do |warning|
+        say "  • #{warning}", :yellow
+      end
+      puts
+    end
+
+    def print_check_statistics(stats)
+      say "Statistics:", :cyan
+      say "  Total Elements: #{stats[:total_elements]}"
+      say "  Vertices: #{stats[:vertices][:total]}"
+      say "  Edges: #{stats[:edges][:total]}"
+      say "  Vertex/Edge Ratio: #{stats[:vertex_to_edge_ratio]}"
+      puts
+
+      say "  Documents: #{stats[:documents]}"
+      say "  Ranges: #{stats[:ranges]}"
+      say "  Definitions: #{stats[:definitions]}"
+      say "  References: #{stats[:references]}"
+      say "  Hovers: #{stats[:hovers]}"
+      puts
+
+      say "  Vertex Types:", :cyan
+      stats[:vertices][:by_type].each do |type, count|
+        say "    #{type}: #{count}"
+      end
+      puts
+
+      say "  Edge Types:", :cyan
+      stats[:edges][:by_type].each do |type, count|
+        say "    #{type}: #{count}"
       end
     end
+
+    def handle_error(error, verbose)
+      message = "Error: #{error.message}"
+      message += "\n#{error.backtrace.join("\n")}" if verbose
+      abort message
+    end
+
+    def symbolize_keys(hash)
+      hash.transform_keys(&:to_sym)
+    end
   end
 end