makit 0.0.143 → 0.0.145

data/lib/makit/configuration/project.rb

@@ -2,14 +2,26 @@
 
 require "json"
 
+# Only load gRPC service implementation if generated files exist
+if File.exist?(File.join(__dir__, "..", "..", "generated", "makit", "v1", "configuration", "project_service_services_pb.rb"))
+  require_relative "../v1/configuration/project_service_impl"
+end
+
 module Makit
   module Configuration
-    # Project configuration management
+    # Project configuration management - Phase 3: Routes calls to gRPC service
     class Project
       attr_accessor :git_remote_url, :name, :version, :project_type, :steps, :authors, :description, :license_expression
       attr_accessor :dotnet_projects
 
       def initialize(name, version = nil, project_type = nil)
+        # Check if gRPC service is available
+        @grpc_available = defined?(Makit::V1::Configuration::ProjectServiceImpl)
+        
+        if @grpc_available
+          @grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
+        end
+        
         # Support both keyword arguments and positional arguments for compatibility
         if name.is_a?(Hash)
           # Keyword arguments: Project.new(name: "test", version: "1.0.0")
@@ -22,94 +34,237 @@ module Makit
           @version = version
           @project_type = project_type
         end
-        @authors = "authors"
-        @description = "description"
-        @license_expression = "MIT"
-        @steps = []
+        
+        if @grpc_available
+          # Create project via gRPC service (handle empty names)
+          if @name && !@name.strip.empty?
+            create_request = Makit::V1::Configuration::CreateProjectRequest.new(
+              name: @name,
+              version: @version || "0.0.0",
+              project_type: @project_type || "gem"
+            )
+            @proto_model = @grpc_service.create_project(create_request, nil)
+          else
+            # Create empty project directly (bypass gRPC validation for empty names)
+            @proto_model = Makit::V1::Configuration::Project.new(
+              name: @name || "",
+              version: @version || "0.0.0",
+              project_type: @project_type || "",
+              authors: "authors",
+              description: "description",
+              license_expression: "MIT",
+              steps: []
+            )
+          end
+          
+          # Initialize Ruby attributes for backward compatibility
+          @authors = @proto_model.authors
+          @description = @proto_model.description
+          @license_expression = @proto_model.license_expression
+          @steps = convert_steps_from_proto(@proto_model.steps)
+          @git_remote_url = @proto_model.git_remote_url
+          @dotnet_projects = @proto_model.dotnet_projects.to_a
+        else
+          # Fallback implementation when gRPC is not available
+          @name = @name || ""
+          @version = @version || "0.0.0"
+          @project_type = @project_type || ""
+          @authors = "authors"
+          @description = "description"
+          @license_expression = "MIT"
+          @steps = []
+          @git_remote_url = ""
+          @dotnet_projects = []
+        end
       end
 
       def add_step(step)
         raise ArgumentError, "Step must be a Makit::Configuration::Step instance" unless step.is_a?(Step)
 
+        if @grpc_available
+          # Add step to Protobuf model
+          proto_step = Makit::V1::Configuration::Step.new(
+            name: step.name,
+            description: step.description,
+            commands: step.commands
+          )
+          @proto_model.steps << proto_step
+        end
+        
+        # Update Ruby attribute for backward compatibility
         @steps << step
       end
 
       def to_json(*args)
-        {
-          name: @name,
-          version: @version,
-          project_type: @project_type,
-          authors: @authors,
-          description: @description,
-          license_expression: @license_expression,
-          steps: @steps.map(&:to_h),
-        }.to_json(*args)
+        if @grpc_available
+          # Use gRPC service to convert to JSON
+          project_data = {
+            name: @proto_model.name,
+            version: @proto_model.version,
+            project_type: @proto_model.project_type,
+            authors: @proto_model.authors,
+            description: @proto_model.description,
+            license_expression: @proto_model.license_expression,
+            steps: @proto_model.steps.map do |step|
+              {
+                name: step.name,
+                description: step.description,
+                commands: step.commands.to_a
+              }
+            end
+          }
+        else
+          # Fallback implementation
+          project_data = {
+            name: @name,
+            version: @version,
+            project_type: @project_type,
+            authors: @authors,
+            description: @description,
+            license_expression: @license_expression,
+            steps: @steps.map do |step|
+              {
+                name: step.name,
+                description: step.description,
+                commands: step.commands
+              }
+            end
+          }
+        end
+        project_data.to_json(*args)
       end
 
       def to_json_pretty
-        JSON.pretty_generate({
-                               name: @name,
-                               version: @version,
-                               project_type: @project_type,
-                               authors: @authors,
-                               description: @description,
-                               license_expression: @license_expression,
-                               steps: @steps.map(&:to_h),
-                             })
+        if @grpc_available
+          # Use gRPC service to convert to pretty JSON
+          project_data = {
+            name: @proto_model.name,
+            version: @proto_model.version,
+            project_type: @proto_model.project_type,
+            authors: @proto_model.authors,
+            description: @proto_model.description,
+            license_expression: @proto_model.license_expression,
+            steps: @proto_model.steps.map do |step|
+              {
+                name: step.name,
+                description: step.description,
+                commands: step.commands.to_a
+              }
+            end
+          }
+        else
+          # Fallback implementation
+          project_data = {
+            name: @name,
+            version: @version,
+            project_type: @project_type,
+            authors: @authors,
+            description: @description,
+            license_expression: @license_expression,
+            steps: @steps.map do |step|
+              {
+                name: step.name,
+                description: step.description,
+                commands: step.commands
+              }
+            end
+          }
+        end
+        JSON.pretty_generate(project_data)
       end
 
       def self.from_json(path)
-        content = File.read(path)
-        data = JSON.parse(content, symbolize_names: true)
-
-        project = new(data[:name], data[:version], data[:project_type])
-
-        # Set additional fields if they exist in the JSON
-        project.authors = data[:authors] if data[:authors]
-        project.description = data[:description] if data[:description]
-        project.license_expression = data[:license_expression] if data[:license_expression]
-
-        data[:steps].each do |step_data|
-          step = Step.new(
-            name: step_data[:name],
-            description: step_data[:description],
-            commands: step_data[:commands],
-          )
-          project.add_step(step)
+        if defined?(Makit::V1::Configuration::ProjectServiceImpl)
+          # Use gRPC service to load from file
+          grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
+          request = Makit::V1::Configuration::LoadFromFileRequest.new(path: path)
+          proto_model = grpc_service.load_from_file(request, nil)
+          
+          # Convert Protobuf model to Ruby object
+          convert_from_proto_model(proto_model)
+        else
+          # Fallback implementation
+          content = File.read(path)
+          data = JSON.parse(content, symbolize_names: true)
+          new(data[:name], data[:version], data[:project_type]).tap do |project|
+            project.authors = data[:authors] || "authors"
+            project.description = data[:description] || "description"
+            project.license_expression = data[:license_expression] || "MIT"
+            project.git_remote_url = data[:git_remote_url] || ""
+            project.dotnet_projects = data[:dotnet_projects] || []
+            
+            # Load steps
+            (data[:steps] || []).each do |step_data|
+              step = Step.new(
+                name: step_data[:name] || "",
+                description: step_data[:description] || "",
+                commands: step_data[:commands] || []
+              )
+              project.steps << step
+            end
+          end
         end
-
-        project
       end
 
       # Class method for deserializing from JSON string (used by serializer)
       def self.decode_json(json_string)
-        data = JSON.parse(json_string, symbolize_names: true)
-
-        project = new(data[:name], data[:version], data[:project_type])
-
-        # Set additional fields if they exist in the JSON
-        project.authors = data[:authors] if data[:authors]
-        project.description = data[:description] if data[:description]
-        project.license_expression = data[:license_expression] if data[:license_expression]
-
-        data[:steps].each do |step_data|
-          step = Step.new(
-            name: step_data[:name],
-            description: step_data[:description],
-            commands: step_data[:commands],
-          )
-          project.add_step(step)
+        if defined?(Makit::V1::Configuration::ProjectServiceImpl)
+          # Use gRPC service to load from JSON string
+          grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
+          request = Makit::V1::Configuration::LoadFromJsonRequest.new(json_string: json_string)
+          proto_model = grpc_service.load_from_json(request, nil)
+          
+          # Convert Protobuf model to Ruby object
+          convert_from_proto_model(proto_model)
+        else
+          # Fallback implementation
+          data = JSON.parse(json_string, symbolize_names: true)
+          new(data[:name], data[:version], data[:project_type]).tap do |project|
+            project.authors = data[:authors] || "authors"
+            project.description = data[:description] || "description"
+            project.license_expression = data[:license_expression] || "MIT"
+            project.git_remote_url = data[:git_remote_url] || ""
+            project.dotnet_projects = data[:dotnet_projects] || []
+            
+            # Load steps
+            (data[:steps] || []).each do |step_data|
+              step = Step.new(
+                name: step_data[:name] || "",
+                description: step_data[:description] || "",
+                commands: step_data[:commands] || []
+              )
+              project.steps << step
+            end
+          end
         end
-
-        project
       end
 
       def to_gitlab_ci(path)
-        GitLabHelper.to_yaml(self, path)
+        if @grpc_available
+          # Use gRPC service to generate GitLab CI
+          request = Makit::V1::Configuration::GenerateGitlabCiRequest.new(
+            project: @proto_model,
+            path: path
+          )
+          @grpc_service.generate_gitlab_ci(request, nil)
+        else
+          # Fallback implementation - just create a basic GitLab CI file
+          require_relative "gitlab_helper"
+          Makit::Configuration::GitLabHelper.to_yaml(self, path)
+        end
       end
 
       def to_rakefile
-        RakefileHelper.generate(self)
+        if @grpc_available
+          # Use gRPC service to generate Rakefile
+          request = Makit::V1::Configuration::GenerateRakefileRequest.new(project: @proto_model)
+          response = @grpc_service.generate_rakefile(request, nil)
+          response.content
+        else
+          # Fallback implementation
+          require_relative "rakefile_helper"
+          Makit::Configuration::RakefileHelper.generate(self)
+        end
       end
 
       # Save the project to a specific path as pretty JSON
@@ -119,7 +274,17 @@ module Makit
           raise ArgumentError, "Project name cannot be empty. Please set a valid project name before saving."
         end
 
-        File.write(path, to_json_pretty)
+        if @grpc_available
+          # Use gRPC service to save to file
+          request = Makit::V1::Configuration::SaveToFileRequest.new(
+            project: @proto_model,
+            path: path
+          )
+          @grpc_service.save_to_file(request, nil)
+        else
+          # Fallback implementation
+          File.write(path, to_json_pretty)
+        end
       end
 
       def save
@@ -128,41 +293,154 @@ module Makit
           raise ArgumentError, "Project name cannot be empty. Please set a valid project name before saving."
         end
 
-        save_as(".makit.json")
+        if @grpc_available
+          # Use gRPC service to save to default location
+          request = Makit::V1::Configuration::SaveToDefaultRequest.new(project: @proto_model)
+          @grpc_service.save_to_default(request, nil)
+        else
+          # Fallback implementation
+          File.write(".makit.json", to_json_pretty)
+        end
       end
 
       # Display the project configuration in YAML format
       def show
         require "yaml"
 
-        project_data = {
-          name: @name,
-          version: @version,
-          project_type: @project_type,
-          git_remote_url: @git_remote_url,
-          steps: @steps.map(&:to_h),
-        }
+        if @grpc_available
+          project_data = {
+            name: @proto_model.name,
+            version: @proto_model.version,
+            project_type: @proto_model.project_type,
+            git_remote_url: @proto_model.git_remote_url,
+            steps: @proto_model.steps.map do |step|
+              {
+                name: step.name,
+                description: step.description,
+                commands: step.commands.to_a
+              }
+            end
+          }
+        else
+          project_data = {
+            name: @name,
+            version: @version,
+            project_type: @project_type,
+            git_remote_url: @git_remote_url,
+            steps: @steps.map do |step|
+              {
+                name: step.name,
+                description: step.description,
+                commands: step.commands
+              }
+            end
+          }
+        end
 
         puts YAML.dump(project_data)
       end
 
       # Load a project from the default .makit.json file
       def self.default
-        if File.exist?(".makit.json")
-          from_json(".makit.json")
+        if defined?(Makit::V1::Configuration::ProjectServiceImpl)
+          # Use gRPC service to load default project
+          grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
+          request = Google::Protobuf::Empty.new
+          proto_model = grpc_service.load_default(request, nil)
+          
+          # Convert Protobuf model to Ruby object
+          convert_from_proto_model(proto_model)
         else
-          # Makit::Logging.default_logger.warn("Project not configured")
-          #          #if defined?(NAME) && defined?(VERSION) && defined?(PROJECT_TYPE)
-          #  project = new(name: NAME, version: VERSION, project_type: PROJECT_TYPE)
-          #  project.save
-          # else
-          project = new(name: "", version: "0.0.0", project_type: "")
-          Makit::Logging.default_logger.warn("Project not configured")
-          # Makit::Logging.default_logger.warn("Define NAME, VERSION, and PROJECT_TYPE in the Rakefile")
-          # end
-          project
+          # Fallback implementation
+          if File.exist?(".makit.json")
+            from_json(".makit.json")
+          else
+            new("", "0.0.0", "")
+          end
+        end
+      end
+
+      # Update project attributes
+      def name=(value)
+        @name = value
+        update_proto_attribute(:name, value) if @grpc_available
+      end
+
+      def version=(value)
+        @version = value
+        update_proto_attribute(:version, value) if @grpc_available
+      end
+
+      def project_type=(value)
+        @project_type = value
+        update_proto_attribute(:project_type, value) if @grpc_available
+      end
+
+      def authors=(value)
+        @authors = value
+        update_proto_attribute(:authors, value) if @grpc_available
+      end
+
+      def description=(value)
+        @description = value
+        update_proto_attribute(:description, value) if @grpc_available
+      end
+
+      def license_expression=(value)
+        @license_expression = value
+        update_proto_attribute(:license_expression, value) if @grpc_available
+      end
+
+      def git_remote_url=(value)
+        @git_remote_url = value
+        update_proto_attribute(:git_remote_url, value) if @grpc_available
+      end
+
+      def dotnet_projects=(value)
+        @dotnet_projects = value
+        @proto_model.dotnet_projects.replace(value || []) if @grpc_available
+      end
+
+      private
+
+      # Convert Protobuf model to Ruby Project object
+      def self.convert_from_proto_model(proto_model)
+        project = new(proto_model.name, proto_model.version, proto_model.project_type)
+        
+        # Update all attributes from Protobuf model
+        project.instance_variable_set(:@proto_model, proto_model)
+        project.instance_variable_set(:@authors, proto_model.authors)
+        project.instance_variable_set(:@description, proto_model.description)
+        project.instance_variable_set(:@license_expression, proto_model.license_expression)
+        project.instance_variable_set(:@git_remote_url, proto_model.git_remote_url)
+        project.instance_variable_set(:@dotnet_projects, proto_model.dotnet_projects.to_a)
+        project.instance_variable_set(:@steps, project.send(:convert_steps_from_proto, proto_model.steps))
+        
+        project
+      end
+
+      # Convert Protobuf steps to Ruby Step objects
+      def convert_steps_from_proto(proto_steps)
+        return [] unless @grpc_available
+        proto_steps.map do |proto_step|
+          Step.new(
+            name: proto_step.name,
+            description: proto_step.description,
+            commands: proto_step.commands.to_a
+          )
         end
       end
+
+      # Update a single attribute in the Protobuf model
+      def update_proto_attribute(attribute, value)
+        return unless @grpc_available
+        updates = { attribute.to_s => value }
+        request = Makit::V1::Configuration::UpdateProjectRequest.new(
+          project: @proto_model,
+          updates: updates
+        )
+        @proto_model = @grpc_service.update_project(request, nil)
+      end
     end
   end
-end
+end

data/lib/makit/configuration/timeout.rb

@@ -7,7 +7,7 @@ module Makit
       # Default timeout values for different operations
       DEFAULTS = {
         # Command execution timeouts
-        command: 30,
+        command: 120,
         git_clone: 300,
         git_pull: 120,
         bundle_install: 300,

data/lib/makit/configuration.rb

@@ -8,6 +8,11 @@ require_relative "configuration/gitlab_helper"
 require_relative "configuration/rakefile_helper"
 require_relative "configuration/timeout"
 
+# Load gRPC service implementation only if generated files exist
+if File.exist?(File.join(__dir__, "generated", "makit", "v1", "configuration", "project_service_services_pb.rb"))
+  require_relative "v1/configuration/project_service_impl"
+end
+
 # Main configuration module that loads all configuration classes
 module Makit
   module Configuration

data/lib/makit/fileinfo.rb

@@ -13,6 +13,14 @@ module Makit
       @size = size
     end
 
+    def to_h
+      {
+        name: @name,
+        mtime: @mtime,
+        size: @size
+      }
+    end
+
     def self.get_file_infos(filenames)
       filenames.map do |filename|
         FileInfo.new(name: filename, mtime: File.mtime(filename), size: File.size(filename))