pray-cli 1.6.0

data/lib/pray/config.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "toml-rb"
+
+module Pray
+  module Config
+    PrayConfig = Struct.new(:local) do
+      def initialize(local: PrayLocalConfig.new)
+        super
+      end
+    end
+
+    PrayLocalConfig = Struct.new(:package, :source) do
+      def initialize(package: {}, source: {})
+        super
+      end
+    end
+
+    module_function
+
+    def load_user_config
+      path = user_config_path
+      return PrayConfig.new unless path && File.file?(path)
+
+      data = TomlRB.load_file(path)
+      PrayConfig.new(
+        local: PrayLocalConfig.new(
+          package: data.dig("local", "package") || {},
+          source: data.dig("local", "source") || {}
+        )
+      )
+    rescue TomlRB::ParseError => error
+      raise Error.parse("config", "#{path}: #{error.message}")
+    end
+
+    def user_config_path
+      if (path = ENV["PRAY_CONFIG"])
+        return path
+      end
+
+      if (home = ENV["PRAY_HOME"])
+        candidate = File.join(home, "config.toml")
+        return candidate if File.file?(candidate)
+      end
+
+      home = ENV["HOME"]
+      return nil unless home
+
+      File.join(home, ".config", "pray", "config.toml")
+    end
+  end
+end

data/lib/pray/constraint.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Pray
+  module Constraint
+    module_function
+
+    def normalize_version_constraint(constraint)
+      trimmed = constraint.strip
+      return trimmed if trimmed.empty? || trimmed == "*"
+      return trimmed if operator_prefixed?(trimmed)
+
+      if bare_semver?(trimmed)
+        "=#{trimmed}"
+      else
+        trimmed
+      end
+    end
+
+    def version_satisfies(version, constraint)
+      normalized = normalize_version_constraint(constraint)
+      return true if normalized.empty? || normalized == "*"
+
+      requirement = Gem::Requirement.new(normalized.strip)
+      requirement.satisfied_by?(Gem::Version.new(version))
+    rescue ArgumentError => error
+      raise Error.resolution(error.message)
+    end
+
+    def pessimistic_constraint_for_version(version)
+      parsed = Gem::Version.new(version)
+      if parsed.segments[1].to_i.zero? && parsed.segments[2].to_i.zero?
+        "~> #{parsed.segments[0]}.0"
+      else
+        "~> #{parsed.segments[0]}.#{parsed.segments[1]}"
+      end
+    end
+
+    def latest_constraint_for_package(current_constraint, latest_version)
+      normalized = normalize_version_constraint(current_constraint)
+      return "*" if normalized == "*"
+      return pessimistic_constraint_for_version(latest_version) if normalized.start_with?("~")
+
+      if normalized.start_with?("^")
+        parsed = Gem::Version.new(latest_version)
+        return "^#{parsed.segments[0]}.#{parsed.segments[1]}"
+      end
+
+      if normalized.start_with?("=") || bare_semver?(current_constraint.strip)
+        return "=#{latest_version}"
+      end
+
+      pessimistic_constraint_for_version(latest_version)
+    end
+
+    def ruby_pessimistic_to_semver(constraint)
+      text = constraint.strip.sub(/\A~>\s*/, "")
+      parts = text.split(".")
+      raise Error.resolution("unsupported Ruby pessimistic constraint: #{constraint}") if parts.empty? || parts.length > 3
+
+      numbers = [parts[0].to_i, (parts[1] || 0).to_i, (parts[2] || 0).to_i]
+      lower = numbers.join(".")
+      upper = case parts.length
+      when 1 then "#{numbers[0] + 1}.0.0"
+      when 2 then "#{numbers[0]}.#{numbers[1] + 1}.0"
+      else "#{numbers[0]}.#{numbers[1] + 1}.0"
+      end
+      ">= #{lower}, < #{upper}"
+    end
+
+    def operator_prefixed?(text)
+      text.start_with?("~>", "~", "^", "=", ">", "<") || text.include?("*")
+    end
+
+    def bare_semver?(text)
+      Gem::Version.correct?(text)
+    rescue
+      false
+    end
+  end
+end

data/lib/pray/destination.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Pray
+  DestinationEntry = Struct.new(:kind, :name, :path) do
+    def self.package(name)
+      new(kind: "package", name: name, path: nil)
+    end
+
+    def self.local(path)
+      new(kind: "local", name: nil, path: path)
+    end
+  end
+
+  module Destination
+    module_function
+
+    def local_path_form?(value)
+      value.start_with?(".", "/") ||
+        value.end_with?(".md", ".txt", ".markdown") ||
+        !value.include?("/")
+    end
+
+    def destination_target_name(mode, path)
+      prefix = case mode
+      when "compose" then "compose"
+      when "tree" then "tree"
+      else "legacy"
+      end
+      "#{prefix}:#{path}"
+    end
+
+    def new_destination_target(mode, path)
+      target = ManifestTarget.new(
+        name: destination_target_name(mode, path),
+        mode: mode,
+        scoped: true
+      )
+      case mode
+      when "compose" then target.outputs << path
+      when "tree" then target.skills << path
+      end
+      target
+    end
+
+    def upsert_package(manifest, package)
+      existing = manifest.packages.find { |candidate| candidate.name == package.name }
+      unless existing
+        manifest.packages << package
+        return
+      end
+
+      if existing.constraint != package.constraint &&
+          existing.constraint != "*" &&
+          package.constraint != "*"
+        raise Error.manifest(
+          "package #{package.name} declared with conflicting constraints " \
+          "(#{existing.constraint} vs #{package.constraint})"
+        )
+      end
+      existing.constraint = package.constraint if existing.constraint == "*" && package.constraint != "*"
+
+      if existing.source.nil?
+        existing.source = package.source
+      elsif package.source && existing.source != package.source
+        raise Error.manifest("package #{package.name} declared with conflicting sources")
+      end
+
+      package.exports.each do |export|
+        existing.exports << export unless existing.exports.include?(export)
+      end
+      package.roles.each do |role|
+        existing.roles << role unless existing.roles.include?(role)
+      end
+
+      if package.file
+        if existing.file && existing.file != package.file
+          raise Error.manifest(
+            "package #{package.name} declared with conflicting file: destinations"
+          )
+        end
+        existing.file = package.file
+      end
+
+      existing.bound = existing.bound || package.bound
+      existing.optional = existing.optional || package.optional
+      existing.path ||= package.path
+      existing.git ||= package.git
+      existing.tag ||= package.tag
+      existing.rev ||= package.rev
+      existing.tarball ||= package.tarball
+      existing.oci ||= package.oci
+      package.groups.each do |group|
+        existing.groups << group unless existing.groups.include?(group)
+      end
+    end
+
+    def upsert_local(manifest, local)
+      existing = manifest.local.find { |candidate| candidate.path == local.path }
+      unless existing
+        manifest.local << local
+        return
+      end
+
+      existing.bound = existing.bound || local.bound
+      existing.optional = existing.optional || local.optional
+      if existing.position == "after" && local.position != "after"
+        existing.position = local.position
+      end
+    end
+
+    def bind_package_entry(target, package_name)
+      entry = DestinationEntry.package(package_name)
+      return if target.entries.any? { |candidate| candidate.kind == "package" && candidate.name == package_name }
+
+      target.entries << entry
+    end
+
+    def bind_local_entry(target, path)
+      return if target.entries.any? { |candidate| candidate.kind == "local" && candidate.path == path }
+
+      target.entries << DestinationEntry.local(path)
+    end
+
+    def role_for_destination(mode)
+      case mode
+      when "compose" then "fragment"
+      when "tree" then "folder"
+      end
+    end
+
+    def package_bound_to_compose?(package, target)
+      if target.scoped && target.mode == "compose"
+        return target.entries.any? { |entry| entry.kind == "package" && entry.name == package.name }
+      end
+      return false if package.bound || package.file
+
+      true
+    end
+
+    def package_bound_to_tree?(package, target)
+      if target.scoped && target.mode == "tree"
+        return target.entries.any? { |entry| entry.kind == "package" && entry.name == package.name }
+      end
+      return false if package.bound || package.file
+
+      true
+    end
+
+    def export_kind_matches_role?(kind, role)
+      case role
+      when "fragment" then kind == "fragment"
+      when "folder" then %w[folder skill].include?(kind)
+      when "file" then kind == "file"
+      else false
+      end
+    end
+  end
+end

data/lib/pray/dotenv.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pray
+  module Dotenv
+    module_function
+
+    def load_dotenv_variables(project_root_hint)
+      path = File.join(project_root_hint, ".env")
+      return {} unless File.file?(path)
+
+      text = File.read(path)
+      parse_dotenv_text(text)
+    rescue
+      {}
+    end
+
+    def parse_dotenv_text(text)
+      variables = {}
+      text.each_line do |line|
+        trimmed = line.strip
+        next if trimmed.empty? || trimmed.start_with?("#")
+
+        assignment = trimmed.delete_prefix("export ").strip
+        key, value = assignment.split("=", 2)
+        next unless value
+
+        key = key.strip
+        next if key.empty?
+        next unless key.start_with?("PRAY_")
+
+        variables[key] = parse_dotenv_value(value.strip)
+      end
+      variables
+    end
+
+    def parse_dotenv_value(value)
+      if value.length >= 2
+        quote = value[0]
+        if (quote == '"' || quote == "'") && value[-1] == quote
+          return value[1...-1]
+        end
+      end
+      value
+    end
+  end
+end

data/lib/pray/environment.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pray
+  module Environment
+    module_function
+
+    def package_matches_environment?(groups, environment)
+      return true if groups.empty?
+
+      return false if environment.nil?
+
+      groups.any? { |group| group == environment }
+    end
+
+    def collect_group_names(manifest)
+      manifest.packages.flat_map(&:groups).uniq.sort
+    end
+
+    def validate_environment(manifest, environment)
+      return if environment.nil?
+
+      if environment.empty?
+        raise Error.resolution("environment name cannot be empty")
+      end
+
+      known_groups = collect_group_names(manifest)
+      if known_groups.empty?
+        raise Error.resolution("unknown environment #{environment}; Prayfile defines no groups")
+      end
+      return if known_groups.include?(environment)
+
+      raise Error.resolution(
+        "unknown environment #{environment}; available groups are #{known_groups.join(", ")}"
+      )
+    end
+
+    def should_render_package?(declaration, environment)
+      package_matches_environment?(declaration.groups, environment)
+    end
+  end
+end

data/lib/pray/error.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pray
+  class Error < StandardError
+    def initialize(category, message, parse_kind: nil)
+      @category = category
+      @parse_kind = parse_kind
+      super(message)
+    end
+
+    attr_reader :category
+
+    def exit_code
+      case category
+      when :parse, :usage then 2
+      when :manifest, :io then 1
+      when :resolution then 3
+      when :integrity then 4
+      when :render then 5
+      when :verify then 6
+      when :unsupported then 8
+      else 1
+      end
+    end
+
+    def to_s
+      prefix = case category
+      when :parse then "#{@parse_kind} parse error"
+      when :usage then "usage error"
+      when :manifest then "manifest error"
+      when :resolution then "resolution error"
+      when :integrity then "integrity error"
+      when :render then "render error"
+      when :verify then "verify error"
+      when :unsupported then "unsupported feature"
+      when :io then "I/O error"
+      else category.to_s
+      end
+      "#{prefix}: #{super}"
+    end
+
+    def self.parse(kind, message)
+      new(:parse, message, parse_kind: kind)
+    end
+
+    def self.manifest(message) = new(:manifest, message)
+    def self.resolution(message) = new(:resolution, message)
+    def self.integrity(message) = new(:integrity, message)
+    def self.render(message) = new(:render, message)
+    def self.verify(message) = new(:verify, message)
+    def self.unsupported(message) = new(:unsupported, message)
+    def self.usage(message) = new(:usage, message)
+    def self.io(error) = new(:io, error.message)
+  end
+end

data/lib/pray/format_manifest.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module Pray
+  PackageFormatHint = Struct.new(:roles, :file_path, :exports) do
+    def initialize(roles: [], file_path: nil, exports: [])
+      super
+    end
+  end
+
+  module FormatManifest
+    module_function
+
+    def uses_destination_dsl?(manifest)
+      manifest.targets.any? { |target| target.scoped || target.mode != "legacy" } ||
+        manifest.packages.any? { |package| package.bound || package.file } ||
+        manifest.local.any?(&:bound)
+    end
+
+    def classify_format_hints(project)
+      hints = {}
+      project.packages.each do |package|
+        roles = []
+        file_path = package.declaration.file
+        package.selected_exports.each do |export_name|
+          export = package.spec.exports[export_name]
+          next unless export
+
+          %w[fragment folder file].each do |role|
+            if Destination.export_kind_matches_role?(export.kind, role) && !roles.include?(role)
+              roles << role
+            end
+          end
+          if file_path.nil? && export.kind == "file"
+            file_path = export.default_path || export_name
+          end
+        end
+        hints[package.declaration.name] = PackageFormatHint.new(
+          roles: roles,
+          file_path: file_path,
+          exports: ambiguous_exports_for_roles(package.selected_exports, package.spec.exports, roles)
+        )
+      end
+      hints
+    end
+
+    def recommend_manifest(manifest, hints)
+      recommended = if has_migratable_legacy_targets?(manifest)
+        migrate_legacy_manifest(manifest, hints)
+      else
+        deep_clone_manifest(manifest)
+      end
+      omit_context_resolved_exports(recommended)
+      omit_default_sources(recommended)
+      recommended
+    end
+
+    def format_recommended(manifest, hints)
+      recommended = recommend_manifest(manifest, hints)
+      text = FormatSerialize.serialize_recommended(recommended)
+      reparsed = Pray.parse_manifest(text)
+      if reparsed.manifest_hash != recommended.manifest_hash
+        raise Error.manifest("formatted Prayfile did not round-trip to an equivalent manifest")
+      end
+
+      text
+    end
+
+    def has_migratable_legacy_targets?(manifest)
+      manifest.targets.any? do |target|
+        !target.scoped && target.mode == "legacy" &&
+          (!target.outputs.empty? || !target.skills.empty?)
+      end
+    end
+
+    def migrate_legacy_manifest(manifest, hints)
+      next_manifest = Manifest.new(
+        prayfile_version: manifest.prayfile_version,
+        sources: manifest.sources.map { |source| source.dup },
+        targets: [],
+        packages: manifest.packages.map { |package| clone_package(package) },
+        local: manifest.local.map { |local| local.dup },
+        symbols: manifest.symbols.dup,
+        render: manifest.render.dup
+      )
+
+      apply_format_hints(next_manifest.packages, hints)
+
+      compose_paths = unique_paths(
+        manifest.targets.flat_map { |target| target.outputs.map { |path| [path, target.name] } }
+      )
+      tree_paths = unique_paths(
+        manifest.targets.flat_map { |target| target.skills.map { |path| [path, target.name] } }
+      )
+
+      compose_paths.each do |path, target_names|
+        target = Destination.new_destination_target("compose", path)
+        locals_for_compose(next_manifest.local).each do |local|
+          Destination.bind_local_entry(target, local.path)
+          entry = next_manifest.local.find { |candidate| candidate.path == local.path }
+          entry.bound = true if entry
+        end
+        packages_for_role(next_manifest.packages, "fragment", target_names).each do |package|
+          Destination.bind_package_entry(target, package.name)
+          mark_package_bound(next_manifest.packages, package.name, "fragment")
+        end
+        next_manifest.targets << target
+      end
+
+      tree_paths.each do |path, target_names|
+        target = Destination.new_destination_target("tree", path)
+        packages_for_role(next_manifest.packages, "folder", target_names).each do |package|
+          Destination.bind_package_entry(target, package.name)
+          mark_package_bound(next_manifest.packages, package.name, "folder")
+        end
+        next_manifest.targets << target
+      end
+
+      next_manifest.packages.each do |package|
+        next unless package.file
+
+        package.bound = true
+        package.roles << "file" unless package.roles.include?("file")
+      end
+      next_manifest.local.each do |local|
+        local.position = "after" if local.bound
+      end
+
+      manifest.targets.each do |target|
+        next unless FormatSerialize.target_has_extras?(target)
+
+        next_manifest.targets << ManifestTarget.new(
+          name: target.name,
+          commands: target.commands.dup,
+          rules: target.rules.dup,
+          max_bytes: target.max_bytes,
+          mode: "legacy",
+          scoped: false
+        )
+      end
+
+      next_manifest
+    end
+
+    def apply_format_hints(packages, hints)
+      packages.each do |package|
+        hint = hints[package.name]
+        if hint
+          hint.roles.each do |role|
+            package.roles << role unless package.roles.include?(role)
+          end
+          package.file ||= hint.file_path
+          if package.exports.empty? && !hint.exports.empty?
+            package.exports = hint.exports.dup
+          end
+        end
+        if package.file && !package.roles.include?("file")
+          package.roles << "file"
+        end
+      end
+    end
+
+    def omit_context_resolved_exports(manifest)
+      manifest.packages.each do |package|
+        package.exports.clear if package.bound && package.exports.length <= 1
+      end
+    end
+
+    def omit_default_sources(manifest)
+      sole_source = (manifest.sources.length == 1) ? manifest.sources.first.name : nil
+      source_names = manifest.sources.map(&:name).to_set
+      manifest.packages.each do |package|
+        source = package.source
+        next unless source
+
+        matches_sole = sole_source == source
+        namespace = package.name.split("/", 2).first
+        matches_namespace = namespace == source && source_names.include?(source)
+        package.source = nil if matches_sole || matches_namespace
+      end
+    end
+
+    def unique_paths(items)
+      map = {}
+      items.each do |path, target_name|
+        map[path] ||= Set.new
+        map[path] << target_name
+      end
+      map.sort.map { |path, names| [path, names] }
+    end
+
+    def locals_for_compose(locals)
+      before = []
+      after = []
+      locals.each do |local|
+        next if local.bound
+
+        if %w[start before].include?(local.position)
+          before << local
+        else
+          after << local
+        end
+      end
+      before + after
+    end
+
+    def packages_for_role(packages, role, target_names)
+      packages.select do |package|
+        next false if package.file
+        if !package.targets.empty? && package.targets.none? { |name| target_names.include?(name) }
+          next false
+        end
+
+        package.roles.include?(role)
+      end
+    end
+
+    def mark_package_bound(packages, name, role)
+      package = packages.find { |entry| entry.name == name }
+      return unless package
+
+      package.bound = true
+      package.roles << role unless package.roles.include?(role)
+    end
+
+    def ambiguous_exports_for_roles(selected_exports, exports, roles)
+      ambiguous = []
+      roles.each do |role|
+        matching = selected_exports.select do |export_name|
+          export = exports[export_name]
+          export && Destination.export_kind_matches_role?(export.kind, role)
+        end
+        next unless matching.length > 1
+
+        matching.each do |export_name|
+          ambiguous << export_name unless ambiguous.include?(export_name)
+        end
+      end
+      ambiguous
+    end
+
+    def deep_clone_manifest(manifest)
+      Marshal.load(Marshal.dump(manifest))
+    end
+
+    def clone_package(package)
+      package.dup.tap do |copy|
+        copy.exports = package.exports.dup
+        copy.targets = package.targets.dup
+        copy.features = package.features.dup
+        copy.groups = package.groups.dup
+        copy.roles = package.roles.dup
+      end
+    end
+  end
+end