rakit 0.1.4 → 0.1.6

data/lib/rakit/static_web_server.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "generated/rakit.static_web_server_pb"
+
+module Rakit
+  # Publish static sites into a configurable root (~/.rakit/wwwroot), regenerate a root index, and control a local HTTP server (start/stop/running).
+  # Host and port are configurable (host default 127.0.0.1, port 5099) and returned regardless of server state for URL building.
+  # CLI: +rakit static-web-server+ (start|stop|running|publish|view). See specs/003-static-web-server/contracts/ruby-api.md and specs/007-wwwroot-docs-hugo-view/contracts/ruby-api.md.
+  module StaticWebServer
+    SITE_NAME_REGEX = /\A[a-z0-9\-]+\z/.freeze
+
+    class << self
+      # @return [String] Static root directory (default ~/.rakit/wwwroot). Used by publish and server lifecycle.
+      attr_accessor :root
+      # @return [String] Host for building URLs (default 127.0.0.1). Returned regardless of server running state.
+      attr_accessor :host
+      # @return [Integer] Default port for start (default 5099). Used when no override passed to start; returned regardless of server running state.
+      attr_accessor :port
+    end
+
+    self.root = ::File.expand_path("~/.rakit/wwwroot")
+    self.host = "127.0.0.1"
+    self.port = 5099
+
+    # T005: Validate site name; raise ArgumentError before any filesystem write.
+    # Single segment (e.g. "mysite") or multi-segment path (e.g. "louparslow/rakit"); each segment must match SITE_NAME_REGEX.
+    def self.validate_site_name!(site_name)
+      validate_site_path!(site_name)
+    end
+
+    def self.validate_site_path!(site_name)
+      return if site_name.nil? || site_name.to_s.empty?
+      site_name.to_s.split(::File::SEPARATOR).each do |seg|
+        next if seg.empty?
+        unless seg.match?(SITE_NAME_REGEX)
+          raise ArgumentError, "site_name segment must be lowercase alphanumeric and dashes only (e.g. my-site); got: #{seg.inspect}"
+        end
+      end
+    end
+
+    # T006: PID file path for start/stop/running (research: ~/.rakit/static_web_server.pid).
+    def self.pid_file_path
+      ::File.expand_path("~/.rakit/static_web_server.pid")
+    end
+
+    # T007: Server binary (miniserve) on PATH; used by start. Returns path or nil.
+    def self.server_binary
+      @server_binary ||= begin
+        path = ENV["RAKIT_STATIC_SERVER_BINARY"]
+        return path if path && !path.empty?
+        which("miniserve")
+      end
+    end
+
+    def self.server_binary=(path)
+      @server_binary = path
+    end
+
+    # T008: Create root directory if missing; used before publish and start.
+    def self.ensure_root
+      FileUtils.mkdir_p(root)
+    end
+
+    # Publish static content from source_directory to root/site_name (atomic copy), then regenerate root index.
+    # @param site_name [String] Single segment (e.g. "mysite") or path (e.g. "louparslow/rakit"); each segment must match \\A[a-z0-9\-]+\\z.
+    # @param source_directory [String] Existing directory path; contents are copied (no traversal outside allowed paths).
+    # @return [true] on success.
+    # @raise [ArgumentError] for invalid site_name, missing/invalid source_directory, or root not writable.
+    def self.publish(site_name, source_directory)
+      validate_site_path!(site_name)
+      src = ::File.expand_path(source_directory)
+      raise ArgumentError, "source_directory does not exist: #{source_directory}" unless ::File.exist?(src)
+      raise ArgumentError, "source_directory is not a directory: #{source_directory}" unless ::File.directory?(src)
+
+      ensure_root
+      unless ::File.writable?(root)
+        raise ArgumentError, "root directory is not writable: #{root}"
+      end
+
+      target = ::File.join(root, site_name)
+      temp_name = ".tmp_#{site_name.to_s.gsub(::File::SEPARATOR, '_')}_#{Process.pid}_#{rand(1_000_000)}"
+      temp = ::File.join(root, temp_name)
+      FileUtils.mkdir_p(temp)
+      FileUtils.cp_r(::File.join(src, "."), temp)
+      FileUtils.mkdir_p(::File.dirname(target))
+      FileUtils.rm_rf(target)
+      FileUtils.mv(temp, target)
+      regenerate_root_index
+      true
+    end
+
+    # Whether the server process is currently running (PID file + process check). No side effects.
+    # @return [Boolean] true if server is running, false otherwise.
+    def self.running?
+      path = pid_file_path
+      return false unless ::File.file?(path)
+      pid = ::File.read(path).strip.to_i
+      return false if pid <= 0
+      Process.getpgid(pid)
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+
+    # Start background server serving root. Idempotent: if already running, no-op.
+    # @param options [Hash] :port (optional) override default port.
+    # @return [true] if server is running (started or already running).
+    # @raise [RuntimeError] if port in use or server binary (miniserve) not found.
+    def self.start(options = {})
+      return true if running?
+      ensure_root
+      p = options[:port] || port
+      raise "port #{p} is already in use; change port or stop the other process" if port_in_use?(p)
+      bin = server_binary
+      raise "static server binary (miniserve) not found on PATH; install miniserve or set RAKIT_STATIC_SERVER_BINARY" unless bin
+      root_path = ::File.expand_path(root)
+      pid = spawn(bin, root_path, "--port", p.to_s, out: ::File::NULL, err: ::File::NULL)
+      Process.detach(pid)
+      FileUtils.mkdir_p(::File.dirname(pid_file_path))
+      ::File.write(pid_file_path, pid.to_s)
+      true
+    end
+
+    STOP_TIMEOUT = 5
+
+    # Gracefully terminate server process; remove PID file. Fail-fast if not running.
+    # @return [true] if stopped.
+    # @raise [RuntimeError] if server was not running (no PID file or process not found).
+    def self.stop
+      path = pid_file_path
+      raise "server is not running (no PID file at #{path})" unless ::File.file?(path)
+      pid = ::File.read(path).strip.to_i
+      raise "server is not running (invalid PID in #{path})" if pid <= 0
+      begin
+        Process.getpgid(pid)
+      rescue Errno::ESRCH
+        ::File.delete(path)
+        raise "server is not running (process #{pid} not found)"
+      end
+      Process.kill(:TERM, pid)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + STOP_TIMEOUT
+      while Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
+        begin
+          Process.wait(pid, Process::WNOHANG)
+          break
+        rescue Errno::ECHILD
+          break
+        end
+        sleep 0.1
+      end
+      begin
+        Process.getpgid(pid)
+        Process.kill(:KILL, pid)
+        Process.wait(pid)
+      rescue Errno::ESRCH, Errno::ECHILD
+        # already gone
+      end
+      ::File.delete(path) if ::File.file?(path)
+      true
+    end
+
+    # Open a path on the static server in the default browser. Ensures server is running (starts if not), builds URL, launches browser.
+    # @param relative_path [String] URL path (e.g. "/louparslow/rakit/" or "louparslow/rakit"); normalized to one leading slash.
+    # @return [true] on success.
+    # @raise [RuntimeError] if browser cannot be launched (e.g. headless), with message e.g. "Could not launch browser; display required?"
+    def self.view(relative_path)
+      start unless running?
+      path = relative_path.to_s.strip
+      path = "/#{path}" unless path.empty? || path.start_with?("/")
+      path = "/" if path.empty?
+      url = "http://#{host}:#{port}#{path}"
+      launch_browser(url)
+      true
+    end
+
+    # T017: Write root/index.html listing all site subdirectories alphabetically with links.
+    def self.regenerate_root_index
+      entries = Dir.entries(root).sort.select do |e|
+        e != "." && e != ".." && e != "index.html" && !e.start_with?(".") && ::File.directory?(::File.join(root, e))
+      end
+      html = ["<!DOCTYPE html>", "<html><head><meta charset=\"utf-8\"><title>Published sites</title></head><body>", "<h1>Published sites</h1>", "<ul>"]
+      entries.each { |name| html << "<li><a href=\"/#{name}/\">#{name}</a></li>" }
+      html << "</ul></body></html>"
+      ::File.write(::File.join(root, "index.html"), html.join("\n"))
+    end
+
+    class << self
+      private
+
+      def which(cmd)
+        exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+        ENV["PATH"].to_s.split(::File::PATH_SEPARATOR).each do |dir|
+          next if dir.empty?
+          exts.each do |ext|
+            exe = ::File.join(dir, "#{cmd}#{ext}")
+            return exe if ::File.executable?(exe) && !::File.directory?(exe)
+          end
+        end
+        nil
+      end
+
+      def port_in_use?(p)
+        require "socket"
+        TCPServer.new("127.0.0.1", p).close
+        false
+      rescue Errno::EADDRINUSE
+        true
+      end
+
+      def launch_browser(url)
+        cmd = case ::RbConfig::CONFIG["host_os"]
+              when /darwin|mac os/i
+                ["open", url]
+              when /mswin|mingw|windows/i
+                ["cmd", "/c", "start", "", url]
+              else
+                ["xdg-open", url]
+              end
+        system(*cmd, out: ::File::NULL, err: ::File::NULL)
+        return true if $?.success?
+        raise "Could not launch browser; display required?"
+      end
+    end
+  end
+end

data/lib/rakit/word_count.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "json"
+require "set"
+require "generated/rakit.word_count_pb"
+
+module Rakit
+  # Schema-driven token frequency counting over JSON content (keys or values).
+  # CLI: +rakit word-count+ (--json-keys). See specs/004-word-count/contracts/ruby-api.md.
+  module WordCount
+    class << self
+      # @param request [Rakit::Generated::WordCountRequest]
+      # @return [Rakit::Generated::WordCountResult]
+      def count(request)
+        json_str = resolve_json_input(request)
+        return json_str if json_str.is_a?(Rakit::Generated::WordCountResult)
+
+        data = JSON.parse(json_str)
+        config = request.config || Rakit::Generated::WordCountConfig.new
+        keys = extract_keys(data)
+        tokens = keys.flat_map { |k| normalize_and_split(k, config) }
+        counts = filter_count_sort(tokens, config)
+        total = tokens.size
+        unique = counts.size
+
+        Rakit::Generated::WordCountResult.new(
+          success: true,
+          message: "",
+          counts: counts.map { |tok, cnt| Rakit::Generated::TokenCount.new(token: tok, count: cnt) },
+          exit_code: 0,
+          stderr: "",
+          total_tokens: total,
+          unique_tokens: unique
+        )
+      rescue JSON::ParserError => e
+        Rakit::Generated::WordCountResult.new(
+          success: false,
+          message: e.message,
+          exit_code: 1,
+          stderr: e.message
+        )
+      rescue Errno::ENOENT, Errno::EACCES => e
+        Rakit::Generated::WordCountResult.new(
+          success: false,
+          message: e.message,
+          exit_code: 1,
+          stderr: e.message
+        )
+      end
+
+      # T004: Recursive key extraction from JSON structure. Returns array of key strings (duplicates preserved).
+      def extract_keys(obj)
+        case obj
+        when Hash
+          obj.keys.map(&:to_s) + obj.values.flat_map { |v| extract_keys(v) }
+        when Array
+          obj.flat_map { |v| extract_keys(v) }
+        else
+          []
+        end
+      end
+
+      # T005: Normalize and split one key into tokens. Pipeline: case -> snake/kebab -> camelCase.
+      def normalize_and_split(token_string, config)
+        return [] if token_string.nil? || !token_string.is_a?(String)
+
+        s = token_string.dup
+        s = s.downcase if config.case_insensitive
+        parts = [s]
+        parts = parts.flat_map { |p| p.split(/_|-/) } if config.split_snake_kebab
+        parts = parts.flat_map { |p| p.split(/(?=[A-Z])/).reject(&:empty?) } if config.split_camel_case
+        parts.map(&:downcase).reject(&:empty?)
+      end
+
+      # T006: Filter (min_length, stopwords), count, sort (count desc, token asc), top_n.
+      def filter_count_sort(tokens, config)
+        min_len = config.min_token_length || 0
+        stopwords = config.stopwords || []
+        normalized_stop = config.case_insensitive ? stopwords.map(&:downcase).to_set : stopwords.to_set
+
+        filtered = tokens.select do |t|
+          compare_t = config.case_insensitive ? t.downcase : t
+          t.length >= min_len && !normalized_stop.include?(compare_t)
+        end
+        freq = filtered.tally
+        sorted = freq.sort_by { |token, count| [-count, token] }
+        top_n = config.top_n || 0
+        top_n.positive? ? sorted.take(top_n) : sorted
+      end
+
+      private
+
+      def resolve_json_input(request)
+        json = request.json
+        return error_result("No JSON source", 1) unless json
+
+        if json.json_file && !json.json_file.empty?
+          path = json.json_file
+          return error_result("File not found: #{path}", 1) unless ::File.file?(path)
+          return error_result("File not readable: #{path}", 1) unless ::File.readable?(path)
+          return ::File.read(path)
+        end
+
+        if json.inline_json && !json.inline_json.empty?
+          return json.inline_json
+        end
+
+        # stdin: caller must set inline_json with the read content (per contracts/ruby-api.md)
+        error_result("No JSON source (set json_file or inline_json)", 1)
+      end
+
+      def error_result(message, exit_code)
+        Rakit::Generated::WordCountResult.new(
+          success: false,
+          message: message,
+          exit_code: exit_code,
+          stderr: message
+        )
+      end
+    end
+  end
+end

data/lib/rakit.rb

@@ -22,9 +22,12 @@ require_relative "rakit/gem"
 require_relative "rakit/git"
 require_relative "rakit/task"
 require_relative "rakit/protobuf"
-# Defer loading so rake tasks that don't need Shell/Data (e.g. clobber) work without google-protobuf.
+# Defer loading so rake tasks that don't need Shell (e.g. clobber) work without google-protobuf.
 autoload :Shell, "rakit/shell"
-autoload :Data, "rakit/data"
+require_relative "rakit/static_web_server"
+require_relative "rakit/hugo"
+require_relative "rakit/word_count"
+require_relative "rakit/file"
 require_relative "rakit/azure/dev_ops"
 
 def run(cmd)

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: rakit
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - rakit
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -41,16 +41,22 @@ dependencies:
   name: google-protobuf
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.25'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.25'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
@@ -93,22 +99,32 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
-executables: []
+executables:
+- rakit
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/generated/azure.devops_pb.rb
+- exe/rakit
 - lib/generated/data_pb.rb
-- lib/generated/example_pb.rb
-- lib/generated/shell_pb.rb
+- lib/generated/rakit.azure_pb.rb
+- lib/generated/rakit.example_pb.rb
+- lib/generated/rakit.file_pb.rb
+- lib/generated/rakit.shell_pb.rb
+- lib/generated/rakit.static_web_server_pb.rb
+- lib/generated/rakit.word_count_pb.rb
 - lib/rakit.rb
 - lib/rakit/azure/dev_ops.rb
-- lib/rakit/data.rb
+- lib/rakit/cli/file.rb
+- lib/rakit/cli/word_count.rb
+- lib/rakit/file.rb
 - lib/rakit/gem.rb
 - lib/rakit/git.rb
+- lib/rakit/hugo.rb
 - lib/rakit/protobuf.rb
 - lib/rakit/shell.rb
+- lib/rakit/static_web_server.rb
 - lib/rakit/task.rb
+- lib/rakit/word_count.rb
 homepage: https://gitlab.com/gems/rakit
 licenses:
 - MIT

data/lib/generated/azure.devops_pb.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: azure.devops.proto
-
-require "google/protobuf"
-
-descriptor_data = "\n\x12\x61zure.devops.proto\x12\x0brakit.azure\"L\n\x08Pipeline\x12\x0b\n\x03org\x18\x01 \x01(\t\x12\x0f\n\x07project\x18\x02 \x01(\t\x12\x13\n\x0bpipeline_id\x18\x03 \x01(\x05\x12\r\n\x05token\x18\x04 \x01(\t\"R\n\x18GetPipelineResultRequest\x12\'\n\x08pipeline\x18\x01 \x01(\x0b\x32\x15.rakit.azure.Pipeline\x12\r\n\x05token\x18\x02 \x01(\t\"C\n\x0ePipelineStatus\x12\x0f\n\x07success\x18\x01 \x01(\x08\x12\x0e\n\x06\x65rrors\x18\x02 \x03(\t\x12\x10\n\x08warnings\x18\x03 \x03(\t\"8\n\x0ePipelineResult\x12&\n\x04runs\x18\x01 \x03(\x0b\x32\x18.rakit.azure.PipelineRun\"\x97\x01\n\x0bPipelineRun\x12\n\n\x02id\x18\x01 \x01(\x05\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\r\n\x05state\x18\x03 \x01(\t\x12\x0e\n\x06result\x18\x04 \x01(\t\x12\x14\n\x0c\x63reated_date\x18\x05 \x01(\t\x12\x15\n\rfinished_date\x18\x06 \x01(\t\x12\"\n\x06stages\x18\x07 \x03(\x0b\x32\x12.rakit.azure.Stage\"&\n\x05Issue\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x0f\n\x07message\x18\x02 \x01(\t\"G\n\x03Job\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06result\x18\x02 \x01(\t\x12\"\n\x06issues\x18\x03 \x03(\x0b\x32\x12.rakit.azure.Issue\"i\n\x05Stage\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06result\x18\x02 \x01(\t\x12\x1e\n\x04jobs\x18\x03 \x03(\x0b\x32\x10.rakit.azure.Job\x12\"\n\x06issues\x18\x04 \x03(\x0b\x32\x12.rakit.azure.Issue\"`\n\x0eTimelineRecord\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x02 \x01(\t\x12\x0e\n\x06result\x18\x03 \x01(\t\x12\"\n\x06issues\x18\x04 \x03(\x0b\x32\x12.rakit.azure.Issue\"\xa8\x01\n\x14PipelineResultDetail\x12\x12\n\nsuccessful\x18\x01 \x01(\x08\x12\x0e\n\x06\x65rrors\x18\x02 \x01(\t\x12\x10\n\x08warnings\x18\x03 \x01(\t\x12%\n\x03run\x18\x04 \x01(\x0b\x32\x18.rakit.azure.PipelineRun\x12\x33\n\x0e\x66\x61iled_records\x18\x05 \x03(\x0b\x32\x1b.rakit.azure.TimelineRecord2i\n\x0ePipelineServer\x12W\n\x11GetPipelineResult\x12%.rakit.azure.GetPipelineResultRequest\x1a\x1b.rakit.azure.PipelineResultB\x0f\xea\x02\x0cRakit::Azureb\x06proto3"
-
-pool = ::Google::Protobuf::DescriptorPool.generated_pool
-pool.add_serialized_file(descriptor_data)
-
-module Rakit
-  module Azure
-    Pipeline = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.azure.Pipeline").msgclass
-    GetPipelineResultRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.azure.GetPipelineResultRequest").msgclass
-    PipelineStatus = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.azure.PipelineStatus").msgclass
-    PipelineResult = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.azure.PipelineResult").msgclass
-    PipelineRun = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.azure.PipelineRun").msgclass
-    Issue = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.azure.Issue").msgclass
-    Job = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.azure.Job").msgclass
-    Stage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.azure.Stage").msgclass
-    TimelineRecord = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.azure.TimelineRecord").msgclass
-    PipelineResultDetail = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.azure.PipelineResultDetail").msgclass
-  end
-end

data/lib/generated/shell_pb.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: shell.proto
-
-require 'google/protobuf'
-
-
-descriptor_data = "\n\x0bshell.proto\x12\x0brakit.shell\"\x9a\x02\n\x07\x43ommand\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04\x61rgs\x18\x02 \x03(\t\x12\x19\n\x11working_directory\x18\x03 \x01(\t\x12\x17\n\x0ftimeout_seconds\x18\x04 \x01(\x05\x12\x1a\n\x12\x65xpected_exit_code\x18\x05 \x01(\x05\x12\x17\n\x0f\x65xpected_stdout\x18\x06 \x01(\t\x12\x17\n\x0f\x65xpected_stderr\x18\x07 \x01(\t\x12<\n\x13\x61\x63\x63\x65ptance_criteria\x18\x08 \x03(\x0b\x32\x1f.rakit.shell.AcceptanceCriteria\x12\x13\n\x0b\x65xit_status\x18\t \x01(\x05\x12\x0e\n\x06stdout\x18\n \x01(\t\x12\x0e\n\x06stderr\x18\x0b \x01(\t\"1\n\x12\x41\x63\x63\x65ptanceCriteria\x12\x0c\n\x04kind\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t\"-\n\nTestResult\x12\x0f\n\x07success\x18\x01 \x01(\x08\x12\x0e\n\x06\x65rrors\x18\x02 \x03(\t\"b\n\rFormatRequest\x12%\n\x07\x63ommand\x18\x01 \x01(\x0b\x32\x14.rakit.shell.Command\x12*\n\x06\x66ormat\x18\x02 \x01(\x0e\x32\x1a.rakit.shell.CommandFormat\" \n\x0e\x46ormatResponse\x12\x0e\n\x06output\x18\x01 \x01(\t*Z\n\rCommandFormat\x12\x1e\n\x1a\x43OMMAND_FORMAT_UNSPECIFIED\x10\x00\x12\x0c\n\x08ONE_LINE\x10\x01\x12\x0e\n\nMULTI_LINE\x10\x02\x12\x0b\n\x07\x43OMPACT\x10\x03\x32\xc1\x01\n\x0e\x43ommandService\x12\x35\n\x07\x45xecute\x12\x14.rakit.shell.Command\x1a\x14.rakit.shell.Command\x12\x35\n\x04Test\x12\x14.rakit.shell.Command\x1a\x17.rakit.shell.TestResult\x12\x41\n\x06\x46ormat\x12\x1a.rakit.shell.FormatRequest\x1a\x1b.rakit.shell.FormatResponseB\x0f\xea\x02\x0cRakit::Shellb\x06proto3"
-
-pool = ::Google::Protobuf::DescriptorPool.generated_pool
-pool.add_serialized_file(descriptor_data)
-
-module Rakit
-  module Shell
-    Command = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.shell.Command").msgclass
-    AcceptanceCriteria = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.shell.AcceptanceCriteria").msgclass
-    TestResult = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.shell.TestResult").msgclass
-    FormatRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.shell.FormatRequest").msgclass
-    FormatResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.shell.FormatResponse").msgclass
-    CommandFormat = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("rakit.shell.CommandFormat").enummodule
-  end
-end

data/lib/rakit/data.rb

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-require "generated/data_pb"
-
-module Rakit
-  module Data
-    # Export all stored messages from DataService.data_dir to export_dir in the given format.
-    # If there are no .pb files under data_dir, no files are created.
-    #
-    # @param export_dir [String] target directory (created if needed)
-    # @param export_format [Rakit::Data::ExportFormat] PROTOBUF_BINARY_FILES (mirror .pb layout),
-    #   PROTOBUF_JSON_FILES (same layout with .json), or PROTOBUF_BINARY_ZIPPED (single data.zip)
-    # @return [void]
-    # @raise [ArgumentError] if export_format is not a supported ExportFormat value
-    def self.export(export_dir, export_format)
-      base = DataService.data_dir
-      export_dir = File.expand_path(export_dir)
-      FileUtils.mkdir_p(export_dir)
-
-      pb_paths = Dir.glob(File.join(base, "**", "*.pb"))
-      return if pb_paths.empty?
-
-      case export_format
-      when ExportFormat::PROTOBUF_BINARY_FILES
-        _export_binary_files(pb_paths, base, export_dir)
-      when ExportFormat::PROTOBUF_JSON_FILES
-        _export_json_files(pb_paths, base, export_dir)
-      when ExportFormat::PROTOBUF_BINARY_ZIPPED
-        _export_binary_zipped(pb_paths, base, export_dir)
-      else
-        raise ArgumentError, "unsupported export_format: #{export_format.inspect}"
-      end
-    end
-
-    def self._rel_parts(base, path)
-      rel = path[(base.end_with?(File::SEPARATOR) ? base.length : base.length + 1)..]
-      parts = rel.split(File::SEPARATOR)
-      type_name = parts[0..-2].join("::")
-      unique_name = File.basename(parts[-1], ".pb")
-      [type_name, unique_name, rel]
-    end
-
-    def self._export_binary_files(pb_paths, base, export_dir)
-      pb_paths.each do |path|
-        type_name, _unique_name, rel = _rel_parts(base, path)
-        message = DataService.load(type_name, File.basename(path, ".pb"))
-        out_path = File.join(export_dir, rel)
-        FileUtils.mkdir_p(File.dirname(out_path))
-        File.binwrite(out_path, message.class.encode(message))
-      end
-    end
-
-    def self._export_json_files(pb_paths, base, export_dir)
-      pb_paths.each do |path|
-        type_name, unique_name, rel = _rel_parts(base, path)
-        message = DataService.load(type_name, unique_name)
-        out_rel = rel.sub(/\.pb\z/, ".json")
-        out_path = File.join(export_dir, out_rel)
-        FileUtils.mkdir_p(File.dirname(out_path))
-        File.write(out_path, message.class.encode_json(message))
-      end
-    end
-
-    def self._export_binary_zipped(pb_paths, base, export_dir)
-      require "zip"
-      zip_path = File.join(export_dir, "data.zip")
-      FileUtils.rm_f(zip_path)
-      Zip::File.open(zip_path, Zip::File::CREATE) do |zip|
-        pb_paths.each do |path|
-          type_name, unique_name, rel = _rel_parts(base, path)
-          message = DataService.load(type_name, unique_name)
-          zip.get_output_stream(rel) { |io| io.write(message.class.encode(message)) }
-        end
-      end
-    end
-
-    # Persist and retrieve protobuf message instances under a configurable data root.
-    #
-    # Storage layout: root is {data_dir} (default +~/.rakit/data+). Path for a message is
-    # +data_dir/TYPE_PATH/unique_name.pb+. TYPE_PATH is the Ruby class name with +::+ replaced by
-    # +File::SEPARATOR+ (e.g. +Rakit::Shell::Command+ → +Rakit/Shell/Command+). File content is
-    # binary protobuf; no character encoding.
-    module DataService
-      # @return [String] current data root (default: expanded +~/.rakit/data+)
-      def self.data_dir
-        @data_dir ||= File.expand_path("~/.rakit/data")
-      end
-
-      # @param path [String] set the data root for subsequent operations (e.g. tests use a temp dir)
-      # @return [void]
-      def self.data_dir=(path)
-        @data_dir = path
-      end
-
-      # Store a proto message under a unique name.
-      # @param message [Object] instance of a generated protobuf message class
-      # @param unique_name [String] non-empty, must not contain path separators or +..+
-      # @return [void]
-      # @raise [ArgumentError] if unique_name is empty/blank or contains path traversal
-      # @raise [Errno::EACCES] etc. on permission failure
-      def self.store(message, unique_name)
-        _validate_unique_name!(unique_name)
-        klass = message.class
-        path = _path(klass.name, unique_name)
-        FileUtils.mkdir_p(File.dirname(path))
-        File.binwrite(path, klass.encode(message))
-      end
-
-      # Load a stored message.
-      # @param type_name [String] Ruby class name (e.g. +"Rakit::Shell::Command"+)
-      # @param unique_name [String] same rules as for store
-      # @return [Object] decoded message instance
-      # @raise [ArgumentError] if unique_name invalid
-      # @raise [NameError] if type_name is not a valid constant
-      # @raise [Errno::ENOENT] if the file does not exist
-      def self.load(type_name, unique_name)
-        _validate_unique_name!(unique_name)
-        klass = Object.const_get(type_name.to_s)
-        path = _path(klass.name, unique_name.to_s)
-        raise Errno::ENOENT, path unless File.file?(path)
-
-        klass.decode(File.binread(path))
-      end
-
-      # Remove a stored message by type and unique name (no-op if file absent).
-      # @param type_name [String] Ruby class name
-      # @param unique_name [String] same rules as for store
-      # @return [void]
-      # @raise [ArgumentError] if unique_name invalid
-      def self.remove(type_name, unique_name)
-        _validate_unique_name!(unique_name)
-        path = _path(type_name.to_s, unique_name.to_s)
-        File.delete(path) if File.file?(path)
-      end
-
-      # Return unique names (without +.pb+) for the given type.
-      # @param type_name [String] Ruby class name for directory resolution
-      # @return [Array<String>] empty if directory missing or no .pb files
-      # @raise [NameError] if type_name is not a valid constant
-      # @raise [ArgumentError] if type_name yields empty path segments (e.g. from _dir_for_type)
-      def self.get_names(type_name)
-        dir = _dir_for_type(type_name.to_s)
-        return [] unless File.directory?(dir)
-
-        Dir.children(dir).select { |f| File.file?(File.join(dir, f)) && f.end_with?(".pb") }.map { |f| f.chomp(".pb") }
-      end
-
-      def self._validate_unique_name!(unique_name)
-        u = unique_name.to_s
-        raise ArgumentError, "unique_name must be a non-empty string" if u.strip.empty?
-        if u.include?("/") || u.include?("\\") || u.include?("..")
-          raise ArgumentError, "unique_name must not contain path separators or '..'"
-        end
-      end
-
-      def self._path(type_name, unique_name)
-        dir = _dir_for_type(type_name)
-        File.join(dir, "#{unique_name}.pb")
-      end
-
-      # PACKAGE_PATH/MESSAGE_NAME: e.g. Rakit::Shell::Command -> Rakit/Shell/Command
-      def self._dir_for_type(type_name)
-        parts = type_name.split("::")
-        raise ArgumentError, "type_name must be a qualified constant path" if parts.empty?
-
-        relative = parts.join(File::SEPARATOR)
-        File.join(data_dir, relative)
-      end
-    end
-  end
-end