nightona 0.191.0

data/lib/nightona/git.rb

@@ -0,0 +1,334 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  class Git
+    include Instrumentation
+
+    # @return [String] The Sandbox ID
+    attr_reader :sandbox_id
+
+    # @return [NightonaToolboxApiClient::GitApi] API client for Sandbox operations
+    attr_reader :toolbox_api
+
+    # Initializes a new Git handler instance.
+    #
+    # @param sandbox_id [String] The Sandbox ID.
+    # @param toolbox_api [NightonaToolboxApiClient::GitApi] API client for Sandbox operations.
+    # @param otel_state [Nightona::OtelState, nil]
+    def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
+      @sandbox_id = sandbox_id
+      @toolbox_api = toolbox_api
+      @otel_state = otel_state
+    end
+
+    # Stages the specified files for the next commit, similar to
+    # running 'git add' on the command line.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param files [Array<String>] List of file paths or directories to stage, relative to the repository root.
+    # @return [void]
+    # @raise [Nightona::Sdk::Error] if adding files fails
+    #
+    # @example
+    #   # Stage a single file
+    #   sandbox.git.add("workspace/repo", ["file.txt"])
+    #
+    #   # Stage multiple files
+    #   sandbox.git.add("workspace/repo", [
+    #     "src/main.rb",
+    #     "spec/main_spec.rb",
+    #     "README.md"
+    #   ])
+    def add(path, files)
+      toolbox_api.add_files(NightonaToolboxApiClient::GitAddRequest.new(path:, files:))
+    rescue NightonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to add files')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to add files: #{e.message}"
+    end
+
+    # Lists branches in the repository.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @return [NightonaApiClient::ListBranchResponse] List of branches in the repository.
+    # @raise [Nightona::Sdk::Error] if listing branches fails
+    #
+    # @example
+    #   response = sandbox.git.branches("workspace/repo")
+    #   puts "Branches: #{response.branches}"
+    def branches(path)
+      toolbox_api.list_branches(path)
+    rescue NightonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to list branches')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to list branches: #{e.message}"
+    end
+
+    # Clones a Git repository into the specified path. It supports
+    # cloning specific branches or commits, and can authenticate with the remote
+    # repository if credentials are provided.
+    #
+    # @param url [String] Repository URL to clone from.
+    # @param path [String] Path where the repository should be cloned. Relative paths are resolved
+    #   based on the sandbox working directory.
+    # @param branch [String, nil] Specific branch to clone. If not specified,
+    #   clones the default branch.
+    # @param commit_id [String, nil] Specific commit to clone. If specified,
+    #   the repository will be left in a detached HEAD state at this commit.
+    # @param username [String, nil] Git username for authentication.
+    # @param password [String, nil] Git password or token for authentication.
+    # @param insecure_skip_tls [Boolean, nil] Skip TLS certificate verification (insecure).
+    #   Use only for trusted internal Git servers with self-signed or private-CA certs;
+    #   credentials, if supplied, are transmitted over an unverified TLS connection.
+    # @return [void]
+    # @raise [Nightona::Sdk::Error] if cloning repository fails
+    #
+    # @example
+    #   # Clone the default branch
+    #   sandbox.git.clone(
+    #     url: "https://github.com/user/repo.git",
+    #     path: "workspace/repo"
+    #   )
+    #
+    #   # Clone a specific branch with authentication
+    #   sandbox.git.clone(
+    #     url: "https://github.com/user/private-repo.git",
+    #     path: "workspace/private",
+    #     branch: "develop",
+    #     username: "user",
+    #     password: "token"
+    #   )
+    #
+    #   # Clone a specific commit
+    #   sandbox.git.clone(
+    #     url: "https://github.com/user/repo.git",
+    #     path: "workspace/repo-old",
+    #     commit_id: "abc123"
+    #   )
+    def clone(url:, path:, branch: nil, commit_id: nil, username: nil, password: nil, insecure_skip_tls: nil) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      toolbox_api.clone_repository(
+        NightonaToolboxApiClient::GitCloneRequest.new(
+          url: url,
+          branch: branch,
+          path: path,
+          username: username,
+          password: password,
+          commit_id: commit_id,
+          insecure_skip_tls: insecure_skip_tls
+        )
+      )
+    rescue NightonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to clone repository')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to clone repository: #{e.message}"
+    end
+
+    # Creates a new commit with the staged changes. Make sure to stage
+    # changes using the add() method before committing.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param message [String] Commit message describing the changes.
+    # @param author [String] Name of the commit author.
+    # @param email [String] Email address of the commit author.
+    # @param allow_empty [Boolean] Allow creating an empty commit when no changes are staged. Defaults to false.
+    # @return [GitCommitResponse] Response containing the commit SHA.
+    # @raise [Nightona::Sdk::Error] if committing changes fails
+    #
+    # @example
+    #   # Stage and commit changes
+    #   sandbox.git.add("workspace/repo", ["README.md"])
+    #   commit_response = sandbox.git.commit(
+    #     path: "workspace/repo",
+    #     message: "Update documentation",
+    #     author: "John Doe",
+    #     email: "john@example.com",
+    #     allow_empty: true
+    #   )
+    #   puts "Commit SHA: #{commit_response.sha}"
+    def commit(path:, message:, author:, email:, allow_empty: false)
+      response = toolbox_api.commit_changes(
+        NightonaToolboxApiClient::GitCommitRequest.new(path:, message:, author:, email:, allow_empty:)
+      )
+      GitCommitResponse.new(sha: response._hash)
+    rescue NightonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to commit changes')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to commit changes: #{e.message}"
+    end
+
+    # Pushes all local commits on the current branch to the remote
+    # repository. If the remote repository requires authentication, provide
+    # username and password/token.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param username [String, nil] Git username for authentication.
+    # @param password [String, nil] Git password or token for authentication.
+    # @return [void]
+    # @raise [Nightona::Sdk::Error] if pushing changes fails
+    #
+    # @example
+    #   # Push without authentication (for public repos or SSH)
+    #   sandbox.git.push("workspace/repo")
+    #
+    #   # Push with authentication
+    #   sandbox.git.push(
+    #     path: "workspace/repo",
+    #     username: "user",
+    #     password: "github_token"
+    #   )
+    def push(path:, username: nil, password: nil)
+      toolbox_api.push_changes(
+        NightonaToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
+      )
+    rescue NightonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to push changes')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to push changes: #{e.message}"
+    end
+
+    # Pulls changes from the remote repository. If the remote repository requires authentication,
+    # provide username and password/token.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param username [String, nil] Git username for authentication.
+    # @param password [String, nil] Git password or token for authentication.
+    # @return [void]
+    # @raise [Nightona::Sdk::Error] if pulling changes fails
+    #
+    # @example
+    #   # Pull without authentication
+    #   sandbox.git.pull("workspace/repo")
+    #
+    #   # Pull with authentication
+    #   sandbox.git.pull(
+    #     path: "workspace/repo",
+    #     username: "user",
+    #     password: "github_token"
+    #   )
+    #
+    def pull(path:, username: nil, password: nil)
+      toolbox_api.pull_changes(
+        NightonaToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
+      )
+    rescue NightonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to pull changes')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to pull changes: #{e.message}"
+    end
+
+    # Gets the current Git repository status.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @return [NightonaToolboxApiClient::GitStatus] Repository status information including:
+    # @raise [Nightona::Sdk::Error] if getting status fails
+    #
+    # @example
+    #   status = sandbox.git.status("workspace/repo")
+    #   puts "On branch: #{status.current_branch}"
+    #   puts "Commits ahead: #{status.ahead}"
+    #   puts "Commits behind: #{status.behind}"
+    def status(path)
+      toolbox_api.get_status(path)
+    rescue NightonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to get status')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get status: #{e.message}"
+    end
+
+    # Checkout branch in the repository.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param branch [String] Name of the branch to checkout
+    # @return [void]
+    # @raise [Nightona::Sdk::Error] if checking out branch fails
+    #
+    # @example
+    #   # Checkout a branch
+    #   sandbox.git.checkout_branch("workspace/repo", "feature-branch")
+    def checkout_branch(path, branch)
+      toolbox_api.checkout_branch(
+        NightonaToolboxApiClient::GitCheckoutRequest.new(path:, branch:)
+      )
+    rescue NightonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to checkout branch')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to checkout branch: #{e.message}"
+    end
+
+    # Create branch in the repository.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param name [String] Name of the new branch to create
+    # @return [void]
+    # @raise [Nightona::Sdk::Error] if creating branch fails
+    #
+    # @example
+    #   # Create a new branch
+    #   sandbox.git.create_branch("workspace/repo", "new-feature")
+    #
+    def create_branch(path, name)
+      toolbox_api.create_branch(
+        NightonaToolboxApiClient::GitBranchRequest.new(path:, name:)
+      )
+    rescue NightonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to create branch')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to create branch: #{e.message}"
+    end
+
+    # Delete branch in the repository.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param name [String] Name of the branch to delete
+    # @return [void]
+    # @raise [Nightona::Sdk::Error] if deleting branch fails
+    #
+    # @example
+    #   # Delete a branch
+    #   sandbox.git.delete_branch("workspace/repo", "old-feature")
+    def delete_branch(path, name)
+      toolbox_api.delete_branch(
+        NightonaToolboxApiClient::GitDeleteBranchRequest.new(path:, name:)
+      )
+    rescue NightonaToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to delete branch')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to delete branch: #{e.message}"
+    end
+
+    instrument :add, :branches, :clone, :commit, :push, :pull, :status,
+               :checkout_branch, :create_branch, :delete_branch,
+               component: 'Git'
+
+    private
+
+    # @return [Nightona::OtelState, nil]
+    attr_reader :otel_state
+
+    def map_api_error(api_error, prefix)
+      msg = "#{prefix}: #{api_error.message}"
+      case api_error.code
+      when 400 then Sdk::ValidationError.new(msg)
+      when 401 then Sdk::AuthenticationError.new(msg)
+      when 403 then Sdk::ForbiddenError.new(msg)
+      when 404 then Sdk::NotFoundError.new(msg)
+      when 409 then Sdk::ConflictError.new(msg)
+      when 429 then Sdk::RateLimitError.new(msg)
+      when 500..599 then Sdk::ServerError.new(msg)
+      else Sdk::Error.new(msg)
+      end
+    end
+  end
+end

data/lib/nightona/lsp_server.rb

@@ -0,0 +1,139 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  class LspServer
+    include Instrumentation
+
+    module Language
+      ALL = [
+        JAVASCRIPT = :javascript,
+        PYTHON = :python,
+        TYPESCRIPT = :typescript
+
+      ].freeze
+    end
+
+    # Represents a zero-based position in a text document,
+    # specified by line number and character offset.
+    Position = Data.define(:line, :character)
+
+    # @return [Symbol]
+    attr_reader :language_id
+
+    # @return [String]
+    attr_reader :path_to_project
+
+    # @return [NightonaToolboxApiClient::LspApi]
+    attr_reader :toolbox_api
+
+    # @return [String]
+    attr_reader :sandbox_id
+
+    # @param language_id [Symbol]
+    # @param path_to_project [String]
+    # @param toolbox_api [NightonaToolboxApiClient::LspApi]
+    # @param sandbox_id [String]
+    # @param otel_state [Nightona::OtelState, nil]
+    def initialize(language_id:, path_to_project:, toolbox_api:, sandbox_id:, otel_state: nil)
+      @language_id = language_id
+      @path_to_project = path_to_project
+      @toolbox_api = toolbox_api
+      @sandbox_id = sandbox_id
+      @otel_state = otel_state
+    end
+
+    # Gets completion suggestions at a position in a file
+    #
+    # @param path [String]
+    # @param position [Nightona::LspServer::Position]
+    # @return [NightonaApiClient::CompletionList]
+    def completions(path:, position:)
+      toolbox_api.completions(
+        NightonaToolboxApiClient::LspCompletionParams.new(
+          language_id:,
+          path_to_project:,
+          uri: uri(path),
+          position: NightonaApiClient::Position.new(line: position.line, character: position.character)
+        )
+      )
+    end
+
+    # Notify the language server that a file has been closed.
+    # This method should be called when a file is closed in the editor to allow
+    # the language server to clean up any resources associated with that file.
+    #
+    # @param path [String]
+    # @return [void]
+    def did_close(path)
+      toolbox_api.did_close(
+        NightonaToolboxApiClient::LspDocumentRequest.new(language_id:, path_to_project:, uri: uri(path))
+      )
+    end
+
+    # Notifies the language server that a file has been opened.
+    # This method should be called when a file is opened in the editor to enable
+    # language features like diagnostics and completions for that file. The server
+    # will begin tracking the file's contents and providing language features.
+    #
+    # @param path [String]
+    # @return [void]
+    def did_open(path)
+      toolbox_api.did_open(
+        NightonaToolboxApiClient::LspDocumentRequest.new(language_id:, path_to_project:, uri: uri(path))
+      )
+    end
+
+    # Gets symbol information (functions, classes, variables, etc.) from a document.
+    #
+    # @param path [String]
+    # @return [Array<NightonaToolboxApiClient::LspSymbol]
+    def document_symbols(path) = toolbox_api.document_symbols(language_id, path_to_project, uri(path))
+
+    # Searches for symbols matching the query string across all files
+    # in the Sandbox.
+    #
+    # @param query [String]
+    # @return [Array<NightonaToolboxApiClient::LspSymbol]
+    def sandbox_symbols(query) = toolbox_api.workspace_symbols(query, language_id, path_to_project)
+
+    # Starts the language server.
+    # This method must be called before using any other LSP functionality.
+    # It initializes the language server for the specified language and project.
+    #
+    # @return [void]
+    def start
+      toolbox_api.start(
+        NightonaToolboxApiClient::LspServerRequest.new(language_id:, path_to_project:)
+      )
+    end
+
+    # Stops the language server.
+    # This method should be called when the LSP server is no longer needed to
+    # free up system resources.
+    #
+    # @return [void]
+    def stop
+      toolbox_api.stop(
+        NightonaToolboxApiClient::LspServerRequest.new(language_id:, path_to_project:)
+      )
+    end
+
+    instrument :completions, :did_close, :did_open, :document_symbols, :sandbox_symbols,
+               :start, :stop,
+               component: 'LspServer'
+
+    private
+
+    # @return [Nightona::OtelState, nil]
+    attr_reader :otel_state
+
+    # Convert path to file uri.
+    #
+    # @param path [String]
+    # @return [String]
+    def uri(path) = "file://#{path}"
+  end
+end