@zalom/plastic 2.0.0-alpha.27 → 2.0.0-alpha.28

package/scripts/lib/cli/commands/migrate.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "subcommand_list"
+
+module Plastic
+  class CLI
+    module Commands
+      class Migrate < SubcommandList
+        USAGE_LINE = "plastic migrate SUBCOMMAND [options]"
+        PREFIX = "migrate"
+        NEXT = "plastic migrate stores --dry-run"
+        BECAUSE = "a dry run prints every move and rewrite and changes nothing"
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/migrate_stores.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../../stores_move"
+
+module Plastic
+  class CLI
+    module Commands
+      class MigrateStores < Command
+        USAGE_LINE = "plastic migrate stores [--dry-run] [--json]"
+
+        def call
+          move = StoresMove.new(scope.plastic_home, qmd_index: File.join(@home, ".config", "qmd", "index.yml"), dry_run: options[:dry_run])
+          move.call.each { |verb, text| @output.row(verb, text) }
+          return @output.next_step("plastic migrate stores", because: "the dry run changed nothing") if options[:dry_run]
+
+          @output.row("remove", "rm -rf #{move.copy}")
+          @output.next_step("plastic doctor", because: "it checks the moved stores, and the copy stays until you remove it")
+        rescue StoresMove::Refused => e
+          raise Refusal, e.message
+        end
+
+        private
+
+        def switches(parser)
+          parser.on("--dry-run") { options[:dry_run] = true }
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/next.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../frontier"
+require_relative "../scope"
+
+# `plastic next` - one line saying what to pick up, then the step to take and
+# the rule that chose it. `--why` adds the roadmap, its frontier batch, and
+# what is dispatchable, in flight and blocked.
+module Plastic
+  class CLI
+    module Commands
+      class Next < Command
+        USAGE_LINE = "plastic next [--why] [--project SLUG] [--json]"
+
+        def call
+          @output.row("next work", frontier.summary)
+          detail if options[:why]
+          @output.next_step(frontier.next_step, because: frontier.because)
+        rescue RoadmapSavepoint::MissingGroupingHeading => e
+          raise Failure, e.message
+        end
+
+        private
+
+        def switches(parser)
+          parser.on("--why") { @options[:why] = true }
+          parser.on("--project SLUG") { |slug| @options[:project] = slug }
+        end
+
+        def detail
+          @output.row("roadmap", frontier.roadmap || Frontier::NONE)
+          @output.row("frontier", frontier.heading || Frontier::NONE)
+          @output.row("dispatchable", listed(frontier.dispatchable_ids))
+          @output.row("in flight", listed(frontier.in_flight_ids))
+          @output.row("blocked", listed(frontier.blocked_ids))
+        end
+
+        def listed(ids)
+          ids.empty? ? Frontier::NONE : ids.join(", ")
+        end
+
+        def frontier
+          @frontier ||= Frontier.new(scope)
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/project.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "subcommand_list"
+
+# `plastic project` - the list of `plastic project ...` subcommands, straight
+# out of the table; a word that names none of them is a usage error naming
+# the same list, so a typo never falls through to a script.
+module Plastic
+  class CLI
+    module Commands
+      class Project < SubcommandList
+        USAGE_LINE = "plastic project SUBCOMMAND [options]"
+        PREFIX = "project"
+        NEXT = "plastic project list"
+        BECAUSE = "the stores it lists are what every other subcommand names a slug from"
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/project_links.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../legacy"
+
+# `plastic project links` - projects every store's `## Links` sections from
+# frontmatter (`project-links`, run through Legacy).
+module Plastic
+  class CLI
+    module Commands
+      class ProjectLinks < Command
+        USAGE_LINE = "plastic project links [--dry-run] [--json]"
+
+        def initialize(argv, runner: nil, **streams)
+          super(argv, **streams)
+          @runner = runner
+        end
+
+        def call
+          status = legacy.run("project-links", "--plastic-home", scope.plastic_home, *dry_run_flag)
+          raise Failure, "project-links exited #{status}" unless status.zero?
+
+          @output.next_step("plastic status", because: "the Links sections just rebuilt across every store")
+        end
+
+        private
+
+        def switches(parser)
+          parser.on("--dry-run") { @options[:dry_run] = true }
+        end
+
+        def dry_run_flag
+          options[:dry_run] ? ["--dry-run"] : []
+        end
+
+        def legacy
+          @legacy ||= Legacy.new(env: @env, runner: @runner)
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/project_list.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+# `plastic project list` - every store this machine holds, global and
+# project, straight from Scope#stores, in this process.
+module Plastic
+  class CLI
+    module Commands
+      class ProjectList < Command
+        USAGE_LINE = "plastic project list [--json]"
+
+        def call
+          scope.stores.each { |store| @output.row(store[:slug], store[:root]) }
+          @output.next_step("plastic status", because: "status shows what is active in each store this just listed")
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/project_new.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "date"
+require_relative "../command"
+require_relative "../legacy"
+require_relative "../../store_provisioning"
+
+# `plastic project new` - registers a project in projects.yml, then provisions
+# and validates its store (`provision-project-store`, `validate-project`, run
+# through Legacy). The project directory must already exist; this command
+# never makes one, and a slug already registered is a Failure.
+module Plastic
+  class CLI
+    module Commands
+      class ProjectNew < Command
+        USAGE_LINE = "plastic project new SLUG --path PATH [--parent ID] [--json]"
+
+        def initialize(argv, runner: nil, **streams)
+          super(argv, **streams)
+          @runner = runner
+        end
+
+        def call
+          raise Usage, "SLUG is required" if slug.to_s.empty?
+          raise Usage, "--path is required" if options[:path].to_s.empty?
+          raise Failure, "#{options[:path]} does not exist" unless Dir.exist?(options[:path])
+          raise Failure, "#{options[:path]} has no AGENTS.md; write one first" unless File.file?(File.join(options[:path], "AGENTS.md"))
+          raise Failure, "#{slug} is already registered" if StoreProvisioning.registered?(slug, scope.plastic_home)
+
+          register
+          run("provision-project-store", slug, "--home", scope.plastic_home)
+          run("validate-project", slug, "--home", scope.plastic_home)
+          @output.next_step("plastic project links", because: "the new store's Links section needs projecting before anything cites it")
+        end
+
+        private
+
+        def slug
+          arguments.first
+        end
+
+        def switches(parser)
+          parser.on("--path PATH") { |v| @options[:path] = v }
+          parser.on("--parent ID") { |v| @options[:parent] = v }
+        end
+
+        def projects_yml
+          File.join(scope.plastic_home, "projects.yml")
+        end
+
+        def register
+          data = File.exist?(projects_yml) ? (YAML.safe_load_file(projects_yml) || {}) : {}
+          data["projects"] ||= {}
+          entry = {"path" => File.expand_path(options[:path]), "registered" => Date.today.to_s, "status" => "active"}
+          entry["parent"] = options[:parent] if options[:parent]
+          data["projects"][slug] = entry
+          File.write(projects_yml, YAML.dump(data))
+        end
+
+        def run(script, *args)
+          status = legacy.run(script, *args)
+          raise Failure, "#{script} exited #{status}" unless status.zero?
+        end
+
+        def legacy
+          @legacy ||= Legacy.new(env: @env, runner: @runner)
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/query.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../../search_index"
+
+module Plastic
+  class CLI
+    module Commands
+      class Query < Command
+        USAGE_LINE = "plastic query SQL [--json]"
+
+        def call
+          raise Usage, "SQL is missing" if arguments.empty?
+          raise Failure, "no index at #{database}; run plastic index" unless File.file?(database)
+
+          rows = Sqlite.call(database, arguments.join(" "), readonly: true)
+          rows.each_with_index { |row, index| @output.row((index + 1).to_s, row.map { |key, value| "#{key}=#{value}" }.join("  ")) }
+          @output.next_step("none", because: "the rows are the whole answer; the database is opened read-only")
+        rescue Sqlite::Error => e
+          raise Failure, e.message
+        end
+
+        private
+
+        def database
+          SearchIndex.path(scope.plastic_home)
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/render.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+module Plastic
+  class CLI
+    module Commands
+      class Render < Command
+        USAGE_LINE = "plastic render FILE"
+        STYLE = File.expand_path("../../../../templates/render.css", __dir__)
+
+        def call
+          file = arguments.first or raise Usage, "FILE is the markdown file to render"
+          raise Failure, "no file at #{file}" unless File.file?(file)
+
+          require "rubygems"
+          require "rdoc"
+          body = RDoc::Markdown.parse(File.read(file, encoding: "UTF-8")).accept(RDoc::Markup::ToHtml.new)
+          @output.raw("<!doctype html>\n<meta charset=\"utf-8\">\n<title>#{File.basename(file)}</title>\n" \
+            "<style>\n#{File.read(STYLE)}</style>\n#{body}")
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/roadmap.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "subcommand_list"
+
+# `plastic roadmap` - the list of `plastic roadmap ...` subcommands, straight
+# out of the table; a word that names none of them is a usage error naming
+# the same list, so a typo never falls through to a script.
+module Plastic
+  class CLI
+    module Commands
+      class Roadmap < SubcommandList
+        USAGE_LINE = "plastic roadmap SUBCOMMAND [options]"
+        PREFIX = "roadmap"
+        NEXT = "plastic roadmap next"
+        BECAUSE = "next names the roadmap most worth continuing, with no slug to guess"
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/roadmap_check.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../legacy"
+
+# `plastic roadmap check` - the roadmap graph's batches, ready set and any
+# cycle or dangling id (`roadmap-graph check`, run through Legacy).
+module Plastic
+  class CLI
+    module Commands
+      class RoadmapCheck < Command
+        USAGE_LINE = "plastic roadmap check SLUG [--json]"
+
+        def initialize(argv, runner: nil, **streams)
+          super(argv, **streams)
+          @runner = runner
+        end
+
+        def call
+          raise Usage, "SLUG is required" if slug.to_s.empty?
+
+          status = legacy.run("roadmap-graph", "check", path)
+          raise Failure, "roadmap-graph exited #{status}" unless status.zero?
+
+          @output.next_step("plastic roadmap show #{slug}", because: "the graph just checked out clean")
+        end
+
+        private
+
+        def slug
+          arguments.first
+        end
+
+        def path
+          File.join(scope.roadmaps_dir, "#{slug}.md")
+        end
+
+        def legacy
+          @legacy ||= Legacy.new(env: @env, runner: @runner)
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/roadmap_log.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../legacy"
+
+# `plastic roadmap log` - appends a savepoint line to a roadmap's ledger
+# (`roadmap-savepoint append`, run through Legacy).
+module Plastic
+  class CLI
+    module Commands
+      class RoadmapLog < Command
+        USAGE_LINE = 'plastic roadmap log SLUG EVENT "TEXT" [--json]'
+
+        def initialize(argv, runner: nil, **streams)
+          super(argv, **streams)
+          @runner = runner
+        end
+
+        def call
+          raise Usage, "SLUG is required" if slug.to_s.empty?
+          raise Usage, "EVENT is required" if event.to_s.empty?
+          raise Usage, "TEXT is required" if text.to_s.empty?
+
+          status = legacy.run("roadmap-savepoint", "append", "--roadmap", path, "--event", event, "--detail", text)
+          raise Failure, "roadmap-savepoint exited #{status}" unless status.zero?
+
+          @output.next_step("plastic roadmap show #{slug}", because: "the log line just landed on the state screen")
+        end
+
+        private
+
+        def slug
+          arguments[0]
+        end
+
+        def event
+          arguments[1]
+        end
+
+        def text
+          arguments[2]
+        end
+
+        def path
+          File.join(scope.roadmaps_dir, "#{slug}.md")
+        end
+
+        def legacy
+          @legacy ||= Legacy.new(env: @env, runner: @runner)
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/roadmap_next.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../legacy"
+
+# `plastic roadmap next` - the roadmap most worth continuing right now
+# (`roadmap-next --which`, run through Legacy).
+module Plastic
+  class CLI
+    module Commands
+      class RoadmapNext < Command
+        USAGE_LINE = "plastic roadmap next [--json]"
+
+        def initialize(argv, runner: nil, **streams)
+          super(argv, **streams)
+          @runner = runner
+        end
+
+        def call
+          status = legacy.run("roadmap-next", "--roadmaps-dir", scope.roadmaps_dir, "--which")
+          raise Failure, "roadmap-next exited #{status}" unless status.zero?
+
+          @output.next_step("plastic roadmap show SLUG", because: "the winner it just named is the slug that command wants")
+        end
+
+        private
+
+        def legacy
+          @legacy ||= Legacy.new(env: @env, runner: @runner)
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/roadmap_show.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../legacy"
+
+# `plastic roadmap show` - a roadmap's state screen (`report-screen roadmap
+# FILE state`, run through Legacy). SLUG is required: `plastic roadmap next`
+# is the command that picks one when the caller has none in mind.
+module Plastic
+  class CLI
+    module Commands
+      class RoadmapShow < Command
+        USAGE_LINE = "plastic roadmap show SLUG [--json]"
+
+        def initialize(argv, runner: nil, **streams)
+          super(argv, **streams)
+          @runner = runner
+        end
+
+        def call
+          raise Usage, "SLUG is required" if slug.to_s.empty?
+
+          status = legacy.run("report-screen", "roadmap", path, "state")
+          raise Failure, "report-screen exited #{status}" unless status.zero?
+
+          @output.next_step("plastic roadmap log #{slug} EVENT \"TEXT\"", because: "a savepoint is how this state screen keeps moving")
+        end
+
+        private
+
+        def slug
+          arguments.first
+        end
+
+        def path
+          File.join(scope.roadmaps_dir, "#{slug}.md")
+        end
+
+        def legacy
+          @legacy ||= Legacy.new(env: @env, runner: @runner)
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/rollback.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "installer_verb"
+
+# `plastic rollback` - steps back to a version this machine has already run. The
+# work is still scripts/rollback.rb, run through Legacy.
+module Plastic
+  class CLI
+    module Commands
+      class Rollback < InstallerVerb
+        USAGE_LINE = "plastic rollback [--version VERSION] [--downgrade] [--upgrade] [--reinstall]"
+        FLAGS = %w[--version --downgrade --upgrade --reinstall].freeze
+
+        SCRIPT = "rollback.rb"
+        AFTER = "plastic version"
+        BECAUSE = "the version says which build is installed"
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/search.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../../search_index"
+require_relative "../../rlm/query"
+
+module Plastic
+  class CLI
+    module Commands
+      class Search < Command
+        USAGE_LINE = "plastic search TERMS [--ask] [--project SLUG] [--limit N] [--json]"
+        DEFAULT_LIMIT = 10
+
+        def call
+          raise Usage, "TERMS is missing" if arguments.empty?
+          raise Failure, "no index at #{database}; run plastic index" unless File.file?(database)
+
+          rows = options[:ask] ? RLM::Query.new(RLM::Probe.new(corpus, limit: limit)).call(arguments.join(" ")) : found(arguments, limit)
+          rows.each { |row| @output.row(row["path"], row["excerpt"].gsub(/\s+/, " ").strip) }
+          @output.row("result", "no match") if rows.empty?
+          @output.next_step("plastic index", because: "the index was built #{File.mtime(database).strftime("%Y-%m-%d %H:%M")}; rebuild it when the stores have changed")
+        rescue Sqlite::Error => e
+          raise Failure, e.message
+        end
+
+        private
+
+        def switches(parser)
+          parser.on("--ask") { @options[:ask] = true }
+          parser.on("--project SLUG") { |slug| @options[:project] = slug }
+          parser.on("--limit N", Integer) { |limit| @options[:limit] = limit }
+        end
+
+        def limit
+          options[:limit] || DEFAULT_LIMIT
+        end
+
+        def found(terms, count)
+          SearchIndex.search(scope.plastic_home, terms, limit: count, prefix: prefix)
+        end
+
+        def corpus
+          RLM::Corpus.new(method(:found))
+        end
+
+        def database
+          SearchIndex.path(scope.plastic_home)
+        end
+
+        def prefix
+          return "" unless options[:project]
+
+          home = scope.plastic_home
+          root = (scope.slug == Scope::GLOBAL) ? StoreLayout.global_store(home) : StoreLayout.project_root(home, scope.slug)
+          "#{root.delete_prefix("#{home}/")}/"
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/session.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "subcommand_list"
+
+# `plastic session` - the list of `plastic session ...` subcommands, straight
+# out of the table.
+module Plastic
+  class CLI
+    module Commands
+      class Session < SubcommandList
+        USAGE_LINE = "plastic session SUBCOMMAND [options]"
+        PREFIX = "session"
+        NEXT = 'plastic session commit "SUMMARY"'
+        BECAUSE = "a commit is the smallest unit every other session subcommand builds on"
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/session_commit.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../legacy"
+
+# `plastic session commit` - one commit for a verified checklist item, on the
+# directory this command was invoked from (`session-commit --cwd DIR
+# --summary SUMMARY`, run through Legacy; fail-open by contract, so a Failure
+# here means the script's own usage error, not a git failure).
+module Plastic
+  class CLI
+    module Commands
+      class SessionCommit < Command
+        USAGE_LINE = 'plastic session commit "SUMMARY" [--json]'
+
+        def initialize(argv, runner: nil, **streams)
+          super(argv, **streams)
+          @runner = runner
+        end
+
+        def call
+          raise Usage, "SUMMARY is required" if summary.to_s.empty?
+
+          status = legacy.run("session-commit", "--cwd", @directory, "--summary", summary)
+          raise Failure, "session-commit exited #{status}" unless status.zero?
+
+          @output.next_step("plastic session handoff", because: "a handoff after a commit keeps the day ledger current")
+        end
+
+        private
+
+        def summary
+          arguments.first
+        end
+
+        def legacy
+          @legacy ||= Legacy.new(env: @env, runner: @runner)
+        end
+      end
+    end
+  end
+end