asgard 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fd4fe5903f93e062c0f515b3f6a49b859671c679b066003c04f2012eaf7176c
-  data.tar.gz: 5af1e1b65fc854258a68ec98a220d8260720474d9d84a7644cecec2fc054889f
+  metadata.gz: a1c6d1f87eea50ba02ac92aff8d7822f9106a7a99afa5ff5c44c7faa7b5e9c87
+  data.tar.gz: dcd334548a5a8d67688cd139482d6a0a3a3ce77c0aa59b2515e81d568849356f
 SHA512:
-  metadata.gz: eb251bfc200af2b94dc66e6247475f2a4c0d2a474d0f1d4b165caf05250c8dbb55bd31295b2c0b7e963aeace88f2b8f2c2ecb8751271a522ea5c7a99486bccfe
-  data.tar.gz: c2540f86218ca5fe471ca276081d23224b2bf4f5784862915bf69f21c83acf664ef57f051bb4587a7104d0bb0bf82e768f28acc9b5f3e2cc32d15eac902dbf94
+  metadata.gz: b45b01bc870415ee36a931278c88ed251c8723a36e7795c6a36d0a142ce5a93822db91e96a099045ef5d35137cd86bc2ce571a37faea7b93818de94be78daca1
+  data.tar.gz: 837ab94dabc90b119831d2effc0c4dba00b55fc5a7cd1221d4cc16799f4376985a4dc5150673ca1e5910d6f1932a04d8782d6a87c6883342b312836e921dc40b

data/CHANGELOG.md

@@ -5,6 +5,46 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.1] - 2026-10-02
+
+### Added
+
+- **`asgard schedule list --all` (`-a`)** — lists every project's scheduled
+  entries, one table per project under a
+  `Project: name (/full/path/to/project)` header. Other projects' `.loki`
+  files are not loaded: their COMMAND and SCHEDULE columns, and the project
+  path, are read back from the installed launchd plist or systemd unit files.
+  Outside any `.loki` tree, `asgard schedule list` shows every project
+  automatically instead of failing with "no .loki file found".
+- **`stop`, `start`, `trigger` and `log` accept entries of other projects**, so
+  they work from any directory. A bare name matches this project's entry first,
+  then any other project's; when two other projects share a name, write it as
+  `project/name`.
+- A project-scoped `list` with nothing installed now ends with
+  "Use `asgard schedule list --all` to see all currently scheduled tasks."
+- Backend API: `installed_entries` (every project's entries),
+  `installed_columns(name)` and `installed_directory(name)` (read from the job
+  files) on both the launchd and systemd backends.
+- Runtime dependency: `tty-table` (~> 0.12), which brings `pastel` and
+  `tty-screen`.
+
+### Changed
+
+- **`asgard schedule list` prints a table** — NAME, COMMAND, SCHEDULE, STATE and
+  LAST EXIT, with long cells wrapped to the terminal width, replacing one text
+  line per entry. A run of hourly times collapses
+  (`10:00-17:00 hourly weekdays`). Color is used on a terminal and turned off
+  by `NO_COLOR` or when piped.
+- The not-installed messages from `stop`, `start`, `trigger` and `log` point at
+  `asgard schedule list --all`.
+
+### Fixed
+
+- Scheduled entries were invisible outside the directory tree of the project
+  that installed them: `list` and every per-entry command were scoped to the
+  project found from the current directory, so `launchctl list` showed jobs
+  that `asgard schedule list` did not.
+
 ## [0.4.0] - 2026-09-26
 
 ### Added

data/README.md

@@ -626,7 +626,7 @@ Then manage them with the built-in `schedule` command:
 ```bash
 asgard schedule preview        # job files install would write
 asgard schedule install        # load declared entries; drop undeclared ones
-asgard schedule list           # installed entries, state, last exit status
+asgard schedule list           # this project's entries, state, last exit (--all: every project's)
 asgard schedule stop NAME      # stop one entry (persists across reboots and installs)
 asgard schedule start NAME     # start a stopped entry, or install just this one
 asgard schedule trigger NAME   # run an installed entry now
@@ -634,6 +634,9 @@ asgard schedule log NAME [-f]  # print (or follow) the entry's log
 asgard schedule remove         # remove all of this project's entries
 ```
 
+`stop`, `start`, `trigger` and `log` also take an entry of another project
+(`list --all` shows them); write `project/name` when two projects share a name.
+
 Jobs run `asgard <task> [options]` from the directory holding `.loki`, with
 the `PATH` captured at install time; a project `.envrc` is loaded at run time
 through `direnv exec`. See [Scheduled Tasks](https://madbomber.github.io/asgard/schedule/)

data/docs/schedule.md

@@ -65,7 +65,7 @@ end
 ```bash
 asgard schedule preview        # print the job files install would write
 asgard schedule install        # load declared entries; drop entries no longer declared
-asgard schedule list           # installed entries, schedule, state, last exit status
+asgard schedule list           # this project's entries, state, last exit (--all: every project's)
 asgard schedule stop NAME      # stop one entry (stays stopped across reboots and installs)
 asgard schedule start NAME     # start a stopped entry, or install just this one
 asgard schedule trigger NAME   # run an installed entry now, under the scheduler
@@ -73,6 +73,11 @@ asgard schedule log NAME [-f]  # print the entry's log (-f keeps following it)
 asgard schedule remove         # unload and delete all of this project's entries
 ```
 
+`stop`, `start`, `trigger` and `log` also accept an entry of another project, so
+they work from any directory. Use the name shown by `list --all`; if two projects
+have an entry with the same name, write it as `project/name` (this project's own
+entry wins a bare name).
+
 Re-run `asgard schedule install` after changing declarations or your `PATH`.
 
 ---

data/lib/asgard/schedule/commands.rb

@@ -54,6 +54,11 @@ module Asgard
 
         def schedule_summary(spec) = "#{Schedule.command_line(spec[:task], spec[:args])} (#{Schedule.describe(**spec)})"
 
+        # One `list` row for this project: its declaration (if still declared) plus live state.
+        def schedule_row(name)
+          { name:, **Schedule.declared_columns(schedules[name], "no longer declared"), **Schedule.live_columns(scheduler, name) }
+        end
+
         def schedule_install(spec, asgard:, direnv:)
           name  = spec[:name]
           state = scheduler.install(spec, asgard:, direnv:)
@@ -65,16 +70,6 @@ module Asgard
           scheduler.uninstall(name)
           puts "removed #{name}"
         end
-
-        def require_installed!(name)
-          abort "#{name} is not installed (see `asgard schedule list`)." unless scheduler.installed_names.include?(name)
-        end
-
-        def require_known!(name)
-          return if schedules.key?(name) || scheduler.installed_names.include?(name)
-
-          abort "#{name} is neither declared nor installed (see `asgard schedule list`)."
-        end
       end
 
       desc "preview", "Show the job files install would write, without installing them"
@@ -100,61 +95,132 @@ module Asgard
         scheduler.notes.each { |note| $stderr.puts note }
       end
 
+      no_commands do
+        # [backend, entry name] for an installed entry of this or any project: a
+        # bare name, or project/name when several projects use the same one. nil if none.
+        def find_installed(name)
+          return [scheduler, name] if scheduler.installed_names.include?(name)
+
+          project, entry = name.include?("/") ? name.split("/", 2) : [nil, name]
+          matches = scheduler.installed_entries.select { |slug, found| found == entry && (project.nil? || slug == project) }
+          abort "#{name} is in several projects (#{matches.map(&:first).join(', ')}); name one as project/#{entry}." if matches.size > 1
+
+          matches.first&.then { |slug, found| [backend_for(slug), found] }
+        end
+
+        def resolve_installed(name) = find_installed(name) || abort("#{name} is not installed (see `asgard schedule list --all`).")
+
+        # Like resolve_installed, but a declared entry of this project counts even before it is installed.
+        def resolve_known(name)
+          return [scheduler, name] if schedules.key?(name)
+
+          find_installed(name) || abort("#{name} is neither declared nor installed (see `asgard schedule list --all`).")
+        end
+
+        # True when list should cover every project: asked for with --all, or
+        # there is no .loki here, so no single project to scope to.
+        def list_all? = options[:all] || Asgard.find_task_file.nil?
+
+        # What `list` says when there is nothing to show; a project-scoped list
+        # also tells the user how to look further.
+        def no_schedules_message
+          backend = scheduler.scheduler
+          return "No scheduled tasks installed (#{backend})." if list_all?
+
+          "No scheduled tasks installed for #{schedule_project} (#{backend}).\n" \
+            "Use `asgard schedule list --all` to see all currently scheduled tasks."
+        end
+
+        # The rows to list, grouped under a project title: { "Project: name (/path)" => [row, ...] }
+        # for every project, or { nil => [row, ...] } for this one. Empty groups drop out.
+        def list_groups
+          groups = list_all? ? all_schedule_groups : { nil => scheduler.installed_names.map { |name| schedule_row(name) } }
+          groups.reject { |_, rows| rows.empty? }
+        end
+
+        # Every installed entry on the machine, grouped by project.
+        def all_schedule_groups
+          by_project = scheduler.installed_entries.group_by(&:first)
+          by_project.to_h { |slug, entries| [project_title(slug, entries.first.last), entry_rows(entries)] }
+        end
+
+        # "Project: slug (/full/path)", the path read from one of the project's job files.
+        def project_title(slug, name)
+          dir = slug == current_slug ? schedule_root : backend_for(slug).installed_directory(name)
+          ["Project: #{slug}", ("(#{dir})" if dir)].compact.join(" ")
+        end
+
+        def current_slug = Asgard.find_task_file && Schedule.slug(schedule_project)
+
+        def backend_for(slug) = Schedule.backend_class.new(project: slug, root: schedule_root)
+
+        def entry_rows(entries) = entries.map { |slug, name| entry_row(slug, name) }
+
+        # This project's entries keep their declaration columns; see other_project_row.
+        def entry_row(slug, name)
+          return schedule_row(name) if slug == current_slug
+
+          other_project_row(slug, name)
+        end
+
+        # A row for an entry of another project: its .loki isn't loaded, so the
+        # command and schedule are read back from the installed job files.
+        def other_project_row(slug, name)
+          backend = backend_for(slug)
+          shown   = backend.installed_columns(name) || Schedule.declared_columns(nil, "(unreadable)")
+          { name:, **shown, **Schedule.live_columns(backend, name) }
+        end
+      end
+
       desc "list", "Show this project's installed entries, their state, and last exit status"
+      method_option :all, aliases: "-a", type: :boolean, desc: "List every project's entries, not just this one's"
       def list
-        names = scheduler.installed_names
-        return puts "No scheduled tasks installed for #{schedule_project} (#{scheduler.scheduler})." if names.empty?
-
-        names.each do |name|
-          status = scheduler.status(name)
-          state  = case status[:state]
-                   when :active  then "active; last exit: #{status[:last_exit] || 'never run'}"
-                   when :stopped then "stopped"
-                   else "not loaded"
-                   end
-          spec   = schedules[name]
-          timing = spec ? schedule_summary(spec) : "no longer declared"
-          puts "#{name}  #{timing}  [#{state}]  log: #{scheduler.log_path(name)}"
-        end
+        groups = list_groups
+        return puts(no_schedules_message) if groups.empty?
+
+        puts groups.map { |title, rows| Schedule::Table.draw(rows, title:) }.join("\n\n")
+        puts "\nLogs: #{File.dirname(scheduler.log_path(groups.values.first.first[:name]))}  (asgard schedule log NAME)"
       end
 
       desc "stop NAME", "Stop one scheduled entry; it stays stopped across reboots and installs until started"
       def stop(name)
-        require_installed!(name)
-        scheduler.stop(name)
+        backend, entry = resolve_installed(name)
+        backend.stop(entry)
         puts "stopped #{name}"
       end
 
       desc "start NAME", "Start a stopped entry, or install and start just this declared entry"
       def start(name)
-        require_known!(name)
-        spec = schedules[name]
+        backend, entry = resolve_known(name)
+        own  = backend.equal?(scheduler)
+        spec = schedules[entry] if own
 
         if spec
           declared_schedules # validates the task exists
           scheduler.install(spec, asgard: schedule_asgard, direnv: schedule_direnv) # refresh the job files
         else
-          $stderr.puts "schedule: #{name} is no longer declared; starting its installed job as-is"
+          why = own ? "is no longer declared" : "belongs to another project"
+          $stderr.puts "schedule: #{name} #{why}; starting its installed job as-is"
         end
-        scheduler.start(name)
+        backend.start(entry)
         puts "started #{name}"
       end
 
       desc "trigger NAME", "Run an installed entry now, under the scheduler's environment"
       def trigger(name)
-        require_installed!(name)
-        abort "#{name} is stopped; `asgard schedule start #{name}` first." if scheduler.status(name)[:state] == :stopped
+        backend, entry = resolve_installed(name)
+        abort "#{name} is stopped; `asgard schedule start #{name}` first." if backend.status(entry)[:state] == :stopped
 
-        scheduler.trigger(name)
-        puts "triggered #{name}; output goes to #{scheduler.log_path(name)}"
+        backend.trigger(entry)
+        puts "triggered #{name}; output goes to #{backend.log_path(entry)}"
       end
 
       desc "log NAME", "Print the named entry's log file to STDOUT"
       method_option :follow, aliases: "-f", type: :boolean, desc: "Keep printing new output as it arrives (tail -f)"
       def log(name)
-        require_known!(name)
+        backend, entry = resolve_known(name)
 
-        path = scheduler.log_path(name)
+        path = backend.log_path(entry)
         return $stderr.puts "#{name} has no log yet (#{path}); it is created on the first run." unless File.exist?(path)
         return sh("tail -n +1 -f #{path.shellescape}", silent: true, exec: true) if options[:follow]
 

data/lib/asgard/schedule/declaration.rb

@@ -24,6 +24,9 @@ module Asgard
   #   #start(name) / #stop(name)          # stop persists across reboots and reinstalls
   #   #trigger(name)                      # run once now, under the scheduler
   #   #installed_names                    # => ["demo", ...] for this project
+  #   #installed_entries                  # => [[project_slug, "demo"], ...] for every project
+  #   #installed_columns(name)            # => { command:, schedule: } read back from the job files, or nil
+  #   #installed_directory(name)          # => the project root the job runs in, or nil
   #   #status(name)                       # => { state: :active|:stopped|:not_loaded, last_exit: String|nil }
   #   #log_path(name)                     # => path the job's output is appended to
   #   #notes                              # => [String] platform hints to show after install
@@ -121,6 +124,64 @@ module Asgard
       "#{Array(at).join(', ')} #{Array(on).join(', ')}"
     end
 
+    # For the `list` table: like describe, but a run of hourly times
+    # collapses ("10:00, 11:00 ... 17:00" => "10:00-17:00 hourly").
+    def describe_compact(at: nil, on: :daily, every: nil, **)
+      return "every #{every}s" if every
+
+      "#{compact_times(Array(at))} #{Array(on).join(', ')}"
+    end
+
+    # The command and schedule columns of a `list` row for a declared entry.
+    def list_columns(spec) = { command: command_line(spec[:task], spec[:args]), schedule: describe_compact(**spec) }
+
+    # The command and schedule columns of a `list` row: the declaration's, or
+    # `missing` in the schedule column when there is none.
+    def declared_columns(spec, missing) = spec ? list_columns(spec) : { command: "-", schedule: missing }
+
+    # The state and last-exit columns of a `list` row, from a backend's live status.
+    def live_columns(backend, name)
+      state, last_exit = backend.status(name).values_at(:state, :last_exit)
+      { state: state.to_s.tr("_", " "), last_exit: state == :active ? (last_exit || "never run") : "-" }
+    end
+
+    # The command a job runs, from its program arguments: everything from
+    # `asgard` on, so a direnv wrapper and the asgard install path drop out.
+    def command_from_arguments(arguments)
+      start = arguments.index { |word| File.basename(word) == "asgard" }
+      Shellwords.join(["asgard", *arguments.drop(start ? start + 1 : 0)])
+    end
+
+    # describe_compact for calendar entries (the shape `calendar` returns), one
+    # group per distinct set of days: "17:30 weekdays; 09:00 saturday".
+    def describe_calendar(entries)
+      entries.group_by { |entry| entry[:days]&.sort }.map { |days, group| describe_days(days, group) }.join("; ")
+    end
+
+    def describe_days(days, group)
+      describe_compact(at: group.map { |entry| format("%<hour>02d:%<minute>02d", entry) }, on: day_names(days))
+    end
+
+    # The command and schedule columns for a job read back from its files.
+    def installed_columns(arguments:, calendar:, every:)
+      { command: command_from_arguments(arguments), schedule: every ? "every #{every}s" : describe_calendar(calendar) }
+    end
+
+    # Weekday numbers back to what on: took: nil => :daily, [1, 2, 3, 4, 5] => :weekdays, [5] => [:friday].
+    def day_names(days)
+      return :daily unless days
+
+      names = days.map { |day| DAYS.fetch(day) }
+      DAY_GROUPS.key(names) || names
+    end
+
+    def compact_times(times)
+      parsed = times.map { |time| parse_time(time) }
+      hourly = parsed.size >= 3 && parsed.map(&:last).uniq.size == 1 &&
+               parsed.each_cons(2).all? { |(hour, _), (next_hour, _)| next_hour == hour + 1 }
+      hourly ? "#{times.first}-#{times.last} hourly" : times.join(", ")
+    end
+
     # "17:30" => [17, 30]
     def parse_time(time)
       shown = time.inspect

data/lib/asgard/schedule/launchd.rb

@@ -64,6 +64,40 @@ module Asgard
         end
       end
 
+      # The parts of a plist (as `plist` writes it) that say what runs and when:
+      # { arguments: [String], calendar: [{ hour:, minute:, days: [Integer]|nil }], every: Integer|nil }
+      def self.parse_plist(xml)
+        {
+          arguments: array_body(xml, "ProgramArguments").scan(%r{<string>(.*?)</string>}m).flatten.map { |text| unescape(text) },
+          calendar:  calendar_entries(array_body(xml, "StartCalendarInterval").scan(%r{<dict>(.*?)</dict>}m).flatten),
+          every:     xml[%r{<key>StartInterval</key>\s*<integer>(\d+)</integer>}, 1]&.to_i
+        }
+      end
+
+      # StartCalendarInterval dict bodies => one entry per time, days collected.
+      def self.calendar_entries(dicts)
+        dicts.map { |body| parse_dict(body) }
+             .group_by { |dict| dict.values_at("Hour", "Minute") }
+             .map { |(hour, minute), group| calendar_entry(hour, minute, group) }
+      end
+
+      # <key>Hour</key><integer>13</integer>... => { "Hour" => 13, ... }
+      def self.parse_dict(body) = body.scan(%r{<key>(\w+)</key>\s*<integer>(\d+)</integer>}).to_h { |key, num| [key, num.to_i] }
+
+      # group: the Weekday-bearing dicts for one time; days is nil when there are none (every day).
+      def self.calendar_entry(hour, minute, group)
+        days = group.filter_map { |dict| dict["Weekday"] }
+        { hour:, minute:, days: days.empty? ? nil : days }
+      end
+
+      # The text inside the <array> that follows <key>key</key>.
+      def self.array_body(xml, key) = xml[%r{<key>#{key}</key>\s*<array>(.*?)</array>}m, 1].to_s
+
+      # The WorkingDirectory (the project root) of a plist, or nil.
+      def self.parse_directory(xml) = xml[%r{<key>WorkingDirectory</key>\s*<string>(.*?)</string>}m, 1]&.then { |text| unescape(text) }
+
+      def self.unescape(text) = text.gsub("&lt;", "<").gsub("&gt;", ">").gsub("&amp;", "&")
+
       def self.escape(text) = text.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
 
       # ---- backend API ------------------------------------------------------
@@ -136,6 +170,27 @@ module Asgard
         Dir.glob(plist_path("*")).map { |path| File.basename(path, ".plist").delete_prefix(prefix) }.sort
       end
 
+      # Every asgard entry on this machine, whatever its project: [[project_slug, name], ...].
+      def installed_entries
+        paths = Dir.glob(File.join(@home, "Library", "LaunchAgents", "#{LABEL_PREFIX}.*.plist"))
+        paths.map { |path| File.basename(path, ".plist").delete_prefix("#{LABEL_PREFIX}.").split(".", 2) }
+             .select { |entry| entry.size == 2 }.sort
+      end
+
+      # { command:, schedule: } as installed, read from the plist; nil when there isn't one.
+      def installed_columns(name)
+        path = plist_path(name)
+        return unless File.exist?(path)
+
+        Schedule.installed_columns(**self.class.parse_plist(File.read(path)))
+      end
+
+      # The project root the job runs in, read from the plist; nil when there isn't one.
+      def installed_directory(name)
+        path = plist_path(name)
+        self.class.parse_directory(File.read(path)) if File.exist?(path)
+      end
+
       def status(name)
         out, ok = run("launchctl", "print", target(name))
         return { state: stopped?(name) ? :stopped : :not_loaded, last_exit: nil } unless ok

data/lib/asgard/schedule/systemd.rb

@@ -76,6 +76,30 @@ module Asgard
         UNIT
       end
 
+      # ExecStart= words, undoing `quote`.
+      def self.parse_exec_start(service)
+        line = service[/^ExecStart=(.*)$/, 1].to_s
+        line.scan(/"((?:[^"\\]|\\.)*)"/).flatten.map { |word| word.gsub(/\\(.)/, '\1').gsub("$$", "$").gsub("%%", "%") }
+      end
+
+      # "Mon,Fri *-*-* 17:30:00" => { hour: 17, minute: 30, days: [1, 5] }
+      def self.parse_on_calendar(text)
+        days = text[/\A([A-Z][a-z]{2}(?:,[A-Z][a-z]{2})*) /, 1]
+        hour, minute = text.scan(/(\d+):(\d+)/).first.map(&:to_i)
+        { hour:, minute:, days: days&.split(",")&.map { |abbr| DAY_ABBREVIATIONS.index(abbr) } }
+      end
+
+      # The WorkingDirectory= (the project root) of a service unit, or nil.
+      def self.parse_directory(service) = service[/^WorkingDirectory=(.*)$/, 1]&.gsub("%%", "%")
+
+      # { calendar: [entry], every: Integer|nil } from a timer unit.
+      def self.parse_timer(timer)
+        {
+          calendar: timer.scan(/^OnCalendar=(.*)$/).flatten.map { |text| parse_on_calendar(text) },
+          every:    timer[/^OnUnitActiveSec=(\d+)/, 1]&.to_i
+        }
+      end
+
       # `systemctl show -p A -p B` output => { "A" => "...", "B" => "..." }
       def self.parse_show(output) = output.lines.to_h { |line| line.chomp.split("=", 2) }.reject { |k, _| k.to_s.empty? }
 
@@ -156,6 +180,29 @@ module Asgard
         Dir.glob(timer_path("*")).map { |path| File.basename(path, ".timer").delete_prefix(prefix) }.sort
       end
 
+      # Every asgard entry on this machine, whatever its project: [[project_slug, name], ...].
+      def installed_entries
+        paths = Dir.glob(File.join(@config, "systemd", "user", "#{UNIT_PREFIX}.*.timer"))
+        paths.map { |path| File.basename(path, ".timer").delete_prefix("#{UNIT_PREFIX}.").split(".", 2) }
+             .select { |entry| entry.size == 2 }.sort
+      end
+
+      # { command:, schedule: } as installed, read from the unit files; nil when there are none.
+      def installed_columns(name)
+        paths = [service_path(name), timer_path(name)]
+        return unless paths.all? { |path| File.exist?(path) }
+
+        klass = self.class
+        service, timer = paths.map { |path| File.read(path) }
+        Schedule.installed_columns(arguments: klass.parse_exec_start(service), **klass.parse_timer(timer))
+      end
+
+      # The project root the job runs in, read from the service unit; nil when there isn't one.
+      def installed_directory(name)
+        path = service_path(name)
+        self.class.parse_directory(File.read(path)) if File.exist?(path)
+      end
+
       def status(name)
         _, active = systemctl("is-active", "--quiet", timer(name))
         state = if active then :active

data/lib/asgard/schedule/table.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Asgard
+  module Schedule
+    # The table `asgard schedule list` prints, drawn by tty-table. rows are
+    # hashes with :name, :command, :schedule, :state and :last_exit (strings).
+    # A cell that doesn't fit wraps onto extra lines; only COMMAND and SCHEDULE
+    # give up width, so the short columns always stay whole.
+    class Table
+      HEADERS      = ["NAME", "COMMAND", "SCHEDULE", "STATE", "LAST EXIT"].freeze
+      FLEXIBLE     = [1, 2].freeze
+      MIN_WIDTH    = 14
+      EXTRA        = 4 # a space either side of a cell, plus slack for tty-table's rounding
+      BORDERS      = HEADERS.size + 1 # one before each column and one after the last
+
+      # Columns available for output: the terminal's when io is one, else
+      # $COLUMNS, else a roomy default (piped output shouldn't wrap at 80).
+      def self.terminal_width(io = $stdout, env: ENV, default: 120)
+        return Integer(env["COLUMNS"], exception: false) || default unless io.tty?
+
+        require "tty-screen"
+        TTY::Screen.width
+      end
+
+      # rows rendered for the terminal, under title when given: colored when io
+      # is a tty and NO_COLOR is unset.
+      def self.draw(rows, title: nil, io: $stdout)
+        table = new(rows, color: io.tty? && !ENV.key?("NO_COLOR"), width: terminal_width(io)).render
+        [title, table].compact.join("\n")
+      end
+
+      # color: styles the header, state and last exit with ANSI codes.
+      def initialize(rows, color:, width:)
+        require "pastel"
+
+        @cells  = rows.map { |row| row.values_at(:name, :command, :schedule, :state, :last_exit) }
+        @pastel = Pastel.new(enabled: color)
+        @width  = width
+        @column_widths = natural_widths
+        shrink_widest while overflowing? && shrinkable?
+      end
+
+      def render
+        require "tty-table"
+
+        grid = TTY::Table.new(header: HEADERS.map { |text| @pastel.bold(text) }, rows: @cells.map { |cells| styled(cells) })
+        grid.render(:unicode, multiline: true, resize: true, width: total_width, column_widths:, padding: [0, 1]).to_s
+      end
+
+      # Width of each column, padding included. Every column starts at its
+      # natural width; when the table would be wider than the screen, the
+      # flexible columns give up a character at a time until it fits.
+      attr_reader :column_widths
+
+      # Rendered width: the columns plus their borders.
+      def total_width = column_widths.sum + BORDERS
+
+      private
+
+      def natural_widths = [HEADERS, *@cells].transpose.map { |column| column.max_by(&:length).length + EXTRA }
+
+      def overflowing? = total_width > @width
+
+      def widest_flexible = FLEXIBLE.max_by { |index| @column_widths[index] }
+
+      def shrinkable? = @column_widths[widest_flexible] > MIN_WIDTH
+
+      def shrink_widest = @column_widths[widest_flexible] -= 1
+
+      def styled(cells)
+        *lead, state, last_exit = cells
+        state_color = { "active" => :green, "stopped" => :yellow }.fetch(state, :red)
+        exit_color  = last_exit.match?(/\A[1-9]\d*\z/) ? :red : :dim
+        [*lead, @pastel.decorate(state, state_color), @pastel.decorate(last_exit, exit_color)]
+      end
+    end
+  end
+end

data/lib/asgard/schedule.rb

@@ -3,6 +3,7 @@
 require_relative "schedule/declaration"
 require_relative "schedule/launchd"
 require_relative "schedule/systemd"
+require_relative "schedule/table"
 require_relative "schedule/commands"
 
 module Asgard

data/lib/asgard/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Asgard
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/lib/asgard.rb

@@ -15,6 +15,10 @@ module Asgard
     loki_up
   end
 
+  # `asgard schedule list` reports every project's scheduled entries, so it
+  # works from a directory with no .loki above it.
+  def self.machine_wide?(argv) = argv.first(2) == %w[schedule list]
+
   # Main entry point invoked by the asgard executable.
   def self.run!(argv)
     first = argv.first
@@ -27,9 +31,10 @@ module Asgard
       Asgard::Doctor.new.run
       exit
     end
-    task_file = find_task_file or abort "asgard: no .loki file found in #{Dir.pwd}"
+    task_file = find_task_file
+    abort "asgard: no .loki file found in #{Dir.pwd}" unless task_file || machine_wide?(argv)
     before = Asgard::Base.subclasses.dup
-    load task_file
+    load task_file if task_file
     newly_defined = Asgard::Base.subclasses - before
     (newly_defined + [Tasks]).uniq.each(&:validate_deps!)
     Tasks._reset_ran!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asgard
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -37,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: tty-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
 description: |
   A powerful Ruby-based task runner for any kind of project with task dependency tracking
   and concurrent execution of designated tasks. Uses Thor for its rich CLI options, var
@@ -112,6 +126,7 @@ files:
 - lib/asgard/schedule/declaration.rb
 - lib/asgard/schedule/launchd.rb
 - lib/asgard/schedule/systemd.rb
+- lib/asgard/schedule/table.rb
 - lib/asgard/shell.rb
 - lib/asgard/tasks.rb
 - lib/asgard/version.rb
@@ -142,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.21
+rubygems_version: 4.0.22
 specification_version: 4
 summary: A powerful Ruby-based task runner
 test_files: []