makit 0.0.99 → 0.0.112

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a90f6822da244e01bde51ceea9147ff5e096c65ba77ff1d0eb447080d47682af
-  data.tar.gz: cda17895074379e842eb717a8e2d0af7580ab134d6037ac0411862421af3c939
+  metadata.gz: 46838a2ffa0f2b330292a5be247d3f8cec628ce299d10adcf780e13ba63e2f0b
+  data.tar.gz: 3160279cb7e06f6e38a0c65028c22e6446a43978ddd138cad816492709832424
 SHA512:
-  metadata.gz: c2cdebafc800836588139bebac0bdf66d96b7a0060a792ab21dafb951f7da111364c631e937c015ded39faa38ee2be82733fea2acd1ecb1be77fb23fab064284
-  data.tar.gz: 10c1e7ddb62cdeb72e3ddf8beeaf91111441805a3ee046afe51479d4a09d57cd722000cfa10099d8431c68c4b020ac6cb66880371e2c1b6f9e34af6008738adf
+  metadata.gz: 60555bc357bb378dd4972a77360beb2dcfd4cd03f494ba654399c341f138e44dfa64a0be44581ca13b019e9956b042128f8ea42ab76d7d9c75643ad529f48918
+  data.tar.gz: f8686dc444c15329727defd706e8916014bad0efc134b38ec98006340fe02aaa512d60823ff3a664dc0562b706cb431a4c45e7178feb34386ab48e356cb7600c

data/README.md

@@ -0,0 +1,41 @@
+# Makit
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/makit`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "makit"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install makit
+
+## Usage
+
+```ruby
+require "makit"
+
+# TODO: Write usage instructions here
+```
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yourusername/makit.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/makit

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "makit"
+Makit::Cli::MainCommand.run(ARGV)

data/lib/makit/apache.rb

@@ -1,32 +1,28 @@
-# frozen_string_literal: true
-
-# This module provides classes for the Makit gem.
-module Makit
-  # This class provide methods for working with the system Environment.
-  #
-  class Apache
-    def self.server_root
-      os = Makit::Environment::get_os
-      if os == "windows"
-        "C:\\Apache24"
-      elsif os == "linux"
-        "/etc/apache2"
-      elsif os == "mac"
-        "/private/etc/apache2"
-      else
-        nil
-      end
-      # default on windows: C:\Apache24
-      # default on linux: /etc/apache2
-      # default on mac: /private/etc/apache2
-      #nil
-    end
-
-    def self.document_root
-      # default on windows: C:\Apache24\htdocs
-      # default on linux: /var/www/html
-      # default on mac: /Library/WebServer/Documents
-      nil
-    end
-  end
-end
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods for working with the system Environment.
+  #
+  class Apache
+    def self.server_root
+      os = Makit::Environment.get_os
+      {
+        "windows" => "C:\\Apache24",
+        "linux" => "/etc/apache2",
+        "mac" => "/private/etc/apache2",
+      }[os]
+      # default on windows: C:\Apache24
+      # default on linux: /etc/apache2
+      # default on mac: /private/etc/apache2
+      # nil
+    end
+
+    def self.document_root
+      # default on windows: C:\Apache24\htdocs
+      # default on linux: /var/www/html
+      # default on mac: /Library/WebServer/Documents
+      nil
+    end
+  end
+end

data/lib/makit/cli/build_commands.rb

@@ -0,0 +1,500 @@
+# frozen_string_literal: true
+
+require "clamp"
+require "fileutils"
+require "json"
+
+module Makit
+  module Cli
+    # Consolidated build operations commands
+    # Combines: make, clean functionality
+    class BuildCommand < Clamp::Command
+      self.description = <<~DESC
+        Manage project build operations and artifact cleanup.
+
+        Available operations:
+          make  - Build project and generate artifacts
+          clean - Clean build artifacts and temporary files
+      DESC
+    end
+
+    # Build project artifacts
+    class MakeBuildCommand < Clamp::Command
+      self.description = <<~DESC
+        Build project artifacts and execute build tasks.
+
+        When called without arguments, enumerates all tracked repositories
+        and displays their latest commit IDs.
+
+        Examples:
+          makit build make                                    # Show all repositories and latest commits
+          makit build make https://github.com/user/repo      # Build specific repository
+          makit build make --target release                  # Build current project with release target
+          makit build make --parallel                        # Build with parallel execution
+      DESC
+
+      parameter "[REPOSITORY_URL]", "Git repository URL to build (optional)", attribute_name: :repository_url,
+                                                                              required: false
+      option ["--commit"], "COMMIT", "Specific commit to build (default: latest)", default: "latest"
+      option ["--target"], "TARGET", "Build target (debug, release)", default: "debug"
+      option ["--parallel", "-j"], :flag, "Enable parallel build"
+      option ["--verbose", "-v"], :flag, "Show verbose build output"
+      option ["--clean"], :flag, "Clean before building"
+      option ["--force"], :flag, "Force rebuild even if cached result exists"
+
+      def execute
+        if repository_url
+          # Build specific repository
+          build_repository(repository_url)
+        else
+          # No arguments - enumerate all tracked repositories and show latest commits
+          enumerate_repositories
+        end
+      end
+
+      private
+
+      def enumerate_repositories
+        puts "Enumerating all tracked repositories and their latest commit IDs..."
+        puts "=" * 80
+
+        repositories = load_tracked_repositories
+
+        if repositories.empty?
+          puts "No tracked repositories found."
+          puts "Use 'makit repository add <url>' to add repositories to track."
+          return
+        end
+
+        repositories.each_with_index do |repo, index|
+          puts "\n#{(index + 1).to_s.rjust(3)}. #{repo["url"]}"
+
+          begin
+            clone_dir = get_clone_directory(repo["url"])
+
+            if Dir.exist?(clone_dir)
+              latest_commit = get_latest_commit_from_clone(clone_dir)
+              commit_info = get_commit_info(clone_dir, latest_commit)
+
+              puts "     Status: ✅ Cloned"
+              puts "     Latest Commit: #{latest_commit[0..7]}"
+              puts "     Message: #{commit_info[:message]}" if commit_info[:message]
+              puts "     Author: #{commit_info[:author]}" if commit_info[:author]
+              puts "     Date: #{commit_info[:date]}" if commit_info[:date]
+            else
+              puts "     Status: 📋 Tracked (not cloned)"
+              puts "     Use 'makit repository clone #{repo["url"]}' to clone locally"
+            end
+          rescue StandardError => e
+            puts "     Status: ❌ Error: #{e.message}"
+          end
+        end
+
+        puts "\n=" * 80
+        puts "Total repositories: #{repositories.length}"
+        puts "\nTo build a specific repository: makit build make <repository-url>"
+      end
+
+      def build_repository(url)
+        puts "Building repository: #{url}"
+        puts "Commit: #{commit}"
+        puts "Force rebuild: #{force?}" if force?
+        puts "Verbose: #{verbose?}" if verbose?
+
+        begin
+          make_result = Makit.make(url, commit, force: force?)
+
+          puts "\n✅ Build completed successfully!"
+          puts "Repository: #{make_result.repository}"
+          puts "Commit: #{make_result.commit}"
+          puts "Device: #{make_result.device}"
+          puts "Runtime: #{make_result.runtime_identifier}"
+
+          if verbose? && make_result.commands.any?
+            puts "\nCommand Summary:"
+            make_result.commands.each_with_index do |cmd, index|
+              status = cmd.exit_code.zero? ? "✅" : "❌"
+              puts "  #{index + 1}. #{status} #{cmd.name} #{cmd.arguments.join(" ")}"
+              puts "     Duration: #{cmd.duration.seconds}s" if cmd.duration
+              puts "     Error: #{cmd.error.strip}" if cmd.exit_code != 0 && cmd.error && !cmd.error.empty?
+            end
+          end
+        rescue Makit::BuildError => e
+          puts "\n❌ Build failed: #{e.message}"
+          exit 1
+        rescue StandardError => e
+          puts "\n❌ Unexpected error: #{e.message}"
+          puts e.backtrace.first(5).join("\n") if verbose?
+          exit 1
+        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
+          puts "Warning: Could not parse tracked repositories file: #{e.message}"
+          []
+        end
+      end
+
+      def get_clone_directory(url)
+        Makit::Directories.get_clone_directory(url)
+      end
+
+      def get_latest_commit_from_clone(clone_dir)
+        Dir.chdir(clone_dir) do
+          `git rev-parse HEAD`.strip
+        end
+      end
+
+      def get_commit_info(clone_dir, commit_hash)
+        Dir.chdir(clone_dir) do
+          {
+            message: `git log -1 --format="%s" #{commit_hash}`.strip,
+            author: `git log -1 --format="%an" #{commit_hash}`.strip,
+            date: `git log -1 --format="%ci" #{commit_hash}`.strip,
+          }
+        end
+      rescue StandardError
+        {}
+      end
+
+      def detect_project_type(dir)
+        return "ruby" if File.exist?(File.join(dir, "Rakefile")) || File.exist?(File.join(dir, "Gemfile"))
+        return "dotnet" if Dir.glob(File.join(dir, "*.csproj")).any? || Dir.glob(File.join(dir, "*.sln")).any?
+        return "node" if File.exist?(File.join(dir, "package.json"))
+        return "rust" if File.exist?(File.join(dir, "Cargo.toml"))
+
+        "unknown"
+      end
+
+      def clean_if_requested
+        puts "Cleaning before build..." if verbose?
+
+        # Use the clean command internally
+        clean_cmd = CleanBuildCommand.new("")
+        clean_cmd.run([])
+      end
+
+      def build_project(project_type)
+        case project_type
+        when "ruby"
+          build_ruby_project
+        when "dotnet"
+          build_dotnet_project
+        when "node"
+          build_node_project
+        when "rust"
+          build_rust_project
+        end
+      end
+
+      def build_ruby_project
+        puts "  Building Ruby gem..." if verbose?
+
+        # Check for Rakefile and run default task
+        if File.exist?("Rakefile")
+          cmd = "bundle exec rake"
+          cmd += " --verbose" if verbose?
+
+          puts "  Running: #{cmd}" if verbose?
+          success = system(cmd)
+
+          unless success
+            puts "❌ Rake build failed"
+            exit 1
+          end
+        else
+          # Fallback: just run bundle install and try to build gem
+          puts "  Installing dependencies..." if verbose?
+          system("bundle install") if File.exist?("Gemfile")
+
+          if Dir.glob("*.gemspec").any?
+            puts "  Building gem..." if verbose?
+            system("gem build *.gemspec")
+          end
+        end
+
+        puts "  ✅ Ruby build complete" if verbose?
+      end
+
+      def build_dotnet_project
+        puts "  Building .NET project..." if verbose?
+
+        build_args = []
+        build_args << "--configuration #{target.capitalize}"
+        build_args << "--verbosity detailed" if verbose?
+
+        cmd = "dotnet build #{build_args.join(" ")}"
+        puts "  Running: #{cmd}" if verbose?
+
+        success = system(cmd)
+        unless success
+          puts "❌ .NET build failed"
+          exit 1
+        end
+
+        puts "  ✅ .NET build complete" if verbose?
+      end
+
+      def build_node_project
+        puts "  Building Node.js project..." if verbose?
+
+        # Install dependencies if needed
+        if File.exist?("package.json") && !Dir.exist?("node_modules")
+          puts "  Installing dependencies..." if verbose?
+          install_cmd = File.exist?("package-lock.json") ? "npm ci" : "npm install"
+          system(install_cmd)
+        end
+
+        # Check for build script in package.json
+        if File.exist?("package.json")
+          package_data = JSON.parse(File.read("package.json"))
+          scripts = package_data["scripts"] || {}
+
+          if scripts["build"]
+            puts "  Running build script..." if verbose?
+            cmd = "npm run build"
+            cmd += " --verbose" if verbose?
+
+            success = system(cmd)
+            unless success
+              puts "❌ npm build failed"
+              exit 1
+            end
+          elsif verbose?
+            puts "  No build script found in package.json"
+          end
+        end
+
+        puts "  ✅ Node.js build complete" if verbose?
+      end
+
+      def build_rust_project
+        puts "  Building Rust project..." if verbose?
+
+        build_args = []
+        build_args << "--release" if target == "release"
+        build_args << "--verbose" if verbose?
+
+        cmd = "cargo build #{build_args.join(" ")}"
+        puts "  Running: #{cmd}" if verbose?
+
+        success = system(cmd)
+        unless success
+          puts "❌ Cargo build failed"
+          exit 1
+        end
+
+        puts "  ✅ Rust build complete" if verbose?
+      end
+    end
+
+    # Clean build artifacts and temporary files
+    class CleanBuildCommand < Clamp::Command
+      self.description = <<~DESC
+        Clean build artifacts, temporary files, and caches.
+
+        Examples:
+          makit build clean
+          makit build clean --deep
+          makit build clean --dry-run
+      DESC
+
+      option ["--deep"], :flag, "Perform deep clean (including dependencies)"
+      option ["--dry-run"], :flag, "Show what would be cleaned without actually cleaning"
+      option ["--verbose", "-v"], :flag, "Show verbose output"
+
+      def execute
+        project_type = detect_project_type(Dir.pwd)
+
+        puts "Cleaning #{project_type} project artifacts..."
+        puts "Deep clean: #{deep?}" if verbose? && deep?
+        puts "Dry run: #{dry_run?}" if verbose? && dry_run?
+
+        clean_common_artifacts
+        clean_project_specific_artifacts(project_type)
+        clean_dependencies if deep?
+
+        if dry_run?
+          puts "✅ Dry run completed - no files were actually removed"
+        else
+          puts "✅ Clean completed successfully"
+        end
+      end
+
+      private
+
+      def detect_project_type(dir)
+        return "ruby" if File.exist?(File.join(dir, "Rakefile")) || File.exist?(File.join(dir, "Gemfile"))
+        return "dotnet" if Dir.glob(File.join(dir, "*.csproj")).any? || Dir.glob(File.join(dir, "*.sln")).any?
+        return "node" if File.exist?(File.join(dir, "package.json"))
+        return "rust" if File.exist?(File.join(dir, "Cargo.toml"))
+
+        "unknown"
+      end
+
+      def clean_common_artifacts
+        common_patterns = [
+          "**/*.log",
+          "**/tmp/**/*",
+          "**/temp/**/*",
+          "**/.DS_Store",
+          "**/Thumbs.db",
+          "**/*.tmp",
+          "**/*.bak",
+          "**/*.swp",
+          "**/*.swo",
+        ]
+
+        common_patterns.each do |pattern|
+          clean_by_pattern(pattern, "Common temp files")
+        end
+      end
+
+      def clean_project_specific_artifacts(project_type)
+        case project_type
+        when "ruby"
+          clean_ruby_artifacts
+        when "dotnet"
+          clean_dotnet_artifacts
+        when "node"
+          clean_node_artifacts
+        when "rust"
+          clean_rust_artifacts
+        else
+          puts "  Unknown project type - only cleaning common artifacts" if verbose?
+        end
+      end
+
+      def clean_ruby_artifacts
+        # Clean gem files
+        clean_by_pattern("*.gem", "Ruby gem files")
+
+        # Clean pkg directory
+        clean_directory("pkg", "Ruby package directory")
+
+        # Clean coverage directory
+        clean_directory("coverage", "Ruby coverage reports")
+
+        # Clean bundler cache if deep clean
+        clean_directory("vendor/bundle", "Bundler cache") if deep?
+
+        puts "  ✅ Ruby artifacts cleaned" if verbose?
+      end
+
+      def clean_dotnet_artifacts
+        # Clean bin and obj directories
+        clean_by_pattern("**/bin/**/*", ".NET bin directories")
+        clean_by_pattern("**/obj/**/*", ".NET obj directories")
+
+        # Clean test results
+        clean_by_pattern("**/TestResults/**/*", ".NET test results")
+
+        # Clean packages if deep clean
+        clean_directory("packages", ".NET packages directory") if deep?
+
+        puts "  ✅ .NET artifacts cleaned" if verbose?
+      end
+
+      def clean_node_artifacts
+        # Clean build directory
+        clean_directory("build", "Node.js build directory")
+        clean_directory("dist", "Node.js dist directory")
+
+        # Clean coverage and test reports
+        clean_directory("coverage", "Node.js coverage reports")
+        clean_directory("nyc_output", "NYC coverage output")
+
+        # Clean logs
+        clean_by_pattern("npm-debug.log*", "npm debug logs")
+        clean_by_pattern("yarn-debug.log*", "Yarn debug logs")
+        clean_by_pattern("yarn-error.log*", "Yarn error logs")
+
+        # Clean node_modules if deep clean
+        clean_directory("node_modules", "Node.js dependencies") if deep?
+
+        puts "  ✅ Node.js artifacts cleaned" if verbose?
+      end
+
+      def clean_rust_artifacts
+        # Clean target directory
+        clean_directory("target", "Rust target directory")
+
+        # Clean Cargo lock if deep clean
+        clean_file("Cargo.lock", "Cargo lock file") if deep?
+
+        puts "  ✅ Rust artifacts cleaned" if verbose?
+      end
+
+      def clean_dependencies
+        puts "  Performing deep clean of dependencies..." if verbose?
+
+        project_type = detect_project_type(Dir.pwd)
+
+        case project_type
+        when "ruby"
+          clean_directory("vendor/bundle", "Ruby vendor directory")
+          clean_file("Gemfile.lock", "Ruby Gemfile lock") if File.exist?("Gemfile.lock")
+        when "dotnet"
+          clean_directory("packages", ".NET packages")
+          # NOTE: Don't clean packages.lock.json as it's source controlled
+        when "node"
+          clean_directory("node_modules", "Node.js modules")
+          clean_file("package-lock.json", "npm lock file") if File.exist?("package-lock.json")
+          clean_file("yarn.lock", "Yarn lock file") if File.exist?("yarn.lock")
+        when "rust"
+          # Rust doesn't really have a separate dependency directory to clean
+          # Dependencies are in target/ which is already cleaned above
+          puts "    Rust dependencies are cleaned with target directory" if verbose?
+        end
+      end
+
+      def clean_by_pattern(pattern, description)
+        matching_files = Dir.glob(pattern)
+
+        if matching_files.any?
+          puts "  Cleaning #{description}: #{matching_files.length} items" if verbose?
+
+          unless dry_run?
+            matching_files.each do |file|
+              if File.directory?(file)
+                FileUtils.rm_rf(file)
+              else
+                FileUtils.rm_f(file)
+              end
+            end
+          end
+        elsif verbose?
+          puts "  No #{description} found"
+        end
+      end
+
+      def clean_directory(dir_path, description)
+        if Dir.exist?(dir_path)
+          puts "  Cleaning #{description}: #{dir_path}" if verbose?
+          FileUtils.rm_rf(dir_path) unless dry_run?
+        elsif verbose?
+          puts "  #{description} not found: #{dir_path}"
+        end
+      end
+
+      def clean_file(file_path, description)
+        if File.exist?(file_path)
+          puts "  Cleaning #{description}: #{file_path}" if verbose?
+          FileUtils.rm_f(file_path) unless dry_run?
+        elsif verbose?
+          puts "  #{description} not found: #{file_path}"
+        end
+      end
+    end
+
+    # Add subcommand declarations after all classes are defined
+    BuildCommand.subcommand "make", "Build project artifacts", MakeBuildCommand
+    BuildCommand.subcommand "clean", "Clean build artifacts", CleanBuildCommand
+  end
+end

data/lib/makit/cli/generators/base_generator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Makit
+  module Cli
+    module Generators
+      # Base class for all project generators providing common functionality
+      class BaseGenerator
+        attr_reader :name, :options
+
+        def initialize(name, options = {})
+          @name = name
+          @options = options
+        end
+
+        # Main generation method - creates the complete project structure
+        def generate(project_dir)
+          create_directory_structure(project_dir)
+          create_files(project_dir)
+          display_success_message(project_dir)
+        end
+
+        protected
+
+        # Create the basic directory structure
+        def create_directory_structure(project_dir)
+          FileUtils.mkdir_p(project_dir)
+        end
+
+        # Create all files defined by the generator
+        def create_files(project_dir)
+          file_definitions.each do |file_path, template_method|
+            content = send(template_method)
+            create_file(File.join(project_dir, file_path), content)
+          end
+        end
+
+        # Create a single file with given content
+        def create_file(path, content)
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, content)
+        end
+
+        # Display success message and next steps
+        def display_success_message(project_dir)
+          puts "#{project_type} '#{name}' created successfully!"
+          puts "Next steps:"
+          puts "  cd #{project_dir}"
+          display_custom_next_steps
+        end
+
+        # Display project-specific next steps
+        def display_custom_next_steps
+          puts "  git init"
+          puts "  git add ."
+          puts "  git commit -m 'Initial commit'"
+        end
+
+        # Template methods to be implemented by subclasses
+
+        # Returns a hash mapping file paths to template method names
+        def file_definitions
+          raise NotImplementedError, "Subclasses must implement file_definitions"
+        end
+
+        # Returns a human-readable description of the project type
+        def project_type
+          raise NotImplementedError, "Subclasses must implement project_type"
+        end
+      end
+    end
+  end
+end