cline-rb 1.0.0

data/lib/cline/utils/os/linux.rb

@@ -0,0 +1,43 @@
+module Cline
+  module Utils
+    module Os
+      # OS utils for host OS linux
+      module Linux
+        include Logger
+
+        # Get the user home directory path
+        #
+        # @return [String] Normalized absolute path to user home directory
+        def user_home_dir
+          @user_home_dir ||= `eval echo ~$USER`.strip
+        end
+
+        # Kill a process
+        # Handles errors gracefully in case the process has already disappeared.
+        #
+        # @param pid [Integer] Process to kill
+        def kill(pid)
+          Process.kill('TERM', pid)
+        rescue Errno::ESRCH
+          # Could be that the process naturally died before we interrupted it
+          log_debug "Process #{pid} was already killed"
+        end
+
+        # @return [Array<String>] The Cline executable command line (can also have some arguments)
+        def cline_exe
+          ['cline']
+        end
+
+        # @return [String] The user applications data directory
+        def user_app_data_dir
+          "#{user_home_dir}/.config"
+        end
+
+        # @return [Integer] Maximum length a command line can have
+        def max_cmd_length
+          @max_cmd_length ||= Integer(`getconf ARG_MAX`.strip)
+        end
+      end
+    end
+  end
+end

data/lib/cline/utils/os/mingw32.rb

@@ -0,0 +1,46 @@
+module Cline
+  module Utils
+    module Os
+      # OS utils for host OS mingw32
+      module Mingw32
+        # Get the user home directory path
+        #
+        # @return [String] Normalized absolute path to user home directory
+        def user_home_dir
+          ENV['USERPROFILE'].gsub('\\', '/')
+        end
+
+        # Kill a process.
+        # Handles errors gracefully in case the process has already disappeared.
+        #
+        # @param pid [Integer] Process to kill
+        def kill(pid)
+          # Don't use Process.kill on Windows, because the killed process will have an exit status 0, which is incorrect.
+          # TODO: Use Process.kill here when Process.kill will be fixed on Windows systems.
+          system("taskkill /f /pid #{pid}")
+        end
+
+        # @return [Array<String>] The Cline executable command line (can also have some arguments)
+        def cline_exe
+          # As this CLI will be used with PTY.spawn and we want multiline support,
+          # don't use cline.cmd npm wrapper as it treats "\n" as new command lines.
+          # Therefore we use the node.exe binary directly.
+          @cline_exe ||= [
+            'node.exe',
+            "#{::File.dirname(`where cline.cmd`.split("\n").first)}/node_modules/cline/bin/cline"
+          ]
+        end
+
+        # @return [String] The user applications data directory
+        def user_app_data_dir
+          ENV['APPDATA'] || raise('APPDATA environment variable should be set to know the applications data dir')
+        end
+
+        # @return [Integer] Maximum length a command line can have
+        def max_cmd_length
+          8191
+        end
+      end
+    end
+  end
+end

data/lib/cline/utils/os.rb

@@ -0,0 +1,31 @@
+require 'os'
+
+module Cline
+  module Utils
+    # Provide OS-specific helpers
+    module Os
+      class << self
+        # @return [String] The Host OS that has been installed
+        attr_accessor :installed_host_os
+
+        # Install OS-specific methods in this module
+        #
+        # @param host_os [String] Host OS for which we install the methods
+        def self.install_os_methods(host_os: OS.host_os)
+          # Auto-extend with correct OS implementation at load time
+          require_relative "os/#{host_os}.rb"
+          host_os_module = Os.const_get(host_os.split('_').map(&:capitalize).join.to_sym)
+          Os.installed_host_os = host_os
+          # Clean eventually other methods that were installed before
+          host_os_module.instance_methods.each do |method|
+            undef_method(method) if method_defined?(method)
+            define_method(method, host_os_module.instance_method(method))
+          end
+        end
+
+        # Install the OS-specific methods
+        install_os_methods
+      end
+    end
+  end
+end

data/lib/cline/utils/schema.rb

@@ -0,0 +1,290 @@
+require 'forwardable'
+require 'shale'
+
+module Cline
+  module Utils
+    # Provide some utility methods that are related to schema handling
+    module Schema
+      # @!group Internal
+
+      # Provide a class that can be used by Shale to read and write maps of objects (dynamic keys), like this:
+      # {
+      #   "key1": { ... another Shale structure ... },
+      #   "key2": { ... another Shale structure ... },
+      #   ...
+      #   "keyN": { ... another Shale structure ... }
+      # }
+      #
+      # @param shale_type [Symbol, Class] The shale type that this class should expect for the map's values
+      # @return [Class] Class that can be used in an attribute declaration
+      def self.map(shale_type)
+        shale_type = Shale::Type.lookup(shale_type) if shale_type.is_a?(Symbol)
+        # Give a name to this class because Shale needs it to reference it in its accessors.
+        # That also allows us to not redefine the same class several times.
+        external_name = :"MapOf#{shale_type.to_s.gsub(':', '')}"
+        unless Schema.const_defined?(external_name)
+          schema_class = Class.new(Cline::Schema) do
+            extend Forwardable
+
+            # @!group Public API
+
+            include Enumerable
+
+            def_delegators :elements_hash, *%i[[] each empty? key? keys size to_hash values]
+
+            # Constructor
+            #
+            # @param elements_hash [Hash{String => shale_type}] The elements to initialize the structure with
+            def initialize(elements_hash = {})
+              super()
+              @elements_hash = elements_hash
+            end
+
+            # Set a key and its corresponding value.
+            # Handle potential casting for the value.
+            #
+            # @param key [Object] The key to set.
+            # @param value [Object] The value to set.
+            def []=(key, value)
+              elements_hash[key] = self.class.value_type.cast(value)
+            end
+
+            # Equality check
+            #
+            # @param other [Object] The other to check equality with
+            # @return [Boolean] True if objects are equal
+            def ==(other)
+              other.is_a?(self.class) &&
+                other.elements_hash == elements_hash
+            end
+
+            # @!group Internal
+
+            # @return [Hash] The elements hash taken from the extra attributes
+            attr_accessor :elements_hash
+
+            class << self
+              attr_accessor :value_type, :external_name
+
+              # Hook called when a subclass inherits our class
+              #
+              # @param subclass [Class] The inheriting class
+              def inherited(subclass)
+                super
+                subclass.value_type = value_type
+              end
+
+              # Parse a Hash object and instantiate the proper instance from it.
+              #
+              # @param hash [Hash] Data
+              # @param args [Array] Remaining arguments to be transferred to Shale
+              # @param kwargs [Hash] Remaining kwargs to be transferred to Shale
+              # @return [Schema] Corresponding instance
+              def of_hash(hash, *args, **kwargs)
+                instance = super
+                # Move the extra attributes into properly constructed elements_hash
+                instance.elements_hash =
+                  if instance.extra_attributes.nil?
+                    {}
+                  else
+                    instance.extra_attributes.to_h do |key, value|
+                      [
+                        key,
+                        @value_type.of_hash(value, *args, **kwargs)
+                      ]
+                    end
+                  end
+                instance
+              end
+
+              # Get a Hash object from an instance.
+              #
+              # @param instance [Schema] Object to serialize to a Hash
+              # @param args [Array] Remaining arguments to be transferred to Shale
+              # @param kwargs [Hash] Remaining kwargs to be transferred to Shale
+              # @return [Hash] Corresponding hash
+              def as_hash(instance, *args, **kwargs)
+                # Set the extra_attributes properly
+                unless instance.elements_hash.empty?
+                  instance.extra_attributes = instance.elements_hash.to_h do |key, value|
+                    [
+                      key,
+                      @value_type.as_hash(value, *args, **kwargs)
+                    ]
+                  end
+                end
+                super
+              end
+
+              # Cast an input value to this Schema object.
+              # Allow the attribute to be initialized directly using its Hash form.
+              #
+              # @param value [Schema, Hash, nil] The value that could be used to initialize a new instance of this attribute.
+              # @return [Schema, nil] The corresponding instance, or nil if none.
+              def cast(value)
+                return nil if value.nil?
+
+                # We expect the value to be a Hash of values that can themselves be cast using the Shale type, or a new instance already initialized.
+                if value.is_a?(self)
+                  value
+                elsif value.is_a?(Hash)
+                  new(value.to_h { |k, v| [k, value_type.cast(v)] })
+                else
+                  raise "Unable to cast #{value} into #{name}"
+                end
+              end
+
+              # Return the class name
+              #
+              # @return [String] The class name
+              def to_s
+                "::Cline::Utils::Schema::#{@external_name}"
+              end
+            end
+          end
+          schema_class.value_type = shale_type
+          schema_class.external_name = external_name
+          Schema.const_set(external_name, schema_class)
+        end
+        Schema.const_get(external_name)
+      end
+
+      # Provide a class that can be used by Shale to read and write arrays of objects, like this:
+      # [
+      #   { ... another Shale structure ... },
+      #   { ... another Shale structure ... },
+      #   ...
+      #   { ... another Shale structure ... }
+      # ]
+      # We don't use the native Shale collection's feature as it does not support type casting at element,
+      #   and so prevents initialization like that: my_object.my_collection = [{ attr: 1 }, { attr: 2 }].
+      #
+      # @param shale_type [Symbol, Class] The shale type that this class should expect for the array's values
+      # @return [Class] Class that can be used in an attribute declaration
+      def self.collection(shale_type)
+        shale_type = Shale::Type.lookup(shale_type) if shale_type.is_a?(Symbol)
+        # Give a name to this class because Shale needs it to reference it in its accessors.
+        # That also allows us to not redefine the same class several times.
+        external_name = :"CollectionOf#{shale_type.to_s.gsub(':', '')}"
+        unless Schema.const_defined?(external_name)
+          schema_class = Class.new(Cline::Schema) do
+            extend Forwardable
+
+            # @!group Public API
+
+            include Enumerable
+
+            def_delegators :elements, *%i[[] each empty? last size]
+
+            # Constructor
+            #
+            # @param elements [Array<shale_type>] The elements to initialize the structure with
+            def initialize(elements = [])
+              super()
+              @elements = elements
+            end
+
+            # Set a value at a given index.
+            # Handle potential casting for the value.
+            #
+            # @param idx [Integer] The integer to set.
+            # @param value [Object] The value to set.
+            def []=(idx, value)
+              elements[idx] = self.class.value_type.cast(value)
+            end
+
+            # Append a value.
+            # Handle potential casting for the value.
+            #
+            # @param value [Object] The value to set.
+            def <<(value)
+              elements << self.class.value_type.cast(value)
+            end
+
+            # Equality check
+            #
+            # @param other [Object] The other to check equality with
+            # @return [Boolean] True if objects are equal
+            def ==(other)
+              other.is_a?(self.class) &&
+                other.elements == elements
+            end
+
+            # @!group Internal
+
+            # Output this object as a Ruby object that can be JSON-serialized.
+            #
+            # @return [Object] Ruby object ready for JSON
+            def to_hash
+              elements.map { |element| element.respond_to?(:to_hash) ? element.to_hash : element }
+            end
+
+            # @return [Hash] The elements array
+            attr_accessor :elements
+
+            class << self
+              attr_accessor :value_type, :external_name
+
+              # Hook called when a subclass inherits our class
+              #
+              # @param subclass [Class] The inheriting class
+              def inherited(subclass)
+                super
+                subclass.value_type = value_type
+              end
+
+              # Parse a Ruby object and instantiate the proper instance from it.
+              #
+              # @param hash [Object] Data
+              # @param args [Array] Remaining arguments to be transferred to Shale
+              # @param kwargs [Hash] Remaining kwargs to be transferred to Shale
+              # @return [Schema] Corresponding instance
+              def of_hash(hash, *args, **kwargs)
+                new(hash.map { |element| value_type.of_hash(element, *args, **kwargs) })
+              end
+
+              # Get a Ruby object from an instance.
+              #
+              # @param instance [Schema] Object to serialize to a Hash
+              # @param args [Array] Remaining arguments to be transferred to Shale
+              # @param kwargs [Hash] Remaining kwargs to be transferred to Shale
+              # @return [Object] Corresponding Ruby object
+              def as_hash(instance, *args, **kwargs)
+                instance.elements.map { |element| value_type.as_hash(element, *args, **kwargs) }
+              end
+
+              # Cast an input value to this Schema object.
+              # Allow the attribute to be initialized directly using its Array form.
+              #
+              # @param value [Schema, Array, nil] The value that could be used to initialize a new instance of this attribute.
+              # @return [Schema, nil] The corresponding instance, or nil if none.
+              def cast(value)
+                return nil if value.nil?
+
+                # We expect the value to be a Array of values that can themselves be cast using the Shale type, or a new instance already initialized.
+                if value.is_a?(self)
+                  value
+                elsif value.is_a?(Array)
+                  new(value.map { |element| value_type.cast(element) })
+                else
+                  raise "Unable to cast #{value} into #{name}"
+                end
+              end
+
+              # Return the class name
+              #
+              # @return [String] The class name
+              def to_s
+                "::Cline::Utils::Schema::#{@external_name}"
+              end
+            end
+          end
+          schema_class.value_type = shale_type
+          schema_class.external_name = external_name
+          Schema.const_set(external_name, schema_class)
+        end
+        Schema.const_get(external_name)
+      end
+    end
+  end
+end

data/lib/cline/version.rb

@@ -0,0 +1,6 @@
+module Cline
+  # @!group Public API
+
+  # Gem version
+  VERSION = '1.0.0'
+end

data/lib/cline/workspace.rb

@@ -0,0 +1,25 @@
+module Cline
+  # A workspace defined in a directory
+  class Workspace
+    # @!group Public API
+
+    include Serializable::Dir
+
+    # Get the workspace settings
+    #
+    # @param create [Boolean] Should the data be created if it does not exist?
+    # @return [WorkspaceSettings, nil] The workspace settings or nil if none
+    def settings(create: self.create)
+      @settings ||= WorkspaceSettings.from_cline_data(dir, create:)
+    end
+
+    # Equality check
+    #
+    # @param other [Object] The other to check equality with
+    # @return [Boolean] True if objects are equal
+    def ==(other)
+      other.is_a?(Workspace) &&
+        other.settings == settings
+    end
+  end
+end

data/lib/cline/workspace_settings.rb

@@ -0,0 +1,29 @@
+module Cline
+  # Workspace settings from workspaceState.json
+  class WorkspaceSettings < Schema
+    # @!group Public API
+
+    Serializable::ClineData.include_for(self, 'workspaceState.json')
+
+    # @return [Hash{String => Boolean}] Local skills toggle states
+    attribute :local_skills_toggles, Utils::Schema.map(:boolean)
+
+    # @return [Hash{String => Boolean}] Local Cline rules toggle states
+    attribute :local_cline_rules_toggles, Utils::Schema.map(:boolean)
+
+    # @return [Hash{String => Boolean}] Local Agents rules toggle states
+    attribute :local_agents_rules_toggles, Utils::Schema.map(:boolean)
+
+    # @return [Hash{String => Boolean}] Workflow toggle states
+    attribute :workflow_toggles, Utils::Schema.map(:boolean)
+
+    # @return [Hash{String => Boolean}] Local Windsurf rules toggle states
+    attribute :local_windsurf_rules_toggles, Utils::Schema.map(:boolean)
+
+    # @return [Hash{String => Boolean}] Local Cursor rules toggle states
+    attribute :local_cursor_rules_toggles, Utils::Schema.map(:boolean)
+
+    # @return [Integer] VSCode migration version
+    attribute :__vscode_migration_version, :integer
+  end
+end

data/lib/cline/workspaces.rb

@@ -0,0 +1,8 @@
+module Cline
+  # Provide a set of wokspaces from a directory
+  class Workspaces
+    # @!group Public API
+
+    Utils::EnumerableDirObjects.include_for(self, Workspace)
+  end
+end

data/lib/cline.rb

@@ -0,0 +1,22 @@
+require 'zeitwerk'
+
+Zeitwerk::Loader.for_gem.setup
+
+# All Cline objects are accessible here.
+module Cline
+  class << self
+    # @!group Public API
+
+    # Configure the behaviour of the cline-rb Rubygem
+    #
+    # @yield [config] The configuration
+    def configure
+      yield config
+    end
+
+    # @return [Configuration] The cline-rb Rubygem configuration
+    def config
+      @config ||= Configuration.new
+    end
+  end
+end