rakit 0.1.4 → 0.1.6

data/lib/rakit/file.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "generated/rakit.file_pb"
+
+module Rakit
+  # Protobuf-first file operations (list directory, copy file). See specs/005-file-ops/contracts/ruby-api.md.
+  module File
+    class << self
+      # @param request [Rakit::File::ListRequest]
+      # @return [Rakit::File::ListResult]
+      def list(request)
+        dir_path = normalize_path(request.directory.to_s)
+        if dir_path.nil?
+          return error_list_result("Empty or invalid directory path", 1)
+        end
+        unless ::File.exist?(dir_path)
+          return error_list_result("Directory does not exist: #{dir_path}", 1)
+        end
+        unless ::File.directory?(dir_path)
+          return error_list_result("Not a directory: #{dir_path}", 1)
+        end
+
+        include_hidden = request.include_hidden
+        follow_symlinks = request.config&.follow_symlinks == true
+        entries = request.recursive ? list_entries_recursive(dir_path, include_hidden, follow_symlinks) : list_entries_one_dir(dir_path, include_hidden, follow_symlinks)
+
+        ListResult.new(
+          success: true,
+          message: "",
+          entries: entries,
+          exit_code: 0,
+          stderr: ""
+        )
+      rescue => e
+        error_list_result("#{e.message}", 1)
+      end
+
+      # @param request [Rakit::File::CopyRequest]
+      # @return [Rakit::File::CopyResult]
+      def copy(request)
+        config = request.config || FileConfig.new
+        src = normalize_path(request.source.to_s)
+        dest_raw = normalize_path(request.destination.to_s)
+
+        if src.nil? || dest_raw.nil?
+          return error_copy_result(request.source.to_s, request.destination.to_s, "Empty or invalid path", 1)
+        end
+        unless ::File.exist?(src)
+          return error_copy_result(src, dest_raw, "Source does not exist: #{src}", 1)
+        end
+        if ::File.directory?(src)
+          return error_copy_result(src, dest_raw, "Source is a directory (MVP: file only)", 1)
+        end
+
+        dest_path = resolve_copy_destination(src, dest_raw)
+        parent = ::File.dirname(dest_path)
+
+        unless ::File.directory?(parent)
+          if config.create_directories
+            FileUtils.mkdir_p(parent)
+          else
+            return error_copy_result(src, dest_path, "Parent directory does not exist: #{parent}", 1)
+          end
+        end
+
+        if ::File.file?(dest_path) && !config.overwrite
+          return error_copy_result(src, dest_path, "Destination file exists (use overwrite to replace)", 1)
+        end
+
+        bytes = perform_copy(src, dest_path, config)
+        CopyResult.new(
+          success: true,
+          message: "",
+          source: src,
+          destination: dest_path,
+          exit_code: 0,
+          stderr: "",
+          bytes_copied: bytes || 0
+        )
+      rescue => e
+        error_copy_result(request.source.to_s, request.destination.to_s, e.message, 1)
+      end
+
+      private
+
+      # T004: Path normalization. Returns expanded absolute path or nil if nil/empty.
+      def normalize_path(path, base_dir = nil)
+        return nil if path.nil?
+        s = path.to_s.strip
+        return nil if s.empty?
+        base = base_dir || Dir.pwd
+        ::File.expand_path(s, base)
+      end
+
+      def error_list_result(message, exit_code)
+        ListResult.new(success: false, message: message, entries: [], exit_code: exit_code, stderr: message)
+      end
+
+      def error_copy_result(source, destination, message, exit_code)
+        CopyResult.new(success: false, message: message, source: source.to_s, destination: destination.to_s, exit_code: exit_code, stderr: message)
+      end
+
+      # T005: List entries for one directory; sort by name; filter hidden; best-effort metadata.
+      def list_entries_one_dir(dir_path, include_hidden, follow_symlinks)
+        names = Dir.children(dir_path)
+        names.reject! { |n| n.start_with?(".") } unless include_hidden
+        names.sort!
+        names.map { |name| file_entry_for(::File.join(dir_path, name), name, follow_symlinks) }
+      end
+
+      def file_entry_for(abs_path, name, follow_symlinks)
+        stat = follow_symlinks ? (::File.stat(abs_path) rescue nil) : (::File.lstat(abs_path) rescue nil)
+        is_symlink = ::File.symlink?(abs_path)
+        is_dir = stat ? stat.directory? : false
+        size_bytes = (stat && stat.file?) ? (stat.size rescue 0) : 0
+        modified_unix_ms = stat ? (stat.mtime.to_f * 1000).to_i : 0
+        FileEntry.new(
+          path: abs_path,
+          name: name,
+          is_directory: is_dir,
+          is_symlink: is_symlink,
+          size_bytes: size_bytes,
+          modified_unix_ms: modified_unix_ms
+        )
+      rescue
+        FileEntry.new(path: abs_path, name: name, is_directory: false, is_symlink: false, size_bytes: 0, modified_unix_ms: 0)
+      end
+
+      # T006: Depth-first recursive list; children at each level sorted by name.
+      def list_entries_recursive(dir_path, include_hidden, follow_symlinks)
+        entries = list_entries_one_dir(dir_path, include_hidden, follow_symlinks)
+        result = []
+        entries.each do |entry|
+          result << entry
+          if entry.is_directory
+            result.concat(list_entries_recursive(entry.path, include_hidden, follow_symlinks))
+          end
+        end
+        result
+      end
+
+      # Resolve destination: if existing directory, copy into it with basename(source); else file path.
+      def resolve_copy_destination(source, destination)
+        return ::File.join(destination, ::File.basename(source)) if ::File.exist?(destination) && ::File.directory?(destination)
+        destination
+      end
+
+      # T007: Atomic copy where possible (temp then rename); respect follow_symlinks for source.
+      def perform_copy(source, dest_path, config)
+        if !config.follow_symlinks && ::File.symlink?(source)
+          # Copy symlink itself: create new symlink with same target
+          target = ::File.readlink(source)
+          ::File.delete(dest_path) if ::File.exist?(dest_path)
+          ::File.symlink(target, dest_path)
+          return 0 # best-effort bytes
+        end
+
+        content = ::File.binread(source)
+        dest_dir = ::File.dirname(dest_path)
+        temp_path = ::File.join(dest_dir, ".rakit_copy_#{Process.pid}_#{object_id}_#{::File.basename(dest_path)}")
+        bytes = nil
+        begin
+          ::File.write(temp_path, content)
+          bytes = content.bytesize
+          ::File.rename(temp_path, dest_path)
+        rescue Errno::EXDEV, Errno::EPERM
+          # Cross-filesystem or rename not allowed: fall back to overwrite
+          ::File.write(dest_path, content)
+          bytes = content.bytesize
+          ::File.delete(temp_path) if ::File.exist?(temp_path)
+        ensure
+          ::File.delete(temp_path) if ::File.exist?(temp_path)
+        end
+        bytes
+      rescue => e
+        raise "Failed to copy: #{e.message}"
+      end
+    end
+  end
+end

data/lib/rakit/gem.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "json"
+require "open3"
 require "rubygems/package"
 
 module Rakit
@@ -11,29 +13,29 @@ module Rakit
       FileUtils.mkdir_p(out_dir)
       gem_file = ::Gem::Package.build(spec)
       FileUtils.mv(gem_file, out_dir)
-      File.join(out_dir, gem_file)
+      ::File.join(out_dir, gem_file)
     end
 
     # Publish the gem to rubygems.org. Loads the gemspec from gemspec_path and
     # expects the .gem file in dirname(gemspec_path)/artifacts/. Run package first.
     def self.publish(gemspec_path)
-      path = File.expand_path(gemspec_path)
+      path = ::File.expand_path(gemspec_path)
       spec = ::Gem::Specification.load(path)
-      out_dir = File.join(File.dirname(path), "artifacts")
-      gem_path = File.join(out_dir, "#{spec.full_name}.gem")
+      out_dir = ::File.join(::File.dirname(path), "artifacts")
+      gem_path = ::File.join(out_dir, "#{spec.full_name}.gem")
       push(gem_path)
     end
 
     # Bump the last digit of the version in the gemspec file (e.g. "0.1.0" -> "0.1.1").
     # Writes the file in place. Returns the new version string.
     def self.bump(gemspec_path)
-      content = File.read(gemspec_path)
+      content = ::File.read(gemspec_path)
       content.sub!(/^(\s*s\.version\s*=\s*["'])([\d.]+)(["'])/) do
         segs = Regexp.last_match(2).split(".")
         segs[-1] = (segs[-1].to_i + 1).to_s
         "#{Regexp.last_match(1)}#{segs.join(".")}#{Regexp.last_match(3)}"
       end or raise "No s.version line found in #{gemspec_path}"
-      File.write(gemspec_path, content)
+      ::File.write(gemspec_path, content)
       content[/s\.version\s*=\s*["']([^"']+)["']/, 1]
     end
 
@@ -41,12 +43,11 @@ module Rakit
     # published, warns and returns without pushing. Raises if the file is missing
     # or if gem push fails.
     def self.push(gem_path)
-      raise "Gem not found: #{gem_path}. Run rake package first." unless File.file?(gem_path)
+      raise "Gem not found: #{gem_path}. Run rake package first." unless ::File.file?(gem_path)
 
-      base = File.basename(gem_path, ".gem")
-      parts = base.split("-")
-      version = parts.pop
-      name = parts.join("-")
+      base = ::File.basename(gem_path, ".gem")
+      name, version = parse_gem_basename(base)
+      raise "Could not parse name/version from #{base}.gem" unless name && version
 
       if version_published?(name, version)
         warn "publish: Version #{version} of #{name} is already published on rubygems.org. Skipping push. Bump the version in the gemspec to publish again."
@@ -57,14 +58,86 @@ module Rakit
       raise "gem push failed" unless success
     end
 
+    # Parse "name-version" basename (no .gem) into [name, version].
+    # Version is the last hyphen-separated segment that looks like a version (e.g. 0.1.5).
+    def self.parse_gem_basename(base)
+      # Match name (may contain hyphens) and version (digits and dots, optional pre-release suffix).
+      m = base.match(/\A(.+)-(\d+(?:\.\d+)*(?:\.\w+)?)\z/)
+      m ? [m[1], m[2]] : nil
+    end
+
     def self.version_published?(name, version)
+      begin
+        return true if version_published_gem_list?(name, version)
+      rescue StandardError
+        # try API fallbacks
+      end
+      begin
+        return true if version_published_v2?(name, version)
+      rescue StandardError
+        # try v1 fallback
+      end
+      begin
+        return true if version_published_v1?(name, version)
+      rescue StandardError
+        nil
+      end
+      false
+    end
+
+    # Run `gem list NAME --remote` and check if version appears in the output.
+    def self.version_published_gem_list?(name, version)
+      out, err, status = Open3.capture3("gem", "list", name, "--remote")
+      return false unless status.success?
+      # Output format: "name (1.0.0, 0.9.0)" or "name (1.0.0)"
+      combined = "#{out}#{err}"
+      combined.each_line do |line|
+        next unless line.include?(name)
+        if line =~ /\s*#{Regexp.escape(name)}\s*\((.*)\)/
+          versions = Regexp.last_match(1).split(",").map(&:strip)
+          return true if versions.include?(version)
+        end
+      end
+      false
+    end
+
+    # GET /api/v2/rubygems/{name}/versions/{version}.json (follows redirects)
+    def self.version_published_v2?(name, version)
       require "net/http"
       require "uri"
       uri = URI("https://rubygems.org/api/v2/rubygems/#{URI::DEFAULT_PARSER.escape(name)}/versions/#{URI::DEFAULT_PARSER.escape(version)}.json")
-      response = Net::HTTP.get_response(uri)
+      response = http_get_following_redirects(uri)
       response.is_a?(Net::HTTPSuccess)
-    rescue StandardError
-      false
+    end
+
+    # GET /api/v1/versions/{name}.json and check if version is in the list
+    def self.version_published_v1?(name, version)
+      require "net/http"
+      require "json"
+      require "uri"
+      uri = URI("https://rubygems.org/api/v1/versions/#{URI::DEFAULT_PARSER.escape(name)}.json")
+      response = http_get_following_redirects(uri)
+      return false unless response.is_a?(Net::HTTPSuccess)
+      list = JSON.parse(response.body)
+      list.is_a?(Array) && list.any? { |h| h["number"] == version }
+    end
+
+    def self.http_get_following_redirects(uri, limit: 5)
+      raise ArgumentError, "redirect limit exceeded" if limit <= 0
+      require "net/http"
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https", open_timeout: 10, read_timeout: 10) do |http|
+        request = Net::HTTP::Get.new(uri)
+        request["User-Agent"] = "rakit (https://rubygems.org/gems/rakit)"
+        http.request(request)
+      end
+      case response
+      when Net::HTTPRedirection
+        location = response["location"]
+        next_uri = location.match?(/\Ahttps?:\/\//) ? URI(location) : URI.join(uri, location)
+        http_get_following_redirects(next_uri, limit: limit - 1)
+      else
+        response
+      end
     end
   end
 end

data/lib/rakit/git.rb

@@ -4,12 +4,18 @@ module Rakit
   module Git
     # Sync the current directory with the remote (git pull, then git push).
     # Runs from Dir.pwd. Raises if not a git repo or if pull/push fails.
+    # If the current branch has no remote tracking branch, pull and push are skipped (no error).
     def self.sync(dir = nil)
       require_relative "shell"
-      target = dir ? File.expand_path(dir) : Dir.pwd
-      raise "Not a git repository: #{target}" unless File.directory?(File.join(target, ".git"))
+      target = dir ? ::File.expand_path(dir) : Dir.pwd
+      raise "Not a git repository: #{target}" unless ::File.directory?(::File.join(target, ".git"))
 
       Dir.chdir(target) do
+        check = Rakit::Shell.run("git rev-parse --abbrev-ref @{u}")
+        if check.exit_status != 0
+          # No upstream configured for current branch; skip sync
+          return
+        end
         result = Rakit::Shell.run("git pull")
         raise "git pull failed" unless result.exit_status == 0
         result = Rakit::Shell.run("git push")
@@ -22,8 +28,8 @@ module Rakit
     # Raises if not a git repo or if add fails.
     def self.integrate(commit_message = nil, dir = nil)
       require_relative "shell"
-      target = dir ? File.expand_path(dir) : Dir.pwd
-      raise "Not a git repository: #{target}" unless File.directory?(File.join(target, ".git"))
+      target = dir ? ::File.expand_path(dir) : Dir.pwd
+      raise "Not a git repository: #{target}" unless ::File.directory?(::File.join(target, ".git"))
 
       message = commit_message || "Integrate"
       Dir.chdir(target) do

data/lib/rakit/hugo.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Rakit
+  # Build Hugo static sites from source. Used by publish_docs and tests.
+  # Contract: specs/008-hugo-docs-site/contracts/ruby-api.md
+  module Hugo
+    class << self
+      attr_accessor :hugo_path
+
+      def hugo_path
+        @hugo_path ||= "hugo"
+      end
+
+      # @param site_dir [String] path to Hugo source (must exist and be a directory)
+      # @param out_dir [String] path for build output
+      # @return [true] on success
+      # @return [false] on failure (Hugo not found, build failed, or invalid site_dir)
+      def build(site_dir:, out_dir:)
+        site_dir = ::File.expand_path(site_dir)
+        out_dir = ::File.expand_path(out_dir)
+        return false unless ::File.directory?(site_dir)
+        return false if ::File.file?(site_dir)
+
+        FileUtils.mkdir_p(out_dir)
+        success = system(hugo_path, "-s", site_dir, "-d", out_dir, out: $stdout, err: $stderr)
+        return false unless success
+        return false unless ::File.directory?(out_dir) && (Dir.entries(out_dir) - %w[. ..]).any?
+
+        true
+      end
+
+      # @param site_dir [String] path to check
+      # @return [Boolean] true if config.toml or config.yaml exists under site_dir
+      def valid_site?(site_dir)
+        dir = ::File.expand_path(site_dir)
+        return false unless ::File.directory?(dir)
+        ::File.file?(::File.join(dir, "config.toml")) || ::File.file?(::File.join(dir, "config.yaml"))
+      end
+    end
+  end
+end

data/lib/rakit/protobuf.rb

@@ -5,19 +5,21 @@ require "fileutils"
 module Rakit
   module Protobuf
     # Generate Ruby from .proto files.
-    # proto_dir: directory containing .proto files (and -I root)
-    # ruby_out: directory for generated *_pb.rb files
+    # proto_dir: directory containing .proto files (and -I root); may be relative to base_dir
+    # ruby_out: directory for generated *_pb.rb files; may be relative to base_dir
+    # base_dir: directory used to expand relative proto_dir and ruby_out (default: Dir.pwd)
     # protoc: executable name/path (default: "protoc")
     # Returns ruby_out if generation ran, nil if no proto files found.
-    def self.generate(proto_dir:, ruby_out:, protoc: "protoc")
+    def self.generate(proto_dir:, ruby_out:, base_dir: Dir.pwd, protoc: "protoc")
+      expanded_proto_dir = File.expand_path(proto_dir, base_dir)
+      expanded_ruby_out = File.expand_path(ruby_out, base_dir)
       # output, in grey, "  generating code from .proto files..."
       puts "\e[30m  generating code from .proto files...\e[0m"
-      expanded_proto_dir = File.expand_path(proto_dir)
       proto_files = Dir[File.join(expanded_proto_dir, "**", "*.proto")]
       return nil if proto_files.empty?
 
-      FileUtils.mkdir_p(ruby_out)
-      args = ["-I", expanded_proto_dir, "--ruby_out=#{ruby_out}", *proto_files]
+      FileUtils.mkdir_p(expanded_ruby_out)
+      args = ["-I", expanded_proto_dir, "--ruby_out=#{expanded_ruby_out}", *proto_files]
       system(protoc, *args) or raise "protoc failed"
 
       # output a green checkmark and the command that was run
@@ -25,14 +27,14 @@ module Rakit
       # output that the files were generated
       #puts "  Generated #{proto_files.size} files in #{ruby_out}"
       # output the files that were generated (all files in the ruby_out directory), once per line
-      ruby_out_files = Dir[File.join(ruby_out, "**", "*_pb.rb")]
+      ruby_out_files = Dir[File.join(expanded_ruby_out, "**", "*_pb.rb")]
       ruby_out_files.each do |file|
         # output, in grey, "  #{File.basename(file)}"
         puts "\e[30m  #{File.basename(file)}\e[0m"
       end
       # output the number of files that were generated
-      #puts "  Generated #{ruby_out_files.size} files in #{ruby_out}"
-      ruby_out
+      #puts "  Generated #{ruby_out_files.size} files in #{expanded_ruby_out}"
+      expanded_ruby_out
     end
   end
 end

data/lib/rakit/shell.rb

@@ -2,7 +2,7 @@
 
 require "open3"
 require "timeout"
-require "generated/shell_pb"
+require "generated/rakit.shell_pb"
 
 module Rakit
   module Shell