superkick 0.1.0

data/lib/superkick/local/repository_source.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Superkick
+  module Local
+    # Local::RepositorySource — scans a local directory for repositories.
+    #
+    # At depth 0 (the default), the path itself is treated as a single repository.
+    # At depth > 0, subdirectories are scanned and each becomes a repository.
+    #
+    # Config:
+    #   type: local
+    #   path: /home/user/projects          # required — directory to scan
+    #   depth: 0                           # optional — 0 = single repo (default), 1+ = scan children
+    #   version_controlled_only: true       # optional — at depth > 0, only include VCS-managed dirs (default true)
+    #   context_documents: [readme, ...]   # optional — document names to discover (default [])
+    #   exclude: [node_modules, .hidden]   # optional — directory names to skip (depth > 0 only)
+    #   name: :api                         # optional — override repo name (depth 0 only)
+    class RepositorySource < Superkick::RepositorySource
+      def self.type = :local
+
+      def self.setup_label = "Local"
+
+      def self.setup_config
+        <<~YAML
+          my_project:
+            path: ~/projects/my-project
+            # dependencies:                      # other repository names this depends on
+            #   - shared
+        YAML
+      end
+
+      def initialize(config = {})
+        @base_path = config[:path] && File.expand_path(config[:path])
+        @name_override = config[:name]&.to_sym
+        @depth = config.fetch(:depth, 0).to_i.clamp(0, 5)
+        @version_controlled_only = config.fetch(:version_controlled_only, true)
+        @exclude = Array(config[:exclude]).map(&:to_s).to_set
+        @context_document_patterns = merge_context_document_patterns(config[:context_documents])
+
+        @repositories = scan.freeze
+      end
+
+      attr_reader :repositories
+
+      private
+
+      def scan
+        return {} unless @base_path && Dir.exist?(@base_path)
+
+        if @depth == 0
+          scan_single
+        else
+          scan_children
+        end
+      end
+
+      # Depth 0: the path itself is one repository.
+      def scan_single
+        name = @name_override || File.basename(@base_path).to_sym
+        vcs_result = Superkick::VersionControl::Probe.detect_from_path(path: @base_path)
+
+        {
+          name => Repository.new(
+            name:,
+            path: @base_path,
+            version_control: vcs_result&.fetch(:type, nil),
+            context_documents: discover_context_documents(@base_path)
+          )
+        }
+      end
+
+      # Depth > 0: scan subdirectories.
+      def scan_children
+        entries = collect_entries(@base_path, @depth)
+        entries.each_with_object({}) do |dir, h|
+          name = File.basename(dir).to_sym
+          next if h.key?(name) # first-found wins for duplicate basenames
+
+          vcs_result = Superkick::VersionControl::Probe.detect_from_path(path: dir)
+          h[name] = Repository.new(
+            name:,
+            path: dir,
+            version_control: vcs_result&.fetch(:type, nil),
+            context_documents: discover_context_documents(dir)
+          )
+        end
+      end
+
+      def collect_entries(base, remaining_depth)
+        return [] unless remaining_depth > 0
+
+        dirs = Dir.children(base)
+          .map { File.join(base, it) }
+          .select { File.directory?(it) }
+          .reject { @exclude.include?(File.basename(it)) }
+          .reject { File.basename(it).start_with?(".") }
+
+        if remaining_depth == 1
+          @version_controlled_only ? dirs.select { detect_vcs_for_dir(it) } : dirs
+        else
+          # At intermediate depths, recurse into subdirectories
+          dirs.flat_map { collect_entries(it, remaining_depth - 1) }
+        end
+      rescue Errno::ENOENT, Errno::EACCES
+        []
+      end
+
+      def detect_vcs_for_dir(dir)
+        Superkick::VersionControl::Probe.detect_from_path(path: dir)
+      end
+
+      def merge_context_document_patterns(per_source_config)
+        global = Superkick.config.resolved_context_document_patterns
+        local = resolve_context_document_entries(per_source_config)
+        global.merge(local)
+      end
+
+      def resolve_context_document_entries(config)
+        return {} unless config.is_a?(Array) && config.any?
+
+        config.each_with_object({}) do |entry, h|
+          if entry.is_a?(Hash) && entry[:name] && entry[:pattern]
+            h[entry[:name].to_sym] = entry[:pattern].to_s
+          elsif entry.is_a?(String) || entry.is_a?(Symbol)
+            name = entry.to_sym
+            pattern = Repository::CONTEXT_DOCUMENT_PATTERNS[name]
+            h[name] = pattern if pattern
+          end
+        end
+      end
+
+      def discover_context_documents(dir)
+        return {} if @context_document_patterns.empty?
+
+        @context_document_patterns.each_with_object({}) do |(name, pattern), docs|
+          match = Dir.glob(File.join(dir, pattern)).first
+          next unless match && File.file?(match)
+
+          docs[name] = File.read(match)
+        rescue Errno::ENOENT, Errno::EACCES
+          # skip unreadable files
+        end
+      end
+    end
+  end
+
+  RepositorySource.register(Local::RepositorySource)
+end