@zalom/plastic 1.0.0-alpha.3 → 1.0.0-alpha.31

package/scripts/lib/intent_validator.rb

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "yaml"
+require "date"
+require "time"
+
+# IntentValidator — the single source of truth for "is an intent born complete?"
+# (intent 60).
+#
+# An intent is born complete when its frontmatter carries every required field
+# and its `sources` and `chain` are well-formed arrays of Folgezettel id references
+# (bare ids like `1a2`, or cross-store refs like `global:1a2`; integer ids are coerced).
+# This module is the only definition of that contract; the `validate-intent` CLI,
+# the doctor diagnostics, and the creating-intent skill all consult it so the
+# definition never drifts across copies.
+#
+# Pure and dependency-injected: `validate` accepts an injectable `plastic_home`
+# for house-style parity, parses with a rescue-to-safe-default reader, uses no
+# `eval`, and performs no file writes and no global-constant injection.
+module IntentValidator
+  module_function
+
+  # Must match Doctor::REQUIRED_FRONTMATTER_FIELDS (scripts/doctor.rb).
+  REQUIRED_FIELDS = %w[id intent sources chain created author tags].freeze
+
+  # Fields whose value must be a well-formed array of valid id strings.
+  ARRAY_ID_FIELDS = %w[sources chain].freeze
+
+  # Folgezettel id form: digits then an optional lowercase-letter/digit suffix
+  # (for example "14", "14a", "4a1"). Mirrors scripts/folgezettel-id.
+  ID_PATTERN = /\A([a-z0-9-]+:)?\d+[a-z0-9]*\z/
+
+  # True iff `value` is a String matching the Folgezettel id form.
+  def valid_id?(value)
+    value.to_s.match?(ID_PATTERN)
+  end
+
+  # Read a file's YAML frontmatter, returning the parsed Hash (or {} when the
+  # frontmatter block is empty), or nil when there is no parseable frontmatter.
+  # A copy of Doctor#parse_frontmatter so `created:` dates do not crash.
+  def parse_frontmatter(path)
+    return nil unless File.exist?(path)
+
+    content = File.read(path)
+    return nil unless content.start_with?("---")
+
+    parts = content.split("---", 3)
+    return nil if parts.length < 3
+
+    YAML.safe_load(parts[1], permitted_classes: [Date, Time]) || {}
+  rescue StandardError
+    nil
+  end
+
+  # PURE: given a parsed frontmatter Hash (or nil), return
+  # { ok: Boolean, missing: [field names], errors: [human strings] }.
+  def validate_frontmatter(fm)
+    unless fm.is_a?(Hash)
+      return { ok: false, missing: REQUIRED_FIELDS.dup, errors: ["no frontmatter found"] }
+    end
+
+    missing = REQUIRED_FIELDS.reject { |f| fm.key?(f) }
+    errors = missing.map { |f| "missing required field: #{f}" }
+
+    ARRAY_ID_FIELDS.each do |key|
+      next unless fm.key?(key)
+
+      value = fm[key]
+      unless value.is_a?(Array)
+        errors << "#{key} must be an array"
+        next
+      end
+
+      value.each do |element|
+        errors << "#{key} has invalid id: #{element.inspect}" unless valid_id?(element)
+      end
+    end
+
+    { ok: missing.empty? && errors.empty?, missing: missing, errors: errors }
+  end
+
+  # Resolve an intent directory's primary md file and validate its frontmatter.
+  # `plastic_home` is accepted for house-style parity (injectable) even though
+  # validation reads the intent dir directly.
+  def validate(intent_dir, plastic_home: File.join(Dir.home, ".plastic"))
+    md_path = File.join(intent_dir, "#{File.basename(intent_dir)}.md")
+    validate_frontmatter(parse_frontmatter(md_path))
+  end
+end

package/scripts/lib/qmd_sync.rb

@@ -0,0 +1,159 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "yaml"
+
+# QmdSync — the single place Plastic talks to QMD (intent 45a).
+#
+# Plastic computes only the Plastic-specific inputs (which store directory maps to
+# which `plastic-`prefixed collection, derived from projects.yml, plus a short
+# context description). The actual indexing is delegated to the `qmd` CLI; this
+# module never reimplements QMD's logic. QMD is optional: every public entry
+# no-ops cleanly when `qmd` is not on PATH.
+#
+# Pure and dependency-injected: all shelling-out goes through an injected
+# `runner` callable, so the whole module is unit-testable with no real binary,
+# no network, and no model downloads. The default runner shells out to `qmd`.
+module QmdSync
+  module_function
+
+  # A runner is `->(args_array) { [stdout_string, success_boolean] }`.
+  # The default invokes the real `qmd` binary.
+  def default_runner
+    lambda do |args|
+      require "open3"
+      out, _err, status = Open3.capture3("qmd", *args)
+      [out, status.success?]
+    end
+  end
+
+  # True when `qmd` is resolvable on PATH. The probe is injectable so tests do
+  # not depend on the host having qmd installed.
+  def detect(path_probe: method(:which_qmd))
+    !!path_probe.call
+  end
+
+  def which_qmd
+    ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
+      candidate = File.join(dir, "qmd")
+      File.file?(candidate) && File.executable?(candidate)
+    end
+  end
+
+  # Collection name for a store directory.
+  #   global store (<plastic_home>/store)        -> "plastic-global"
+  #   project store (<.../projects/<slug>/store) -> "plastic-<slug>"
+  # Slug is resolved from projects.yml by matching the project path; falls back
+  # to the directory's parent name when no registry match exists.
+  def collection_name(store_dir, plastic_home:)
+    store_dir = File.expand_path(store_dir)
+    global_store = File.expand_path(File.join(plastic_home, "store"))
+    return "plastic-global" if store_dir == global_store
+
+    slug = slug_for_store(store_dir, plastic_home: plastic_home)
+    "plastic-#{slug}"
+  end
+
+  # Every store Plastic knows about: the global store plus each registered
+  # project store. Returns [{collection:, dir:}, ...].
+  def enumerate_stores(plastic_home:)
+    stores = [{
+      collection: "plastic-global",
+      dir: File.expand_path(File.join(plastic_home, "store")),
+    }]
+
+    projects = load_projects(plastic_home)
+    projects.each do |slug, info|
+      path = info.is_a?(Hash) ? info["path"] : nil
+      next unless path
+      project_store = File.join(File.expand_path(path), "store")
+      # Project stores live under ~/.plastic/projects/<slug>/store as the mirror;
+      # registry `path` is the project code dir, so the tactical store is the
+      # plastic_home projects mirror.
+      mirror_store = File.expand_path(File.join(plastic_home, "projects", slug.to_s, "store"))
+      dir = Dir.exist?(mirror_store) ? mirror_store : project_store
+      stores << { collection: "plastic-#{slug}", dir: dir }
+    end
+    stores
+  end
+
+  # Register a store directory as a collection. Idempotent: re-running is safe.
+  # `qmd collection add` exits non-zero when the collection already exists, so we
+  # check the collection list first and treat an existing collection as success.
+  # No-op when qmd is absent. (`qmd context add` attaches a summary to a document
+  # path, not a collection-level description, so it is not used here.)
+  def register(collection:, dir:, runner: default_runner, detector: method(:detect))
+    return skip_result unless detector.call
+    return { ran: true, ok: true, output: "exists" } if list_collections(runner).include?(collection)
+    out, ok = runner.call(["collection", "add", dir, "--name", collection])
+    { ran: true, ok: ok, output: out.to_s.strip }
+  end
+
+  # Re-index a single collection: refresh the corpus then its embeddings.
+  # Scoped embed (-c) keeps delivery-time reindex fast. No-op when qmd absent.
+  def reindex(collection:, runner: default_runner, detector: method(:detect))
+    return skip_result unless detector.call
+    _o1, ok1 = runner.call(["update"])
+    _o2, ok2 = runner.call(["embed", "-c", collection])
+    { ran: true, ok: (ok1 && ok2) }
+  end
+
+  # Read-only status used by doctor and the session-start report line.
+  # Returns a structured hash; never mutates the index.
+  def status(plastic_home:, runner: default_runner, detector: method(:detect))
+    return { present: false } unless detector.call
+
+    expected = enumerate_stores(plastic_home: plastic_home).map { |s| s[:collection] }
+    listed = list_collections(runner)
+    missing = expected - listed
+
+    { present: true, expected: expected, registered: listed,
+      missing: missing, all_registered: missing.empty? }
+  end
+
+  # --- internals ---
+
+  def skip_result
+    { ran: false, ok: true, skipped: true }
+  end
+
+  def list_collections(runner)
+    out, ok = runner.call(["collection", "list"])
+    return [] unless ok && out
+    # qmd prints lines like "plastic-global (qmd://plastic-global/)"; pull the
+    # leading collection token off each non-indented line.
+    out.lines.filter_map do |line|
+      next if line.start_with?(" ", "\t")
+      m = line.strip.match(/\A([A-Za-z0-9][\w.-]*)\b/)
+      m && m[1]
+    end.reject { |t| %w[Collections No].include?(t) }
+  end
+
+  def load_projects(plastic_home)
+    path = File.join(plastic_home, "projects.yml")
+    return {} unless File.exist?(path)
+    data = begin
+      YAML.safe_load(File.read(path)) || {}
+    rescue StandardError
+      {}
+    end
+    projects = data.is_a?(Hash) ? data["projects"] : nil
+    projects.is_a?(Hash) ? projects : {}
+  end
+
+  def slug_for_store(store_dir, plastic_home:)
+    projects = load_projects(plastic_home)
+    projects.each do |slug, info|
+      path = info.is_a?(Hash) ? info["path"] : nil
+      next unless path
+      project_root = File.expand_path(path)
+      mirror = File.expand_path(File.join(plastic_home, "projects", slug.to_s, "store"))
+      return slug.to_s if store_dir == File.join(project_root, "store") || store_dir == mirror
+    end
+    # Fallback: <...>/projects/<slug>/store -> slug, else parent dir name.
+    parts = store_dir.split(File::SEPARATOR)
+    idx = parts.rindex("projects")
+    return parts[idx + 1] if idx && parts[idx + 1] && parts[idx + 2] == "store"
+    File.basename(File.dirname(store_dir))
+  end
+end

package/scripts/lib/store_provisioning.rb

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+
+# StoreProvisioning — the single source of truth for creating a registered
+# project's intent store (intent 61).
+#
+# A project can be registered in `projects.yml` yet have no store on disk. This
+# module deterministically and idempotently provisions that store at
+# `~/.plastic/projects/{slug}/store`: it makes the store directory, then writes,
+# only if missing, `.gitkeep`, `INDEX.md` (from templates/index.md), and
+# `project.yml` (from templates/project.yml). Re-running never clobbers existing
+# files. The logic was migrated here from the orphaned
+# `InstallerCore#bootstrap_project_store` so there is one definition that the
+# `provision-project-store` CLI, the `plastic-add-project-store` skill, the
+# doctor fix hint, and the project skills all consult.
+#
+# Pure filesystem and dependency-injected: `provision` accepts an injectable
+# `plastic_home` and `package_root` (so templates resolve from a known root and
+# tests stay hermetic), uses no `eval`, performs no qmd mutation, no `system`
+# or `spawn`, no network, and no global-constant injection. An unknown or
+# unregistered slug creates nothing and returns an error result.
+module StoreProvisioning
+  module_function
+
+  # Repo root resolved from this file's location (scripts/lib/), so templates
+  # resolve at package_root/templates/...; tests can inject a fake package_root.
+  PACKAGE_ROOT = File.expand_path("../..", __dir__)
+
+  # Provision the store for a registered project.
+  #
+  # Returns a result hash mirroring IntentValidator.validate's hash style:
+  #   { ok: true, store_dir: "...", created: [paths written this run] }
+  #   { ok: false, error: "..." }                (nothing is created)
+  def provision(slug, plastic_home: File.join(Dir.home, ".plastic"),
+                package_root: PACKAGE_ROOT)
+    unless registered?(slug, plastic_home)
+      return {
+        ok: false,
+        error: "project '#{slug}' is not registered in projects.yml; " \
+               "provisioning requires the project to already be registered",
+      }
+    end
+
+    project_dir = File.join(plastic_home, "projects", slug)
+    store_dir = File.join(project_dir, "store")
+    FileUtils.mkdir_p(store_dir)
+
+    created = []
+    created << write_if_missing(File.join(store_dir, ".gitkeep"), "")
+
+    index_template = File.join(package_root, "templates", "index.md")
+    if File.exist?(index_template)
+      created << write_if_missing(File.join(project_dir, "INDEX.md"),
+                                  File.read(index_template))
+    end
+
+    project_template = File.join(package_root, "templates", "project.yml")
+    if File.exist?(project_template)
+      created << write_if_missing(File.join(project_dir, "project.yml"),
+                                  File.read(project_template))
+    end
+
+    { ok: true, store_dir: store_dir, created: created.compact }
+  end
+
+  # True iff `slug` is a key under the `projects` mapping in projects.yml.
+  # Reads with a rescue-to-safe-default reader so a malformed file never raises.
+  def registered?(slug, plastic_home)
+    projects = load_projects(plastic_home)
+    projects.is_a?(Hash) && projects.key?(slug)
+  end
+
+  # Parse projects.yml -> the `projects` Hash, or {} on any error/absence.
+  # Mirrors QmdSync#load_projects (scripts/lib/qmd_sync.rb).
+  def load_projects(plastic_home)
+    path = File.join(plastic_home, "projects.yml")
+    return {} unless File.exist?(path)
+
+    data = begin
+      YAML.safe_load(File.read(path)) || {}
+    rescue StandardError
+      {}
+    end
+    projects = data.is_a?(Hash) ? data["projects"] : nil
+    projects.is_a?(Hash) ? projects : {}
+  end
+
+  # Write `content` to `path` only when `path` does not exist. Returns the path
+  # when a file was written, or nil when the file already existed (so callers
+  # can build a `created` list). Copied from InstallerCore#write_if_missing.
+  def write_if_missing(path, content)
+    return nil if File.exist?(path)
+
+    File.write(path, content)
+    path
+  end
+end

package/scripts/migrate-to-global

@@ -17,7 +17,7 @@ GLOBAL_ROOT="$HOME/.plastic"
 LOCAL_PLASTIC="$PROJECT_PATH/.plastic"
 
 if [ ! -d "$GLOBAL_ROOT" ]; then
-  echo "Error: Global Plastic not installed. Run /plastic:install first." >&2
+  echo "Error: Global Plastic not installed. Run /plastic-install first." >&2
   exit 1
 fi
 

package/scripts/provision-project-store

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# provision-project-store — deterministic CLI over StoreProvisioning (intent 61).
+#
+# Creates a registered project's store at ~/.plastic/projects/{slug}/store: it
+# makes the store directory, then writes, only if missing, .gitkeep, INDEX.md,
+# and project.yml. It is pure filesystem and idempotent, so re-running never
+# clobbers existing files and performs no qmd mutation. The project must already
+# be registered in projects.yml; an unregistered slug exits non-zero and creates
+# nothing.
+#
+# Usage:
+#   provision-project-store <slug> [--home <path>]
+#
+# Exit codes: 0 (store provisioned), 1 (unregistered slug / error on stderr),
+# 2 (usage). --home <path> overrides the Plastic home (default: ~/.plastic).
+
+require_relative "lib/store_provisioning"
+
+def plastic_home(args)
+  if (i = args.index("--home")) && args[i + 1]
+    File.expand_path(args[i + 1])
+  else
+    File.expand_path(ENV["PLASTIC_HOME"] || "~/.plastic")
+  end
+end
+
+home = plastic_home(ARGV)
+
+# First positional arg, skipping any flag and the value that follows --home.
+home_value_index = (i = ARGV.index("--home")) ? i + 1 : nil
+slug_index = ARGV.each_index.find do |idx|
+  arg = ARGV[idx]
+  !arg.start_with?("--") && idx != home_value_index
+end
+slug = slug_index && ARGV[slug_index]
+
+if slug.nil?
+  warn "usage: provision-project-store <slug> [--home <path>]"
+  exit 2
+end
+
+result = StoreProvisioning.provision(slug, plastic_home: home)
+
+if result[:ok]
+  puts "OK: #{result[:store_dir]}"
+  exit 0
+end
+
+warn result[:error]
+exit 1

package/scripts/qmd-sync

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# qmd-sync — deterministic CLI over QmdSync (intent 45a).
+#
+# Plastic skills and hooks call these verbs instead of assembling `qmd` commands
+# themselves. QMD is optional: when `qmd` is absent every verb exits 0 and prints
+# a skip notice, so callers can invoke unconditionally.
+#
+# Usage:
+#   qmd-sync detect                     # exit 0 if qmd present, 1 if absent
+#   qmd-sync register --store <dir>     # register one store as a collection
+#   qmd-sync register --all             # register the global store + all projects
+#   qmd-sync reindex --store <dir>      # update + embed that store's collection
+#   qmd-sync status [--format json]     # read-only status
+#
+# --home <path> overrides the Plastic home (default: ~/.plastic).
+
+require "json"
+require_relative "lib/qmd_sync"
+
+def plastic_home(args)
+  if (i = args.index("--home")) && args[i + 1]
+    File.expand_path(args[i + 1])
+  else
+    File.expand_path(ENV["PLASTIC_HOME"] || "~/.plastic")
+  end
+end
+
+def opt(args, name)
+  (i = args.index(name)) && args[i + 1]
+end
+
+verb = ARGV.shift
+home = plastic_home(ARGV)
+
+unless QmdSync.detect
+  case verb
+  when "detect"
+    warn "QMD not detected on PATH."
+    exit 1
+  else
+    puts "QMD not detected; skipped (#{verb})."
+    exit 0
+  end
+end
+
+case verb
+when "detect"
+  puts "QMD detected."
+  exit 0
+
+when "register"
+  stores =
+    if ARGV.include?("--all")
+      QmdSync.enumerate_stores(plastic_home: home)
+    elsif (dir = opt(ARGV, "--store"))
+      [{ collection: QmdSync.collection_name(dir, plastic_home: home), dir: File.expand_path(dir) }]
+    else
+      warn "register: pass --store <dir> or --all"
+      exit 2
+    end
+  stores.each do |s|
+    next unless Dir.exist?(s[:dir])
+    res = QmdSync.register(collection: s[:collection], dir: s[:dir])
+    puts "registered #{s[:collection]} -> #{s[:dir]} (#{res[:ok] ? "ok" : "warn"})"
+  end
+  exit 0
+
+when "reindex"
+  dir = opt(ARGV, "--store") or (warn("reindex: pass --store <dir>"); exit 2)
+  collection = QmdSync.collection_name(dir, plastic_home: home)
+  res = QmdSync.reindex(collection: collection)
+  puts "reindexed #{collection} (#{res[:ok] ? "ok" : "warn"})"
+  exit 0
+
+when "status"
+  st = QmdSync.status(plastic_home: home)
+  if opt(ARGV, "--format") == "json"
+    puts JSON.generate(st)
+  else
+    puts "QMD present: #{st[:present]}"
+    puts "registered: #{Array(st[:registered]).join(", ")}"
+    puts "missing: #{Array(st[:missing]).join(", ")}" unless Array(st[:missing]).empty?
+  end
+  exit 0
+
+else
+  warn "qmd-sync: unknown verb #{verb.inspect}. Use detect|register|reindex|status."
+  exit 2
+end

package/scripts/select-update-target

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+# plastic-script-version: 1.0.0
+# Channel-aware update target selector.
+#
+# Usage: npm view @zalom/plastic dist-tags --json | select-update-target <current-version>
+#
+# Prints the best update target to stdout, or nothing if already up to date.
+#
+# Rule: target = the highest version, among the dist-tags reachable from the
+# installed channel, that is strictly greater than the installed version (semver).
+#   alpha installed  -> reachable: alpha, beta, latest
+#   beta installed   -> reachable: beta, latest   (never downgrade to alpha)
+#   stable installed -> reachable: latest         (stable only)
+# A prerelease (1.1.0-alpha.1) is LOWER than its release (1.1.0); the `latest`
+# placeholder (0.0.1) is naturally excluded as lower than any 1.0.0-alpha.N.
+
+require "json"
+
+# Parse "MAJOR.MINOR.PATCH[-prerelease]" into a comparable structure.
+# Returns nil for anything that isn't a clean semver string.
+def parse(version)
+  m = /\A(\d+)\.(\d+)\.(\d+)(?:-(.+))?\z/.match(version.to_s.strip)
+  return nil unless m
+  { maj: m[1].to_i, min: m[2].to_i, pat: m[3].to_i,
+    pre: m[4] ? m[4].split(".") : nil }
+end
+
+# Semver precedence (§11). Returns -1, 0, or 1.
+def compare(a, b)
+  %i[maj min pat].each do |k|
+    return a[k] <=> b[k] unless a[k] == b[k]
+  end
+  # A version with no prerelease is greater than one with a prerelease.
+  return 0 if a[:pre].nil? && b[:pre].nil?
+  return 1 if a[:pre].nil?
+  return -1 if b[:pre].nil?
+  [a[:pre].length, b[:pre].length].max.times do |i|
+    x = a[:pre][i]
+    y = b[:pre][i]
+    return -1 if x.nil?
+    return 1 if y.nil?
+    xn = x.match?(/\A\d+\z/)
+    yn = y.match?(/\A\d+\z/)
+    if xn && yn
+      return x.to_i <=> y.to_i unless x.to_i == y.to_i
+    elsif xn
+      return -1 # numeric identifiers rank lower than alphanumeric
+    elsif yn
+      return 1
+    elsif x != y
+      return x <=> y
+    end
+  end
+  0
+end
+
+def channel(version)
+  return "alpha" if version.include?("-alpha")
+  return "beta" if version.include?("-beta")
+  "stable"
+end
+
+REACH = {
+  "alpha"  => %w[alpha beta latest],
+  "beta"   => %w[beta latest],
+  "stable" => %w[latest],
+}.freeze
+
+current = ARGV[0]
+cur = parse(current)
+exit 0 unless cur
+
+begin
+  tags = JSON.parse($stdin.read)
+rescue JSON::ParserError, StandardError
+  exit 0
+end
+exit 0 unless tags.is_a?(Hash)
+
+best = nil
+best_parsed = nil
+REACH[channel(current)].each do |tag|
+  raw = tags[tag]
+  next unless raw
+  parsed = parse(raw)
+  next unless parsed
+  if compare(parsed, cur) > 0 && (best_parsed.nil? || compare(parsed, best_parsed) > 0)
+    best = raw
+    best_parsed = parsed
+  end
+end
+
+print best if best

package/scripts/uninstall.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Plastic — `uninstall` verb. Runs via `npx @zalom/plastic uninstall` (bin/plastic.js) or directly.
+# Usage: ruby scripts/uninstall.rb [--claude|--codex|--hermes|--all] [--help]
+#
+# Manifest-driven removal of installed files + legacy-plugin migration. Leaves ~/.plastic/
+# (intent store, config, and the versions.json ledger) in place — the ledger is permanent.
+
+require_relative "lib/installer_core"
+
+class Uninstall < InstallerCore
+  def cli(argv = ARGV)
+    if argv.include?("--help") || argv.include?("-h")
+      show_help
+      return 0
+    end
+
+    selected = agent_keys_from(argv)
+    selected = ["claude"] if selected.empty?
+
+    puts "\n\u{1f9e0} Plastic v#{version} — uninstall\n\n"
+    handle_uninstall(selected)
+    0
+  end
+
+  private
+
+  def show_help
+    puts <<~HELP
+
+      plastic uninstall — remove Plastic from an agent
+
+      Usage:
+        npx @zalom/plastic uninstall [options]
+
+      Agent options:
+        --claude      Uninstall from Claude Code (default)
+        --codex       Uninstall from Codex CLI
+        --hermes      Uninstall from Hermes
+        --all         Uninstall from all supported agents
+
+      Other options:
+        -h, --help    Show this help
+
+      Leaves your intent store, config, and version ledger (~/.plastic/) in place.
+
+    HELP
+  end
+end
+
+exit(Uninstall.new(package_root: ENV["PLASTIC_PACKAGE_ROOT"] || File.expand_path("..", __dir__)).cli(ARGV)) if $PROGRAM_NAME == __FILE__