asgard 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c25b1efcac0de2f525140327f64753c1cb7b0cf82904ea6c4e1be1114b619bf
-  data.tar.gz: 857e98381996d06968944ed6bafb6b35d86073523672ac6d987ce2fb85a8cc79
+  metadata.gz: 7920fc28de5f8644ccc7934f576142d433de3fb5af1ac21b28cbd350d930af66
+  data.tar.gz: e651f2956eb2f9fc076548fc04cae92e6835fb508b5960eeda952929d9197253
 SHA512:
-  metadata.gz: 383ececde0765e801b1e84dc239895ee0d2ffe491fc6d0c0c4d3a583f0a0912f64ca8dc4a4a6469f12efcae93358302ada9aeb648b6a95ada4fe866c205306b0
-  data.tar.gz: 3d2ecd3d0dcc3acdaa1ecd6dd6457ce02c23b086c36f178b9aa378ec620069ae99e9ecae3d824d26f0d22fb5906a4b34bc1831a2040abf24bab81833080b470e
+  metadata.gz: 19e473102e5850db42c777b9dd824765b9e4a187f1de6f009d80ae85fa1d6992984587a7ca4e9dc40cb301aadc11093826f913d3c5c7dac8e17a47c47f7cdefe
+  data.tar.gz: '09c0f72476c8690f055e6aeb2b052449a4eb9fd415bff06a82e4cd5dc4255cfb8709721a76ae347226b31b8dafcbd3e63a439fcd6f249975f134156f578edb1f'

data/.loki

@@ -1,6 +1,8 @@
-# default task filename for the asgard task runner
+# frozen_string_literal: true
+# Asgard gem's own task file.
+# Task is pre-defined by the gem — just reopen it to add tasks.
 
-class Tasks < Asgard::Base
+class Tasks
   var :gem_name, "asgard"
   var :version,  -> { Asgard::VERSION }
 

data/CHANGELOG.md

@@ -7,12 +7,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.1] - 2026-05-28
+### Added
+
+- Parallel dependency execution — wrap deps in an array to run them concurrently:
+  `depends_on [:build, :lint]` or `depends_on :setup, [:build, :lint], :deploy`
+- `Asgard.run!(argv)` — single entry point encapsulating find, load, validate, and start
+- `Asgard.load_loki(dir)` — auto-loads all `*.loki` files in a directory alphabetically
+- `Tasks` class pre-defined by the gem (`class Tasks < Asgard::Base`) — task files reopen it without restating the superclass
+- `lib/asgard/tasks.rb` — ships the pre-defined `Tasks` class
+
+### Changed
+
+- Replaced `SimpleFlow` dependency with `Dagwood` — purpose-built DAG library with no extra dependencies and no Ruby 4 compatibility issues
+- `bin/asgard` simplified to two lines: `require "asgard"` + `Asgard.run!(ARGV)`
+- Task file convention: `.loki` is the project root marker and entry point; `*.loki` files each reopen `class Tasks` and are auto-loaded before `.loki`
+- `Asgard.find_task_files` renamed to `Asgard.find_task_file` (singular — only `.loki` is the entry point)
+- `depends_on` now accepts mixed sequential/parallel stages; bare symbols run sequentially, arrays within the splat run in parallel
+- `run!` handles its own errors — missing `.loki` and circular dependencies produce a clean one-line message and exit 1 rather than a backtrace
+- Thread-safe dep deduplication via class-level `_ran_tasks` Set + Mutex replaces Thor's `@_invocations`
+- Removed `import` macro — task files use Ruby class reopening instead of modules
+
+### Removed
+
+- `SimpleFlow` dependency (replaced by `Dagwood`)
+- `logger` gem workaround (was only needed for SimpleFlow on Ruby 4)
+- `*.loki` glob fallback in `find_task_file` — only `.loki` is the auto-discovered entry point
+
 ## [0.1.0] - 2026-05-28
 
 ### Added
 
 - `Asgard::Base` — Thor subclass providing the task DSL
-- `depends_on` — declare recipe dependencies resolved via `SimpleFlow::DependencyGraph`; dependencies run at most once per invocation
+- `depends_on` — declare recipe dependencies; dependencies run at most once per invocation
 - `var` — declare static or lazy-evaluated variables available to all recipes
 - `import` — flat-merge a task module into the current class
 - `dotenv` — load a `.env` file into the environment

data/README.md

@@ -1,6 +1,6 @@
 # Asgard
 
-A [just](https://just.systems)-like task runner for Ruby. Define project recipes in a `.loki` file and run them with the `asgard` command. Built on [Thor](https://github.com/rails/thor) for argument handling and [SimpleFlow](https://github.com/madbomber/simple_flow) for dependency ordering.
+A [just](https://just.systems)-like task runner for Ruby. Built on [Thor](https://github.com/rails/thor) for argument handling and [Dagwood](https://github.com/rewindio/dagwood) for dependency ordering.
 
 The name comes from Norse mythology: **Thor** is the CLI framework, **Asgard** is the realm where tasks live, and the task file is named **loki** — because Loki holds all the tricks.
 
@@ -16,241 +16,405 @@ Or add to your Gemfile:
 bundle add asgard
 ```
 
-## Quick Start
+---
 
-Create a `.loki` file at your project root. `sh` runs any shell command — a single line or a multiline heredoc:
+## Tasks
+
+Every `.loki` file defines tasks as methods inside `class Tasks`. The `Tasks` class is pre-defined by the gem — just reopen it and add methods.
+
+### A task with no parameters
 
 ```ruby
-# filename: .loki
+class Tasks
+  desc "hello", "Say hello"
+  def hello = sh 'echo "Hello, World!"'
+end
+```
 
-class Tasks < Asgard::Base
-  desc "deps", "Install project dependencies"
-  def deps
-    sh <<~SHELL
-      brew install redis
-      npm install
-      bundle install
-    SHELL
-  end
+```bash
+asgard hello
+```
 
-  depends_on :deps
-  desc "test", "Run the test suite"
-  def test
-    sh "bundle exec rake test"
-  end
+### A task with a positional parameter
 
-  depends_on :test
-  desc "release", "Tag and publish the gem"
-  def release
-    sh <<~SHELL
-      git tag v$(ruby -r./lib/my_gem/version -e 'puts MyGem::VERSION')
-      git push --tags
-      bundle exec rake release
-    SHELL
-  end
+Declare positional parameters directly in the method signature. Document them in the `desc` usage string:
+
+```ruby
+class Tasks
+  desc "hello NAME", "Say hello to NAME"
+  def hello(name = "World") = sh "echo 'Hello, #{name}!'"
 end
 ```
 
-Then run tasks from any directory in the project tree:
-
 ```bash
-asgard test       # runs deps, then test
-asgard release    # runs deps, then test, then release
-asgard help       # list all available tasks
+asgard hello
+asgard hello Alice
 ```
 
-## Task Files
+### A task with a formal argument declaration
 
-Asgard searches the current directory and its ancestors for task files, in this order:
+Use `argument` for richer metadata — type checking, enums, and help text:
+
+```ruby
+class Tasks
+  argument :name,
+           type:    :string,
+           default: "World",
+           desc:    "Name to greet"
+
+  desc "hello NAME", "Say hello to NAME"
+  def hello = sh "echo 'Hello, #{name}!'"
+end
+```
 
-1. **`.loki`** — the hidden default. Found alone, takes priority over everything.
-2. **`*.loki`** — all matching files loaded alphabetically when no `.loki` exists.
+### A task with named options
 
-This means you can split a large task set across multiple files:
+Use `method_option` (alias: `option`) for named flags. Access them inside the method via `options[:name]`:
 
+```ruby
+class Tasks
+  desc "hello NAME", "Say hello to NAME"
+  method_option :shout,  aliases: "-s", type: :boolean, desc: "Uppercase the output"
+  method_option :count,  aliases: "-n", type: :numeric, default: 1, desc: "Repeat N times"
+  def hello(name = "World")
+    message = options[:shout] ? "HELLO, #{name.upcase}!" : "Hello, #{name}!"
+    options[:count].times { sh "echo '#{message}'" }
+  end
+end
 ```
-deploy.loki
-test.loki
-build.loki        # loaded as: build.loki, deploy.loki, test.loki
+
+```bash
+asgard hello Alice --shout --count 3
 ```
 
-Or use a single hidden default:
+### A task with an extended description
 
+`long_desc` provides detailed help shown by `asgard help <task>`:
+
+```ruby
+class Tasks
+  long_desc <<~DESC
+    Says hello to NAME.
+    Repeats the greeting COUNT times.
+    Use --shout to uppercase the output.
+  DESC
+  desc "hello NAME", "Say hello to NAME"
+  method_option :shout, aliases: "-s", type: :boolean, desc: "Uppercase the output"
+  method_option :count, aliases: "-n", type: :numeric, default: 1, desc: "Repeat N times"
+  def hello(name = "World")
+    message = options[:shout] ? "HELLO, #{name.upcase}!" : "Hello, #{name}!"
+    options[:count].times { sh "echo '#{message}'" }
+  end
+end
 ```
-.loki             # takes priority, *.loki files are ignored
-```
 
-## Features
+---
+
+## Dependencies
 
-### Task dependencies
+`depends_on` declares what must run before a task. Each dependency runs at most once per `asgard` invocation regardless of how many tasks declare it. Circular dependencies are caught at startup.
+
+`desc` and `depends_on` are independent — either can come first, both must appear before `def`.
+
+### Sequential dependencies
+
+Bare symbols run one after another in the order declared:
 
 ```ruby
-depends_on :build
-desc "test", "Run tests"
-def test
-  sh "bundle exec rake test"
+class Tasks
+  desc "build", "Compile the project"
+  def build = sh "rake build"
+
+  depends_on :build
+  desc "test", "Run the test suite"
+  def test = sh "rake test"
+
+  depends_on :test
+  desc "release", "Publish the gem"
+  def release = sh "bundle exec rake release"
 end
 ```
 
-Dependencies run before the recipe, at most once per invocation regardless of how many recipes declare them. Circular dependencies are caught at startup via `SimpleFlow::DependencyGraph`.
+```bash
+asgard release   # build → test → release
+```
+
+### Parallel dependencies
 
-### Variables
+Wrap symbols in an array to declare they can run concurrently. Asgard waits for all tasks in a parallel group to finish before moving to the next stage:
 
 ```ruby
-var :app,     "myapp"
-var :version, -> { `git describe --tags`.strip }   # lazy, evaluated on first use
+class Tasks
+  desc "lint", "Check code style"
+  def lint = sh "bundle exec rubocop"
+
+  desc "typecheck", "Run type checks"
+  def typecheck = sh "bundle exec srb tc"
 
-desc "tag", "Create a git tag"
-def tag
-  sh "git tag #{version}"
+  # lint and typecheck run in parallel, test waits for both
+  depends_on [:lint, :typecheck]
+  desc "test", "Run the test suite"
+  def test = sh "bundle exec rake test"
 end
 ```
 
-### Multi-line shell scripts
+```bash
+asgard test   # lint ∥ typecheck → test
+```
+
+### Mixed sequential and parallel
+
+Mix bare symbols (sequential) and arrays (parallel) in a single `depends_on` call. Execution proceeds stage by stage — each stage must complete before the next begins:
 
 ```ruby
-desc "setup", "Bootstrap the dev environment"
-def setup
-  sh <<~SHELL
-    brew install redis postgresql
-    brew services start redis
-    bundle install
-    rails db:setup
-  SHELL
+class Tasks
+  desc "setup",  "Install dependencies"; def setup  = sh "bundle install"
+  desc "lint",   "Check code style";     def lint   = sh "bundle exec rubocop"
+  desc "build",  "Compile assets";       def build  = sh "rake assets:precompile"
+  desc "test",   "Run tests";            def test   = sh "bundle exec rake test"
+  desc "notify", "Post to Slack";        def notify = sh "curl $SLACK_WEBHOOK -d '{\"text\":\"done\"}'"
+
+  # setup first, then lint+build in parallel, then test, then notify
+  depends_on :setup, [:lint, :build], :test, :notify
+  desc "ci", "Full CI pipeline"
+  def ci = sh "echo 'CI complete'"
 end
 ```
 
-### Embedded scripts in other languages
+```
+asgard ci executes:
+
+  setup
+    ↓
+  lint ∥ build    (concurrent)
+    ↓
+  test
+    ↓
+  notify
+    ↓
+  ci
+```
+
+---
+
+## Variables
+
+`var` declares a named value available to all tasks as a method. Pass a lambda for lazy evaluation — it is called once on first use:
 
 ```ruby
-desc "analyze", "Run data analysis"
-def analyze
-  shebang :python3, <<~PYTHON
-    import json
-    data = json.load(open("results.json"))
-    print(f"Total: {sum(data.values())}")
-  PYTHON
-end
+class Tasks
+  var :app,     "myapp"
+  var :version, -> { `git describe --tags`.strip }
 
-desc "bundle", "Build frontend assets"
-def bundle_assets
-  shebang :node, <<~JS
-    const esbuild = require("esbuild")
-    esbuild.buildSync({ entryPoints: ["src/app.js"], bundle: true, outfile: "dist/app.js" })
-  JS
+  desc "tag", "Create a release tag"
+  def tag = sh "git tag #{app}-#{version}"
 end
 ```
 
-Supported interpreters: `:python3`, `:python`, `:node`, `:ruby`, `:perl`, `:bash`, `:sh`. Any other symbol is passed directly to `system` with a `.tmp` extension.
+---
 
-### Importing task modules
+## Options shared across all tasks
 
-Split tasks into reusable modules and include them flat (all tasks in the same namespace):
+`class_option` defines an option available to every task in the class:
 
 ```ruby
-# shared/deploy_tasks.rb
-module DeployTasks
-  def self.included(base)
-    base.desc "deploy", "Deploy to production"
-    base.define_method(:deploy) { sh "cap production deploy" }
+class Tasks
+  class_option :dry_run, aliases: "-n", type: :boolean, desc: "Print commands without running"
+
+  desc "deploy ENV", "Deploy to the given environment"
+  def deploy(env = "staging")
+    if options[:dry_run]
+      puts "Would deploy to #{env}"
+    else
+      sh "cap #{env} deploy"
+    end
   end
 end
+```
 
-# .loki
-require_relative "shared/deploy_tasks"
+---
 
-class Tasks < Asgard::Base
-  import DeployTasks
+## Shell helpers
+
+`sh` runs any shell command or multiline heredoc. `shebang` writes a script body to a tempfile and executes it with the given interpreter. Both exit with the command's status code on failure.
+
+```ruby
+class Tasks
+  desc "setup", "Bootstrap the development environment"
+  def setup
+    sh <<~SHELL
+      brew install redis postgresql
+      brew services start redis
+      bundle install
+      rails db:setup
+    SHELL
+  end
+
+  desc "analyze", "Run Python data analysis"
+  def analyze
+    shebang :python3, <<~PYTHON
+      import json
+      data = json.load(open("results.json"))
+      print(f"Total: {sum(data.values())}")
+    PYTHON
+  end
+
+  desc "bundle_assets", "Build frontend assets with esbuild"
+  def bundle_assets
+    shebang :node, <<~JS
+      const esbuild = require("esbuild")
+      esbuild.buildSync({ entryPoints: ["src/app.js"], bundle: true, outfile: "dist/app.js" })
+    JS
+  end
 end
 ```
 
-For namespaced subcommands, use Thor's `register`:
+Supported interpreters: `:python3`, `:python`, `:node`, `:ruby`, `:perl`, `:bash`, `:sh`. Any other symbol is passed directly to `system` with a `.tmp` extension.
+
+Pass `silent: true` to suppress the command echo:
 
 ```ruby
-register DeployTasks, "deploy", "deploy COMMAND", "Deployment tasks"
-# invoked as: asgard deploy production
+def build = sh "rake build", silent: true
 ```
 
-### Dotenv
+---
+
+## Environment variables
+
+`dotenv` loads a `.env` file into the environment before tasks run:
 
 ```ruby
-class Tasks < Asgard::Base
-  dotenv          # loads .env from CWD
-  dotenv ".env.local"
+class Tasks
+  dotenv              # loads .env
+  dotenv ".env.local" # or a specific file
 
-  desc "check", "Print the app name"
-  def check
-    sh "echo $APP_NAME"
-  end
+  desc "check", "Print the app name from .env"
+  def check = sh "echo $APP_NAME"
 end
 ```
 
-### Echo suppression
+---
 
-Pass `silent: true` to suppress the command echo (equivalent to `just`'s `@` prefix):
+## Command aliases
+
+`map` creates alternative names for a task:
 
 ```ruby
-def build
-  sh "bundle exec rake build", silent: true   # runs quietly, output still shown
+class Tasks
+  map "-v"  => "version"
+  map "--v" => "version"
+  map "t"   => "test"
+
+  desc "version", "Print the version"
+  def version = puts Asgard::VERSION
 end
 ```
 
-## Shell helpers
+---
 
-| Method | Description |
-|---|---|
-| `sh(script, silent: false)` | Run a shell command or multiline script |
-| `shebang(interpreter, script, silent: false)` | Write script to a tempfile and execute it |
+## `method_option` types reference
 
-Both exit with the command's status code on failure.
+| Type | CLI example | Ruby value |
+|---|---|---|
+| `:string` | `--branch main` | `"main"` |
+| `:boolean` | `--force` / `--no-force` | `true` / `false` |
+| `:numeric` | `--count 3` | `3` |
+| `:array` | `--tags foo bar baz` | `["foo", "bar", "baz"]` |
+| `:hash` | `--vars KEY:val FOO:bar` | `{"KEY"=>"val", "FOO"=>"bar"}` |
 
-## Full example `.loki`
+Common `method_option` keys: `aliases`, `type`, `default`, `required`, `desc`, `enum`, `banner`.
 
-```ruby
-require "asgard"
+---
 
-class Tasks < Asgard::Base
-  dotenv
+## Task files
 
-  var :app,     "myapp"
-  var :version, -> { File.read("VERSION").strip }
+Asgard searches the current directory and its ancestors for a `.loki` file. That file marks the project root. All `*.loki` files in the same directory are auto-loaded alphabetically before `.loki` is loaded.
+
+### Single file
+
+```
+myproject/
+  .loki
+```
+
+### Multiple files
+
+Split tasks across files — each reopens `class Tasks`:
 
+```
+myproject/
+  .loki          ← entry point, can be empty
+  build.loki
+  deploy.loki
+  test.loki
+```
+
+```ruby
+# build.loki
+class Tasks
+  desc "build", "Compile the project"
+  def build = sh "rake build"
+end
+```
+
+```ruby
+# test.loki
+class Tasks
+  depends_on :build
   desc "test", "Run the test suite"
-  def test
-    sh "bundle exec rake test"
-  end
+  def test = sh "bundle exec rake test"
+end
+```
 
+```ruby
+# deploy.loki
+class Tasks
   depends_on :test
-  desc "quality", "Run tests then check complexity"
-  def quality
-    sh "flog lib/"
-  end
+  desc "deploy", "Deploy to production"
+  def deploy = sh "cap production deploy"
+end
+```
 
-  desc "build", "Build the gem"
-  def build
-    sh "bundle exec rake build"
-  end
+The `.loki` entry point can be completely empty — it only needs to exist to mark the project root.
 
-  depends_on :quality, :build
-  desc "release", "Release #{version} to RubyGems"
-  def release
-    sh "bundle exec rake release"
-  end
+### Explicit loading
+
+Load any Ruby or `.loki` file manually from `.loki`:
+
+```ruby
+# .loki
+require_relative "shared/helpers"
+require_relative "ci.loki"
+
+class Tasks
+  # additional tasks
 end
 ```
 
+---
+
+## `Asgard` module API
+
+| Method | Description |
+|---|---|
+| `Asgard.run!(argv)` | Entry point — finds `.loki`, loads task files, starts CLI |
+| `Asgard.find_task_file` | Returns path to `.loki` searching from CWD upward, or nil |
+| `Asgard.load_loki(dir)` | Loads all `*.loki` files in dir alphabetically |
+
+`run!` handles its own errors — a missing `.loki` or a circular dependency both produce a clean one-line message and exit 1.
+
+---
+
 ## Development
 
 ```bash
 git clone git@github.com:MadBomber/asgard.git
 cd asgard
 bundle install
-bundle exec rake test       # run tests with coverage
-bundle exec bin/asgard help # try the CLI against this gem's own .loki file
+bundle exec rake test       # run tests (95% coverage minimum enforced)
+bundle exec bin/asgard help # exercise the CLI against this gem's own .loki
 ```
 
-Coverage threshold is enforced at 95% via SimpleCov.
-
 ## Contributing
 
 Bug reports and pull requests are welcome at https://github.com/MadBomber/asgard.

data/bin/asgard

@@ -2,23 +2,4 @@
 # frozen_string_literal: true
 
 require "asgard"
-
-task_files = Asgard.find_task_files
-
-unless task_files
-  warn "asgard: no .loki or *.loki task file found in #{Dir.pwd} or any parent directory"
-  exit 1
-end
-
-task_files.each { |f| load f }
-
-klass = Asgard::Base.subclasses.last
-
-unless klass
-  warn "asgard: no class inheriting Asgard::Base found in #{task_files.join(', ')}"
-  exit 1
-end
-
-klass.validate_deps!
-klass._reset_ran!
-klass.start(ARGV)
+Asgard.run!(ARGV)

data/lib/asgard/base.rb

@@ -2,7 +2,7 @@
 
 require "thor"
 require "set"
-require "simple_flow"
+require "dagwood"
 
 module Asgard
   class Base < Thor
@@ -88,7 +88,7 @@ module Asgard
         Dotenv.load(path) if File.exist?(path)
       end
 
-      # Validate the full dep graph for cycles using SimpleFlow::DependencyGraph.
+      # Validate the full dep graph for cycles using Dagwood::DependencyGraph.
       def validate_deps!
         return if _deps.empty?
 
@@ -97,7 +97,7 @@ module Asgard
           hash[task] = _deps.fetch(task, []).flatten
         end
 
-        SimpleFlow::DependencyGraph.new(full_graph).order
+        Dagwood::DependencyGraph.new(full_graph).order
       rescue TSort::Cyclic => e
         raise Asgard::CircularDependencyError, e.message
       end
@@ -132,7 +132,7 @@ module Asgard
         stages = self.class._deps[target]
         if stages&.any?
           graph  = self.class._build_dep_graph(stages)
-          groups = SimpleFlow::DependencyGraph.new(graph).parallel_order
+          groups = Dagwood::DependencyGraph.new(graph).parallel_order
 
           groups.each do |group|
             if group.size > 1

data/lib/asgard/tasks.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Tasks is the single conventional entry point for all .loki files.
+# It is pre-defined by the gem so .loki files never need to declare a class.
+# Auxiliary *.loki files define modules which are imported into Tasks.
+class Tasks < Asgard::Base; end

data/lib/asgard/version.rb

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

data/lib/asgard.rb

@@ -3,30 +3,43 @@
 require_relative "asgard/version"
 require_relative "asgard/shell"
 require_relative "asgard/base"
+require_relative "asgard/tasks"
 
 module Asgard
   class Error < StandardError; end
   class CircularDependencyError < Error; end
 
-  # Search the current directory and its ancestors for task files.
-  # Returns an array of paths, or nil if nothing is found.
-  #
-  # Priority:
-  #   1. A single .loki file in the directory (default/hidden task file)
-  #   2. All *.loki files in the directory, sorted alphabetically
-  def self.find_task_files
+  # Search the current directory and its ancestors for a .loki task file.
+  # Returns the path string, or nil if not found.
+  def self.find_task_file
     dir = Dir.pwd
     loop do
-      dot_loki = File.join(dir, ".loki")
-      return [dot_loki] if File.exist?(dot_loki)
-
-      matches = Dir.glob(File.join(dir, "*.loki")).sort
-      return matches unless matches.empty?
-
+      candidate = File.join(dir, ".loki")
+      return candidate if File.exist?(candidate)
       parent = File.dirname(dir)
       break if parent == dir
       dir = parent
     end
     nil
   end
+
+  # Load all *.loki files from dir in alphabetical order.
+  # Each file typically reopens class Tasks to add recipes.
+  # The .loki entry point is excluded — it is loaded separately by run!.
+  def self.load_loki(dir)
+    Dir.glob(File.join(dir, "*.loki")).sort.each { |f| load f }
+  end
+
+  # Main entry point invoked by the asgard executable.
+  def self.run!(argv)
+    task_file = find_task_file or (warn "asgard: no .loki file found in #{Dir.pwd}"; exit 1)
+    load_loki(File.dirname(task_file))
+    load task_file
+    Tasks.validate_deps!
+    Tasks._reset_ran!
+    Tasks.start(argv)
+  rescue CircularDependencyError => e
+    warn "asgard: circular dependency — #{e.message}"
+    exit 1
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asgard
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -9,20 +9,6 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: logger
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -38,19 +24,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: simple_flow
+  name: dagwood
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +52,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 description: 'Asgard brings just-style recipes to Ruby: Thor-powered CLI, dep ordering
-  via SimpleFlow::DependencyGraph, var declarations, dotenv, sh/shebang helpers, and
+  via Dagwood::DependencyGraph, var declarations, dotenv, sh/shebang helpers, and
   importable task modules.'
 email:
 - dewayne@vanhoozer.me
@@ -88,6 +74,7 @@ files:
 - lib/asgard.rb
 - lib/asgard/base.rb
 - lib/asgard/shell.rb
+- lib/asgard/tasks.rb
 - lib/asgard/version.rb
 - sig/asgard.rbs
 homepage: https://github.com/madbomber/asgard
@@ -113,5 +100,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.12
 specification_version: 4
-summary: A just-like task runner built on Thor, with recipe dependencies via SimpleFlow.
+summary: A just-like task runner built on Thor, with recipe dependencies via Dagwood.
 test_files: []