makit 0.0.99 → 0.0.111

data/lib/makit/cli/repository_commands.rb

@@ -0,0 +1,661 @@
+# frozen_string_literal: true
+
+require "clamp"
+require "json"
+require "uri"
+require "time"
+require "find"
+
+module Makit
+  module Cli
+    # Consolidated repository management commands
+    # Combines: add, clone, pull, list, remove, import functionality
+    class RepositoryCommand < Clamp::Command
+      self.description = <<~DESC
+        Manage git repositories tracked by Makit.
+
+        Available operations:
+          add     - Add repository URL to tracking list
+          clone   - Clone repository to local directory#{"  "}
+          pull    - Pull latest changes from repository
+          list    - List tracked repositories
+          remove  - Remove tracked repositories by pattern
+          import  - Import repositories from filesystem
+      DESC
+    end
+
+    # Add repository to tracking list
+    class AddRepositoryCommand < Clamp::Command
+      self.description = <<~DESC
+        Add git repository URLs to the tracked list.
+
+        Examples:
+          makit repository add https://github.com/user/repo.git
+          makit repository add git@gitlab.com:group/project.git
+      DESC
+
+      parameter "GIT_URL", "The git repository URL to track", attribute_name: :git_url, required: true
+
+      def execute
+        validate_git_url(git_url)
+
+        if add_to_tracked_list(git_url)
+          puts "✅ Successfully added repository to tracked list: #{git_url}"
+        else
+          puts "ℹ️  Repository already tracked: #{git_url}"
+        end
+      rescue ArgumentError => e
+        warn "❌ Invalid repository URL: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        warn "❌ Failed to add repository: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def validate_git_url(url)
+        raise ArgumentError, "URL cannot be empty" if url.nil? || url.strip.empty?
+
+        url = url.strip
+        valid_patterns = [
+          %r{^https?://\w+[\w.-]*\w+/[\w.-]+/[\w.-]+(?:\.git)?/?$}, # HTTPS
+          %r{^git@[\w.-]+:[\w.-]+/[\w.-]+(?:\.git)?$},              # SSH
+          %r{^ssh://git@[\w.-]+/[\w.-]+/[\w.-]+(?:\.git)?$},        # SSH with ssh://
+          %r{^[\w.-]+@[\w.-]+:[\w.-]+/[\w.-]+(?:\.git)?$},           # Generic SSH
+        ]
+
+        unless valid_patterns.any? { |pattern| url.match?(pattern) }
+          raise ArgumentError, "URL does not match expected git repository format"
+        end
+
+        return unless url.include?("github.com") || url.include?("gitlab.com") || url.include?("bitbucket.org")
+
+        validate_hosted_repository_url(url)
+      end
+
+      def validate_hosted_repository_url(url)
+        if url.start_with?("http")
+          path = URI.parse(url).path.sub(%r{^/}, "").sub(/\.git$/, "").sub(%r{/$}, "")
+        elsif url.include?("@")
+          path = url.split(":").last.sub(/\.git$/, "")
+        end
+
+        parts = path.split("/")
+        raise ArgumentError, "Repository path should be in format 'user/repository'" if parts.length < 2
+
+        parts.each do |part|
+          if part.empty? || part.match?(/[<>:"|?*]/)
+            raise ArgumentError, "Invalid characters in repository path: #{part}"
+          end
+        end
+      end
+
+      def add_to_tracked_list(url)
+        tracked_repos = load_tracked_repositories
+        return false if tracked_repos.any? { |repo| repo["url"] == url }
+
+        new_repo = {
+          "url" => url,
+          "added_at" => Time.now.iso8601,
+          "status" => "tracked",
+        }
+
+        tracked_repos << new_repo
+        save_tracked_repositories(tracked_repos)
+        true
+      end
+
+      def load_tracked_repositories
+        tracked_file = tracked_repositories_file
+        return [] unless File.exist?(tracked_file)
+
+        begin
+          JSON.parse(File.read(tracked_file))
+        rescue JSON::ParserError => e
+          warn "Warning: Could not parse tracked repositories file: #{e.message}"
+          []
+        end
+      end
+
+      def save_tracked_repositories(repositories)
+        tracked_file = tracked_repositories_file
+        FileUtils.mkdir_p(File.dirname(tracked_file))
+        sorted_repos = repositories.sort_by { |repo| repo["url"] }
+        File.write(tracked_file, JSON.pretty_generate(sorted_repos))
+      end
+
+      def tracked_repositories_file
+        File.join(Makit::Directories::ROOT, "tracked_repositories.json")
+      end
+    end
+
+    # Clone repository to local directory
+    class CloneRepositoryCommand < Clamp::Command
+      self.description = <<~DESC
+        Clone git repositories to local directories.
+
+        Examples:
+          makit repository clone https://github.com/user/repo
+          makit repository clone git@github.com:user/repo.git
+      DESC
+
+      parameter "GIT_REPOSITORY", "The git repository URL", attribute_name: :git_repository, required: true
+
+      def execute
+        clone_dir = Makit::Directories.get_clone_directory(git_repository)
+
+        if Dir.exist?(clone_dir)
+          puts "Repository already exists at: #{clone_dir}"
+          return
+        end
+
+        puts "Cloning repository: #{git_repository} to #{clone_dir}"
+
+        begin
+          commands = Makit.clone(git_repository)
+
+          if commands.any? && commands.last.exit_code != 0
+            handle_clone_error(commands.last, clone_dir)
+          elsif !Dir.exist?(clone_dir)
+            warn "Clone operation completed but directory not found: #{clone_dir}"
+            exit 1
+          else
+            puts "Successfully cloned repository to: #{clone_dir}"
+          end
+        rescue ArgumentError => e
+          warn "Invalid repository URL: #{e.message}"
+          exit 1
+        rescue StandardError => e
+          warn "Failed to clone repository: #{git_repository}"
+          puts e.message
+          exit 1
+        end
+      end
+
+      private
+
+      def handle_clone_error(clone_command, clone_dir)
+        summary = "Failed to clone repository: #{git_repository} to #{clone_dir}\n"
+        summary += "Please check the URL and your network connection.\n"
+        summary += "Exit code: #{clone_command.exit_code}\n"
+        summary += "Output: #{clone_command.output}" if clone_command.respond_to?(:output)
+        warn summary
+        exit 1
+      end
+    end
+
+    # Pull latest changes from repository
+    class PullRepositoryCommand < Clamp::Command
+      self.description = <<~DESC
+        Pull latest changes from git repositories.
+
+        Examples:
+          makit repository pull https://github.com/user/repo
+      DESC
+
+      parameter "GIT_REPOSITORY", "The git repository URL", attribute_name: :git_repository, required: true
+
+      def execute
+        commands = Makit.pull(git_repository)
+
+        if commands.any? && commands.last.exit_code.zero?
+          puts "Successfully pulled latest changes from: #{git_repository}"
+        else
+          warn "Failed to pull changes from: #{git_repository}"
+          exit 1
+        end
+      rescue ArgumentError => e
+        warn "Invalid repository URL: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        warn "Failed to pull repository: #{git_repository}"
+        puts e.message
+        exit 1
+      end
+    end
+
+    # List tracked repositories
+    class ListRepositoryCommand < Clamp::Command
+      self.description = <<~DESC
+        List git repositories tracked by Makit.
+
+        Examples:
+          makit repository list
+          makit repository list --details
+          makit repository list --tracked
+      DESC
+
+      option ["--details"], :flag, "Show detailed information about each repository"
+      option ["--paths"], :flag, "Show local paths for each repository"
+      option ["--tracked"], :flag, "Show tracked repository URLs (not cloned)"
+      option ["--all"], :flag, "Show both cloned and tracked repositories"
+      option ["--format"], "FORMAT", "Output format (table, json, plain)", default: "table"
+
+      def execute
+        repositories = discover_repositories
+
+        if repositories.empty?
+          puts "No git repositories found."
+          puts "Use 'makit repository clone <url>' to clone repositories."
+          return
+        end
+
+        case format
+        when "json"
+          output_json(repositories)
+        when "plain"
+          output_plain(repositories)
+        else
+          output_table(repositories)
+        end
+      end
+
+      private
+
+      def discover_repositories
+        repositories = []
+
+        if tracked? && !all?
+          repositories = load_tracked_repositories
+        elsif all?
+          repositories = discover_cloned_repositories
+          tracked_repos = load_tracked_repositories
+          tracked_repos.each do |tracked_repo|
+            unless repositories.any? { |repo| repo[:url] == tracked_repo[:url] }
+              repositories << tracked_repo.merge(type: "tracked")
+            end
+          end
+        else
+          repositories = discover_cloned_repositories
+        end
+
+        repositories.sort_by { |repo| repo[:url] || repo[:name] }
+      end
+
+      def discover_cloned_repositories
+        repositories = []
+        clone_base_dir = Makit::Directories::CLONE
+        return repositories unless Dir.exist?(clone_base_dir)
+
+        Find.find(clone_base_dir) do |path|
+          next unless File.directory?(path) && File.basename(path) == ".git"
+
+          repo_dir = File.dirname(path)
+          repo_info = extract_repository_info(repo_dir)
+          if repo_info
+            repo_info[:type] = "cloned"
+            repositories << repo_info
+          end
+          Find.prune
+        end
+
+        repositories
+      end
+
+      def load_tracked_repositories
+        tracked_file = File.join(Makit::Directories::ROOT, "tracked_repositories.json")
+        return [] unless File.exist?(tracked_file)
+
+        begin
+          tracked_repos = JSON.parse(File.read(tracked_file))
+          tracked_repos.map do |repo|
+            {
+              name: extract_repo_name_from_url(repo["url"]),
+              url: repo["url"],
+              added_at: repo["added_at"],
+              status: repo["status"],
+              type: "tracked",
+            }
+          end
+        rescue JSON::ParserError => e
+          warn "Warning: Could not parse tracked repositories file: #{e.message}"
+          []
+        end
+      end
+
+      def extract_repo_name_from_url(url)
+        if url.include?("/")
+          url.split("/").last.sub(/\.git$/, "")
+        else
+          url
+        end
+      end
+
+      def extract_repository_info(repo_dir)
+        return nil unless Dir.exist?(repo_dir)
+
+        info = {
+          name: File.basename(repo_dir),
+          path: repo_dir,
+          relative_path: repo_dir.sub("#{Makit::Directories::CLONE}/", ""),
+        }
+
+        begin
+          Dir.chdir(repo_dir) do
+            remote_output = `git remote get-url origin 2>/dev/null`.strip
+            info[:url] = remote_output unless remote_output.empty?
+
+            if details?
+              info[:branch] = `git branch --show-current 2>/dev/null`.strip
+              info[:last_commit] = `git log -1 --format="%H %s" 2>/dev/null`.strip
+              info[:last_commit_date] = `git log -1 --format="%ci" 2>/dev/null`.strip
+              info[:status] = `git status --porcelain 2>/dev/null`.strip
+              info[:clean] = info[:status].empty?
+            end
+          end
+        rescue StandardError => e
+          info[:error] = "Cannot read git info: #{e.message}"
+        end
+
+        info
+      end
+
+      def output_table(repositories)
+        if details?
+          output_detailed_table(repositories)
+        else
+          output_simple_table(repositories)
+        end
+      end
+
+      def output_simple_table(repositories)
+        puts "Tracked Git Repositories (#{repositories.length}):"
+        puts "=" * 80
+
+        repositories.each_with_index do |repo, index|
+          type_indicator = repo[:type] == "tracked" ? "📋" : "📁"
+          puts "#{(index + 1).to_s.rjust(3)}. #{type_indicator} #{repo[:url] || repo[:name]}"
+          puts "     Path: #{repo[:path] || "Not cloned"}" if paths?
+          puts "     Type: #{repo[:type]&.capitalize || "Unknown"}" if all? || tracked?
+          puts
+        end
+      end
+
+      def output_detailed_table(repositories)
+        puts "Tracked Git Repositories (#{repositories.length}):"
+        puts "=" * 120
+
+        repositories.each_with_index do |repo, index|
+          type_indicator = repo[:type] == "tracked" ? "📋" : "📁"
+          puts "#{(index + 1).to_s.rjust(3)}. #{type_indicator} #{repo[:url] || repo[:name]}"
+          puts "     Type:   #{repo[:type]&.capitalize || "Unknown"}"
+          puts "     Path:   #{repo[:path] || "Not cloned"}" if repo[:type] != "tracked" || all?
+          puts "     Branch: #{repo[:branch]}" if repo[:branch] && !repo[:branch].empty?
+          puts "     Status: #{repo[:clean] ? "Clean" : "Modified"}" if repo[:type] == "cloned"
+
+          if repo[:last_commit] && !repo[:last_commit].empty?
+            commit_parts = repo[:last_commit].split(" ", 2)
+            commit_hash = commit_parts[0][0..7] if commit_parts[0]
+            commit_msg = commit_parts[1] if commit_parts[1]
+            puts "     Commit: #{commit_hash} - #{commit_msg}"
+          end
+
+          puts "     Date:   #{repo[:last_commit_date]}" if repo[:last_commit_date] && !repo[:last_commit_date].empty?
+          puts "     Added:  #{repo[:added_at]}" if repo[:added_at]
+          puts "     Error:  #{repo[:error]}" if repo[:error]
+          puts
+        end
+      end
+
+      def output_json(repositories)
+        puts JSON.pretty_generate({
+                                    count: repositories.length,
+                                    repositories: repositories,
+                                  })
+      end
+
+      def output_plain(repositories)
+        repositories.each do |repo|
+          if paths?
+            puts "#{repo[:url] || repo[:name]} -> #{repo[:path]}"
+          else
+            puts repo[:url] || repo[:name]
+          end
+        end
+      end
+    end
+
+    # Remove tracked repositories by pattern
+    class RemoveRepositoryCommand < Clamp::Command
+      self.description = <<~DESC
+        Remove tracked repositories using pattern matching.
+
+        Examples:
+          makit repository remove github.com/user/
+          makit repository remove clamp.git
+          makit repository remove --missing-rakefile
+      DESC
+
+      parameter "PATTERN", "Pattern to match repository URLs", attribute_name: :pattern, required: false
+      option ["--missing-rakefile"], :flag, "Remove repositories without Rakefile"
+      option ["--dry-run"], :flag, "Show what would be removed without actually removing"
+      option ["--verbose"], :flag, "Show verbose output"
+
+      def execute
+        if missing_rakefile?
+          remove_missing_rakefile_repos
+        elsif pattern
+          remove_by_pattern(pattern)
+        else
+          puts "Error: Either provide a PATTERN or use --missing-rakefile"
+          exit 1
+        end
+      end
+
+      private
+
+      def remove_by_pattern(pattern)
+        tracked_repos = load_tracked_repositories
+        matching_repos = tracked_repos.select { |repo| repo["url"].include?(pattern) }
+
+        if matching_repos.empty?
+          puts "No repositories found matching pattern: #{pattern}"
+          return
+        end
+
+        puts "Found #{matching_repos.length} repositories matching pattern: #{pattern}"
+        matching_repos.each { |repo| puts "  - #{repo["url"]}" }
+
+        return if dry_run?
+
+        remaining_repos = tracked_repos.reject { |repo| repo["url"].include?(pattern) }
+        save_tracked_repositories(remaining_repos)
+        puts "✅ Removed #{matching_repos.length} repositories"
+      end
+
+      def remove_missing_rakefile_repos
+        tracked_repos = load_tracked_repositories
+        repos_to_remove = []
+
+        tracked_repos.each do |repo|
+          clone_dir = Makit::Directories.get_clone_directory(repo["url"])
+          rakefile_path = File.join(clone_dir, "Rakefile")
+
+          if Dir.exist?(clone_dir) && !File.exist?(rakefile_path)
+            repos_to_remove << repo
+            puts "  - #{repo["url"]} (no Rakefile)" if verbose?
+          end
+        end
+
+        if repos_to_remove.empty?
+          puts "No repositories found without Rakefile"
+          return
+        end
+
+        puts "Found #{repos_to_remove.length} repositories without Rakefile"
+        return if dry_run?
+
+        remaining_repos = tracked_repos - repos_to_remove
+        save_tracked_repositories(remaining_repos)
+        puts "✅ Removed #{repos_to_remove.length} repositories without Rakefile"
+      end
+
+      def load_tracked_repositories
+        tracked_file = File.join(Makit::Directories::ROOT, "tracked_repositories.json")
+        return [] unless File.exist?(tracked_file)
+
+        begin
+          JSON.parse(File.read(tracked_file))
+        rescue JSON::ParserError => e
+          warn "Warning: Could not parse tracked repositories file: #{e.message}"
+          []
+        end
+      end
+
+      def save_tracked_repositories(repositories)
+        tracked_file = File.join(Makit::Directories::ROOT, "tracked_repositories.json")
+        FileUtils.mkdir_p(File.dirname(tracked_file))
+        sorted_repos = repositories.sort_by { |repo| repo["url"] }
+        File.write(tracked_file, JSON.pretty_generate(sorted_repos))
+      end
+    end
+
+    # Import repositories from filesystem
+    class ImportRepositoryCommand < Clamp::Command
+      self.description = <<~DESC
+        Import git repositories from filesystem by discovery.
+
+        Examples:
+          makit repository import
+          makit repository import --directory ~/code
+          makit repository import --skip-rakefile-check
+      DESC
+
+      option ["--directory"], "DIR", "Directory to search for repositories", default: File.join(Dir.home, "code")
+      option ["--max-depth"], "DEPTH", "Maximum search depth", default: 3, &method(:Integer)
+      option ["--skip-rakefile-check"], :flag, "Import all repositories, not just those with Rakefile"
+      option ["--dry-run"], :flag, "Show what would be imported without actually importing"
+      option ["--verbose"], :flag, "Show verbose output"
+
+      def execute
+        search_dir = directory
+        unless Dir.exist?(search_dir)
+          puts "Directory does not exist: #{search_dir}"
+          exit 1
+        end
+
+        puts "Searching for git repositories in: #{search_dir}"
+        puts "Max depth: #{max_depth}"
+        puts "Rakefile required: #{!skip_rakefile_check?}"
+
+        repositories = discover_repositories(search_dir)
+
+        if repositories.empty?
+          puts "No repositories found"
+          return
+        end
+
+        puts "\nFound #{repositories.length} repositories:"
+        repositories.each { |repo| puts "  - #{repo[:url] || repo[:path]}" }
+
+        return if dry_run?
+
+        import_repositories(repositories)
+      end
+
+      private
+
+      def discover_repositories(base_dir)
+        repositories = []
+
+        Find.find(base_dir) do |path|
+          next unless File.directory?(path) && File.basename(path) == ".git"
+
+          repo_dir = File.dirname(path)
+
+          # Check depth
+          relative_path = repo_dir.sub("#{base_dir}/", "")
+          depth = relative_path.split("/").length
+
+          if depth <= max_depth
+            repo_info = extract_repository_info(repo_dir)
+            repositories << repo_info if repo_info && should_import?(repo_dir)
+          end
+
+          Find.prune
+        end
+
+        repositories
+      end
+
+      def should_import?(repo_dir)
+        return true if skip_rakefile_check?
+
+        File.exist?(File.join(repo_dir, "Rakefile"))
+      end
+
+      def extract_repository_info(repo_dir)
+        return nil unless Dir.exist?(repo_dir)
+
+        info = { path: repo_dir }
+
+        begin
+          Dir.chdir(repo_dir) do
+            remote_output = `git remote get-url origin 2>/dev/null`.strip
+            info[:url] = remote_output unless remote_output.empty?
+          end
+        rescue StandardError
+          # If we can't get git info, skip this repo
+          return nil
+        end
+
+        info
+      end
+
+      def import_repositories(repositories)
+        tracked_repos = load_tracked_repositories
+        imported_count = 0
+
+        repositories.each do |repo|
+          next unless repo[:url]
+          next if tracked_repos.any? { |tracked| tracked["url"] == repo[:url] }
+
+          new_repo = {
+            "url" => repo[:url],
+            "added_at" => Time.now.iso8601,
+            "status" => "imported",
+          }
+
+          tracked_repos << new_repo
+          imported_count += 1
+          puts "  ✅ Imported: #{repo[:url]}" if verbose?
+        end
+
+        if imported_count.positive?
+          save_tracked_repositories(tracked_repos)
+          puts "✅ Successfully imported #{imported_count} repositories"
+        else
+          puts "No new repositories to import"
+        end
+      end
+
+      def load_tracked_repositories
+        tracked_file = File.join(Makit::Directories::ROOT, "tracked_repositories.json")
+        return [] unless File.exist?(tracked_file)
+
+        begin
+          JSON.parse(File.read(tracked_file))
+        rescue JSON::ParserError => e
+          warn "Warning: Could not parse tracked repositories file: #{e.message}"
+          []
+        end
+      end
+
+      def save_tracked_repositories(repositories)
+        tracked_file = File.join(Makit::Directories::ROOT, "tracked_repositories.json")
+        FileUtils.mkdir_p(File.dirname(tracked_file))
+        sorted_repos = repositories.sort_by { |repo| repo["url"] }
+        File.write(tracked_file, JSON.pretty_generate(sorted_repos))
+      end
+    end
+
+    # Add subcommand declarations after all classes are defined
+    RepositoryCommand.subcommand "add", "Add repository to tracking list", AddRepositoryCommand
+    RepositoryCommand.subcommand "clone", "Clone repository to local directory", CloneRepositoryCommand
+    RepositoryCommand.subcommand "pull", "Pull latest changes", PullRepositoryCommand
+    RepositoryCommand.subcommand "list", "List tracked repositories", ListRepositoryCommand
+    RepositoryCommand.subcommand "remove", "Remove tracked repositories", RemoveRepositoryCommand
+    RepositoryCommand.subcommand "import", "Import repositories from filesystem", ImportRepositoryCommand
+  end
+end