pray-cli 1.16.0 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5950b63f50e919bd5864874919afde95413ed095954046604d570d4c3daf090a
-  data.tar.gz: 82056f753f0d244afd54de70b7528d1e5d98b0c67f0da18538eb5d906986f12b
+  metadata.gz: a562f35befa229763cc5f2f9be9b2863d35be5002f2269a847261b37d4367736
+  data.tar.gz: db714d3beafd859ac0d121c03ccdde09ccc644886e75c8928279cd8bc2aee69d
 SHA512:
-  metadata.gz: e3289cc2a08751a1358c37ddfb692d042c2d522374b02ed370dd25e703f5c5fe3be66996bbd008a7e6dfbe26a9ea6b278b87f640035a55a235ef7e1ed1d00967
-  data.tar.gz: a54b4dbed546b3f301d42692033552c3878b2281f25fee70e647e02634c19541a7440542bddbade45619a2e6dd4cac8bcefc05ff89b035645195ce90a3bffad6
+  metadata.gz: 866b36dd793f81c0cd9632005aa11c9d061db091ee250d39d6cfdce8aed5906e30ad29f635b5e5fb7a4f969098141bc5f6baadc18eb334256b34102682b612b3
+  data.tar.gz: 8c03862357b6bc6755ac648f1f171b4471c62fb0c0c1e401abccaff51d07dfe1f3728f57633725366bc4d2b2d617f9f2fc1a03d2d80b05ce3be2ac96899ed0ff

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # CHANGELOG
 
+## 1.18.0 (2026-09-17)
+
+- Clone a git catalog without unused package blobs, and fetch a used package file when install needs it.
+- Skip cloning a git catalog when no package uses that source.
+- Fetch a used git catalog once on `pray update` instead of fetching it twice.
+- Keep packages from two git sources that share a clone URL when each source names a different `subdir`.
+- Share one git object store for those subdirectory checkouts.
+- Import signing keys with `pray trust import-repo` after a catalog was cloned only through `subdir` sources.
+- Reuse registry package metadata during one command so `pray update --latest` does not download the same package JSON twice.
+- Skip a second resolve when `pray update --latest` does not rewrite constraints or upstream pins, and still refresh path-fork files when needed.
+
+## 1.17.0 (2026-09-16)
+
+- Locate local prayers through a path source of any directory name (RFC 0117). `pray prayer init` adds `source "local"` when needed and declares `pray "local/project"` once. Version is optional until `pray package` or `pray publish`. `.agents/project.md` remains a compose shortcut for one local file.
+- Copy upstream files into an empty path-fork tree on `pray install` and `pray update` (RFC 0116). Extra listed overlay files stay. `pray outdated` lists fork files that differ from the locked upstream. An identity-only fork uses empty `spec.files`; refresh lists content paths, not the prayspec file.
+- Refuse a local path with `file:` and a local path inside `tree`. Compose still embeds local fragments. Package `file:` and package `tree` stay.
+- Name dest versus lock on `pray verify`, dest versus a fresh render on `pray drift`, and dest write on `pray render`. Dry-run of a write is `pray plan`. Listed local compose files stay on `pray install`.
+- Write `.praytorrent.json` when `v1/distribution.json` lists `protocols: ["torrent"]` (RFC 0062). `pray repo init` writes empty protocols.
+- Parse `spec.maintainers` as a string array, and accept `spec.pray_version` as an alias for `spec.prayfile_version`.
+- Re-embed a changed local compose source on `pray install`, `pray update`, and `pray plan`, and print its `sha256` as `checked` or `was`. List local checksum drift under `pray outdated`.
+
 ## 1.16.0 (2026-09-15)
 
 - Rewrite a two-component pessimistic Prayfile pin on `pray update --latest` (`~> 2.2` to `~> 2.4` when registry latest is 2.4.0), matching the Rust and TypeScript CLIs. Install a newer version that the current constraint already allows.

data/lib/pray/apply_report.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pray
+  module ApplyReport
+    module_function
+
+    def local_summary_lines(previous, project)
+      previous_checksums = previous_local_checksums(previous)
+      project.local_files.filter_map do |local|
+        next if local.content.empty? && local.optional
+
+        checksum = local.source_checksum
+        previous_checksum = previous_checksums[local.manifest_path]
+        if previous_checksum.nil?
+          "Installing #{local.manifest_path} (#{checksum})"
+        elsif previous_checksum == checksum
+          "Using #{local.manifest_path} (#{checksum} checked)"
+        else
+          "Updating #{local.manifest_path} (#{checksum} was #{previous_checksum})"
+        end
+      end
+    end
+
+    def outdated_local_lines(previous, project)
+      previous_checksums = previous_local_checksums(previous)
+      project.local_files.filter_map do |local|
+        next if local.content.empty? && local.optional
+
+        checksum = local.source_checksum
+        previous_checksum = previous_checksums[local.manifest_path]
+        if previous_checksum && previous_checksum != checksum
+          "#{local.manifest_path} #{previous_checksum} -> #{checksum}"
+        elsif previous && previous_checksum.nil?
+          "#{local.manifest_path} (new) -> #{checksum}"
+        end
+      end
+    end
+
+    def previous_local_checksums(previous)
+      return {} unless previous
+
+      previous.managed_span.each_with_object({}) do |span, checksums|
+        next unless span.package == LOCAL_EMBED_PACKAGE
+
+        checksums[span.export] = span.source_checksum
+      end
+    end
+  end
+end

data/lib/pray/cli/commands/init.rb

@@ -25,26 +25,6 @@ module Pray
       File.write(path, "#{lines.join("\n")}\n")
     end
 
-    def prayer_init_command
-      root = Dir.pwd
-      package_name = File.basename(root)
-      package_name = "prayer-package" if package_name.strip.empty?
-      prayspec_path = File.join(root, "#{package_name}.prayspec")
-      raise Error.manifest("package spec already exists: #{prayspec_path}") if File.exist?(prayspec_path)
-
-      File.write(
-        prayspec_path,
-        <<~SPEC
-          Package::Specification.new do |spec|
-            spec.name = "#{package_name}"
-            spec.version = "0.1.0"
-            spec.summary = "Prayer package"
-            spec.files = []
-          end
-        SPEC
-      )
-    end
-
     def repo_init_command
       distribution_root = repo_distribution_root(Dir.pwd)
       index_path = File.join(distribution_root, "v1", "index.json")
@@ -53,6 +33,7 @@ module Pray
       FileUtils.mkdir_p(File.join(distribution_root, "v1", "packages"))
       FileUtils.mkdir_p(File.join(distribution_root, "v1", "artifacts"))
       Publish.write_registry_index(distribution_root, RegistryIndex.new)
+      Distribution.write_settings(distribution_root)
     end
 
     def repo_distribution_root(root)

data/lib/pray/cli/commands/init_prayer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Pray
+  module CLI
+    def prayer_init_command(name = nil, directory = nil)
+      if File.exist?(manifest_path)
+        scaffold_local_prayer(name, directory)
+      else
+        scaffold_standalone_package(name)
+      end
+    end
+
+    def scaffold_local_prayer(name, directory)
+      requested = name.to_s.strip
+      package_name = LocalPrayer.validate_name!(requested.empty? ? DEFAULT_LOCAL_PRAYER_NAME : requested)
+      source_name, source_directory = resolve_local_prayer_directory(directory)
+      root = File.join(project_root, source_directory, package_name)
+      prayspec_path = File.join(root, "#{package_name}.prayspec")
+      raise Error.manifest("package spec already exists: #{prayspec_path}") if File.exist?(prayspec_path)
+      raise Error.manifest("prayer directory already exists: #{root}") if File.exist?(root)
+
+      FileUtils.mkdir_p(File.join(root, "exports"))
+      File.write(prayspec_path, local_prayspec(source_name, package_name))
+      File.write(File.join(root, "README.md"), "# #{package_name}\n")
+      File.write(File.join(root, "exports", "#{package_name}.md"), "# #{package_name}\n")
+      declare_local_prayer("#{source_name}/#{package_name}")
+    end
+
+    def scaffold_standalone_package(name)
+      root = Dir.pwd
+      package_name = if name.nil? || name.strip.empty?
+        basename = File.basename(root)
+        basename.strip.empty? ? "prayer-package" : basename
+      else
+        LocalPrayer.validate_name!(name)
+      end
+      prayspec_path = File.join(root, "#{package_name}.prayspec")
+      raise Error.manifest("package spec already exists: #{prayspec_path}") if File.exist?(prayspec_path)
+
+      File.write(prayspec_path, standalone_prayspec(package_name))
+      readme = File.join(root, "README.md")
+      File.write(readme, "# #{package_name}\n") unless File.exist?(readme)
+      FileUtils.mkdir_p(File.join(root, "exports"))
+    end
+
+    def local_prayspec(source_name, name)
+      <<~SPEC
+        Package::Specification.new do |spec|
+          spec.name = "#{source_name}/#{name}"
+          spec.summary = "Describe this package"
+          spec.files = ["README.md", "exports/#{name}.md"]
+          spec.exports = {
+            "#{name}" => {
+              type: "fragment",
+              path: "exports/#{name}.md"
+            }
+          }
+        end
+      SPEC
+    end
+
+    def standalone_prayspec(name)
+      <<~SPEC
+        Package::Specification.new do |spec|
+          spec.name = "#{name}"
+          spec.version = "0.1.0"
+          spec.summary = "Describe this package"
+          spec.files = ["README.md"]
+          spec.exports = {}
+        end
+      SPEC
+    end
+  end
+end

data/lib/pray/cli/commands/init_prayer_manifest.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Pray
+  module CLI
+    def resolve_local_prayer_directory(requested)
+      manifest = Pray.parse_manifest(Pray.read_manifest_text(manifest_path))
+      path_sources = path_sources_for(manifest)
+      if requested
+        directory = requested.to_s.strip
+        raise Error.usage("--path requires a directory") if directory.empty?
+
+        matching = path_sources.find { |source| source.url == directory }
+        return [matching.name, matching.url] if matching
+        if path_sources.length == 1
+          raise Error.usage("path source already uses #{path_sources.first.url}")
+        end
+
+        name = ensure_path_source(directory)
+        return [name, directory]
+      end
+
+      case path_sources.length
+      when 0
+        name = ensure_path_source(DEFAULT_PATH_SOURCE_DIRECTORY)
+        [name, DEFAULT_PATH_SOURCE_DIRECTORY]
+      when 1
+        [path_sources.first.name, path_sources.first.url]
+      else
+        raise Error.usage("say which directory with --path")
+      end
+    end
+
+    def declare_local_prayer(package_name)
+      manifest_text = Pray.read_manifest_text(manifest_path)
+      manifest = Pray.parse_manifest(manifest_text)
+      return if manifest.packages.any? { |package| package.name == package_name }
+
+      statement = "pray \"#{package_name}\""
+      updated = insert_into_first_compose(manifest_text, statement) ||
+        insert_manifest_statement(manifest_text, statement)
+      Transaction.write_file(manifest_path, updated)
+    end
+
+    def path_sources_for(manifest)
+      manifest.sources.select { |source| source.kind == "path" }
+    end
+
+    def ensure_path_source(directory)
+      manifest_text = Pray.read_manifest_text(manifest_path)
+      manifest = Pray.parse_manifest(manifest_text)
+      existing = manifest.sources.find { |source| source.kind == "path" && source.url == directory }
+      return existing.name if existing
+
+      name = unused_source_name(manifest, directory)
+      statement = "source \"#{name}\", path: \"#{directory}\""
+      Transaction.write_file(manifest_path, insert_source_statement(manifest_text, statement))
+      name
+    end
+
+    def unused_source_name(manifest, directory)
+      taken = manifest.sources.map(&:name)
+      return DEFAULT_PATH_SOURCE_NAME unless taken.include?(DEFAULT_PATH_SOURCE_NAME)
+
+      fallback = directory.to_s.split(%r{[/\\]}).reject(&:empty?).last || DEFAULT_PATH_SOURCE_NAME
+      raise Error.manifest("source name #{fallback} is already used") if taken.include?(fallback)
+
+      fallback
+    end
+
+    def insert_source_statement(text, statement)
+      lines = text.lines.map(&:chomp)
+      last_source = lines.rindex { |line| line.lstrip.start_with?("source ") }
+      insertion_index = if last_source
+        last_source + 1
+      else
+        prayfile = lines.index { |line| line.lstrip.start_with?("prayfile ") }
+        prayfile ? prayfile + 1 : 0
+      end
+      lines.insert(insertion_index, statement)
+      join_manifest_lines(lines)
+    end
+
+    def insert_into_first_compose(text, statement)
+      lines = text.lines.map(&:chomp)
+      index = lines.index do |line|
+        trimmed = line.lstrip
+        trimmed.start_with?("compose ") && trimmed.end_with?(" do")
+      end
+      return unless index
+
+      indent = lines[index][/\A\s*/].to_s
+      lines.insert(index + 1, "#{indent}  #{statement}")
+      join_manifest_lines(lines)
+    end
+
+    def join_manifest_lines(lines)
+      output = lines.join("\n")
+      output += "\n" unless output.end_with?("\n")
+      output
+    end
+  end
+end

data/lib/pray/cli/commands/packages.rb

@@ -36,7 +36,7 @@ module Pray
       project = resolve_current_project
       lines = ["Package list"]
       project.packages.each do |package|
-        lines << "#{package.declaration.name} #{package.spec.version} source=#{package_source_summary(package)} exports=#{format_list(package.selected_exports)}"
+        lines << "#{package.declaration.name} #{package.spec.recorded_version} source=#{package_source_summary(package)} exports=#{format_list(package.selected_exports)}"
       end
       puts lines.join("\n")
     end
@@ -54,6 +54,7 @@ module Pray
     def package_command
       project = resolve_current_project
       project.packages.each do |package|
+        package.spec.require_release_version!
         output_path = Archive.package_archive_path(package.declaration.name, package.spec.version)
         Archive.write_package_archive(package, output_path)
       end
@@ -72,7 +73,7 @@ module Pray
       lines = ["Package explanation"]
       lines << "name: #{package.declaration.name}"
       lines << "constraint: #{package.declaration.constraint}"
-      lines << "resolved version: #{package.spec.version}"
+      lines << "resolved version: #{package.spec.recorded_version}"
       if package.registry_latest_version
         lines << "registry latest: #{package.registry_latest_version}"
       end
@@ -102,6 +103,16 @@ module Pray
       else
         Plan.package_summary_lines(previous_lockfile, latest_lockfile, project).each { |line| puts line }
       end
+      local_lines = ApplyReport.outdated_local_lines(previous_lockfile, project)
+      unless local_lines.empty?
+        puts "Outdated local files"
+        local_lines.each { |line| puts line }
+      end
+      fork_lines = Upstream.path_fork_drift_lines(project, previous_lockfile, ResolveOptions.new)
+      unless fork_lines.empty?
+        puts "Outdated path forks"
+        fork_lines.each { |line| puts line }
+      end
     end
   end
 end

data/lib/pray/cli/commands/trust.rb

@@ -28,10 +28,10 @@ module Pray
 
     def trust_import_repo_command(source_url, match_prefix: nil)
       clone_url = source_url.delete_prefix("git+")
-      repository = GitSources.git_source_cache_directory(Dir.pwd, clone_url)
-      unless File.directory?(File.join(repository, ".git"))
+      repository = GitSources.git_source_cached_repository(Dir.pwd, clone_url)
+      unless repository
         raise Error.resolution(
-          "no cached git repository for #{clone_url} at #{repository}"
+          "no cached git repository for #{clone_url}"
         )
       end
 

data/lib/pray/cli/commands/update_latest.rb

@@ -6,13 +6,15 @@ module Pray
       path = manifest_path
       original_text = Pray.read_manifest_text(path)
       manifest_text = original_text
-      preview_options = ResolveOptions.new(
+      unlocked = package ? Set[package] : Set.new
+      options = ResolveOptions.new(
         offline: offline,
         refresh: true,
         refresh_source_revisions: true,
-        ignore_locked_versions: true
+        ignore_locked_versions: package.nil?,
+        unlocked_packages: unlocked
       )
-      project = resolve_current_project(preview_options)
+      project = resolve_current_project(options)
       if package && project.manifest.packages.none? { |entry| entry.name == package }
         raise Error.manifest("package #{package} not found")
       end
@@ -46,24 +48,20 @@ module Pray
 
       previous = File.exist?(lockfile_path) ? Pray.read_lockfile(lockfile_path) : nil
       upstream_plans = Upstream.plan_path_upstream_latest_constraints(
-        project, previous, package, preview_options
+        project, previous, package, options
       )
       print_latest_constraint_plans(manifest_updates, upstream_plans)
 
       return if dry_run
 
-      Upstream.apply_path_upstream_latest_constraints(upstream_plans)
-      Transaction.write_file(path, manifest_text) if manifest_text != original_text
-      unlocked = package ? Set[package] : Set.new
-      options = ResolveOptions.new(
-        offline: offline,
-        refresh: true,
-        refresh_source_revisions: true,
-        ignore_locked_versions: package.nil?,
-        unlocked_packages: unlocked
-      )
-      current = resolve_current_project(options)
-      Upstream.apply_path_upstream_refreshes(current, previous, package, options)
+      if !manifest_updates.empty? || !upstream_plans.empty?
+        Upstream.apply_path_upstream_latest_constraints(upstream_plans)
+        Transaction.write_file(path, manifest_text) if manifest_text != original_text
+        current = resolve_current_project(options)
+        Upstream.apply_path_upstream_refreshes(current, previous, package, options)
+      else
+        Upstream.apply_path_upstream_refreshes(project, previous, package, options)
+      end
       install_command(
         {
           locked: false,

data/lib/pray/cli/commands/workflow.rb

@@ -5,6 +5,7 @@ require "fileutils"
 module Pray
   module CLI
     def install_command(flags)
+      previous_lockfile = File.exist?(lockfile_path) ? Pray.read_lockfile(lockfile_path) : nil
       Pray.materialize_project(
         manifest_path: manifest_path,
         frozen: flags[:frozen],
@@ -14,6 +15,10 @@ module Pray
         ignore_locked_versions: flags[:ignore_locked_versions],
         unlocked_packages: flags[:unlocked_packages]
       )
+      return if flags[:frozen] || flags[:locked]
+
+      project = resolve_current_project
+      ApplyReport.local_summary_lines(previous_lockfile, project).each { |line| puts line }
     end
 
     def render_command(flags)

data/lib/pray/cli/help.rb

@@ -4,19 +4,19 @@ module Pray
   module CLI
     module Help
       WORKFLOW_COMMANDS = [
-        "install [--locked|--frozen|--offline]  resolve, render, and write Prayfile.lock",
-        "plan [--remote]                        preview materialization changes",
+        "install [--locked|--frozen|--offline]  keep locked versions, re-embed listed locals",
+        "plan [--remote]                        dry-run of install: dest after patch",
         "apply                                  apply the current plan",
-        "verify [--strict]                      check rendered output against the lockfile",
-        "drift [--semantic]                     compare lockfile to current resolution",
-        "render [--check]                       render targets without updating the lockfile",
+        "verify [--strict]                      dest managed spans versus Prayfile.lock",
+        "drift [--semantic]                     dest versus lock, then dest versus a fresh render",
+        "render [--check]                       write dest from current inputs",
         "format, fmt                            rewrite Prayfile to recommended destination DSL"
       ].freeze
 
       PACKAGE_COMMANDS = [
         "add <name> [constraint] [--path PATH]  declare a package in Prayfile",
         "remove <name>                          remove a package from Prayfile",
-        "update [package]",
+        "update [package]                       re-resolve packages and git sources within constraints",
         "unlock <package>                       clear a locked package pin",
         "vendor                                 copy resolved packages locally",
         "clean                                  remove local cache and vendor trees"
@@ -43,7 +43,7 @@ module Pray
 
       META_COMMANDS = [
         "init [--targets tool_a,tool_b]         create a starter Prayfile",
-        "prayer init                            scaffold a prayer package",
+        "prayer init [name] [--path DIR]       scaffold a local prayer",
         "repo init                              scaffold a distribution root",
         "manifest                               print canonical Prayfile JSON",
         "package                                build a distributable prayer archive",
@@ -58,33 +58,49 @@ module Pray
 
       COMMAND_HELP = {
         "install" => <<~TEXT.strip,
-          resolve packages, render targets, and update Prayfile.lock
+          keep locked package versions and re-embed listed local compose sources
 
           Usage: pray install [--locked|--frozen|--offline]
 
+          Install renders dest and writes Prayfile.lock. Package versions stay at the lock.
+          Listed local compose files are re-embedded and their span checksums refresh.
+          A path package with spec.upstream copies upstream files when the path tree has no content yet.
+          Use pray update to re-resolve package versions and git sources.
+          Use pray plan to preview a write.
+
           --locked   require an existing lockfile
-          --frozen   require lockfile to match Prayfile exactly
+          --frozen   fail if dest or lock would change
           --offline  use cache only
         TEXT
         "verify" => <<~TEXT.strip,
-          check rendered files against Prayfile.lock
+          compare dest managed spans versus Prayfile.lock
 
           Usage: pray verify [--strict]
 
+          Read-only integrity check. It does not compare dest to a fresh render from current sources.
+          A changed local compose file is clean here when dest and lock still match.
+          Use pray drift to compare dest with a fresh render. Use pray plan to preview a write.
+
           Without --strict, orphan-marker warnings print to stderr but exit 0.
           With --strict, any finding fails with exit code 6.
         TEXT
         "drift" => <<~TEXT.strip,
-          report differences between lockfile and current resolution
+          compare dest versus Prayfile.lock, then dest versus a fresh render
 
           Usage: pray drift [--semantic]
 
+          Read-only finding report from current packages and listed local files. Not a line diff.
           Exits with code 6 when drift is found.
+          Use pray plan to preview a write. Use pray verify for dest versus lock alone.
         TEXT
         "render" => <<~TEXT.strip,
-          render targets without updating the lockfile
+          write dest from current inputs
 
           Usage: pray render [--check]
+
+          Without --check, render writes dest. It does not write Prayfile.lock.
+          Use pray plan to preview a write.
+          --check writes nothing. It fails unless dest already matches a fresh render from current inputs.
         TEXT
         "format" => <<~TEXT.strip,
           rewrite Prayfile to recommended destination DSL
@@ -99,18 +115,25 @@ module Pray
                  pray fmt
         TEXT
         "update" => <<~TEXT.strip,
-          refresh package versions within constraints
+          re-resolve package versions and git sources within current constraints
 
           Usage: pray update [package] [--latest] [--latest --dry-run]
 
+          With no package name, update re-resolves the whole graph within constraints
+          and refreshes git source revisions. A package name unlocks that package only.
+          Path-fork packages can refresh from upstream.
+          Listed local compose files are re-embedded by pray install, not by update.
+
           --latest adjusts constraints to allow the latest package versions.
           --latest also rewrites exact spec.upstream pins in path packages, then refreshes those trees.
           --latest --dry-run prints the planned rewrite and does not write.
         TEXT
         "plan" => <<~TEXT.strip,
-          preview install/apply changes
+          preview what install or apply would write after patch
 
           Usage: pray plan [--remote]
+
+          This is the dry-run of a write. It does not write dest or the lock.
         TEXT
         "apply" => "materialize the current resolution plan\n\nUsage: pray apply",
         "add" => <<~TEXT.strip,
@@ -159,6 +182,8 @@ module Pray
           show constraint vs resolved versions
 
           Usage: pray outdated [--remote]
+
+          Path-fork files that differ from the locked upstream are listed.
         TEXT
         "explain" => <<~TEXT.strip,
           show why a package was selected
@@ -171,7 +196,19 @@ module Pray
 
           Usage: pray init [--targets tool_a,tool_b]
         TEXT
-        "prayer" => "scaffold a prayer package\n\nUsage: pray prayer init",
+        "prayer" => <<~TEXT.strip,
+          scaffold a local prayer under a path source
+
+          Usage: pray prayer init [name] [--path DIR]
+
+          With a Prayfile, writes <name>/ under the path source directory without a version.
+          The default directory is prayers/. Use --path to choose another.
+          Declares pray "<source>/<name>" once, such as pray "local/project", inside compose when a compose block exists.
+          The default name is project. The name v1 is reserved for the distribution layout.
+          Without a Prayfile, writes a versioned package spec in the current directory.
+          Add spec.version before pray package or pray publish.
+          A compose file such as .agents/project.md remains a shortcut for one local file.
+        TEXT
         "repo" => "scaffold a distribution root\n\nUsage: pray repo init",
         "manifest" => "print canonical Prayfile JSON\n\nUsage: pray manifest",
         "package" => "build a distributable prayer archive\n\nUsage: pray package",

data/lib/pray/cli/helpers.rb

@@ -80,11 +80,19 @@ module Pray
 
     def remove_manifest_statement(text, name)
       lines = text.lines.map(&:chomp)
-      package_prefix = "agent \"#{name}\""
-      alternate_prefix = "agent '#{name}'"
+      prefixes = [
+        %(pray "#{name}"),
+        %(pray '#{name}'),
+        %(use "#{name}"),
+        %(include "#{name}"),
+        %(agent "#{name}"),
+        %(agent '#{name}'),
+        %(package "#{name}"),
+        %(package '#{name}')
+      ]
       index = lines.index do |line|
         trimmed = line.lstrip
-        trimmed.start_with?(package_prefix, alternate_prefix)
+        prefixes.any? { |prefix| trimmed.start_with?(prefix) }
       end
       if index
         lines.delete_at(index)
@@ -141,14 +149,14 @@ module Pray
 
     def render_tree_node(package, package_map, depth, ancestry, lines)
       indent = "  " * depth
-      lines << "#{indent}#{package.declaration.name} #{package.spec.version}"
+      lines << "#{indent}#{package.declaration.name} #{package.spec.recorded_version}"
       return unless ancestry.add?(package.declaration.name)
 
       package.spec.dependencies.each do |dependency|
         resolved = package_map[dependency.name]
         if resolved
           if ancestry.include?(resolved.declaration.name)
-            lines << "#{indent}  #{resolved.declaration.name} #{resolved.spec.version} (cycle)"
+            lines << "#{indent}  #{resolved.declaration.name} #{resolved.spec.recorded_version} (cycle)"
           else
             render_tree_node(resolved, package_map, depth + 1, ancestry, lines)
           end

data/lib/pray/cli/parse.rb

@@ -42,7 +42,7 @@ module Pray
       when "prayer"
         raise Error.unsupported("prayer requires init") unless arguments.shift == "init"
 
-        [:prayer_init]
+        [:prayer_init, *parse_prayer_init_arguments(arguments)]
       when "repo"
         raise Error.unsupported("repo requires init") unless arguments.shift == "init"
 
@@ -77,6 +77,26 @@ module Pray
       end
     end
 
+    def parse_prayer_init_arguments(arguments)
+      name = nil
+      directory = nil
+      while (argument = arguments.shift)
+        if argument == "--path"
+          directory = arguments.shift
+          if directory.nil? || directory.start_with?("-")
+            raise Error.usage("--path requires a directory")
+          end
+        elsif argument.start_with?("-")
+          raise Error.unsupported("unexpected prayer argument: #{argument}")
+        elsif name.nil?
+          name = argument
+        else
+          raise Error.unsupported("unexpected prayer argument: #{argument}")
+        end
+      end
+      [name, directory]
+    end
+
     def extract_flag!(arguments, flag)
       found = arguments.include?(flag)
       arguments.reject! { |argument| argument == flag }