asgard 0.3.0 → 0.3.2

data/lib/asgard.rb

@@ -5,6 +5,7 @@ require_relative "asgard/kernel_methods"
 require_relative "asgard/shell"
 require_relative "asgard/base"
 require_relative "asgard/tasks"
+require_relative "asgard/doctor"
 
 module Asgard
   class Error < StandardError; end
@@ -18,7 +19,16 @@ module Asgard
 
   # Main entry point invoked by the asgard executable.
   def self.run!(argv)
-    abort "asgard: unknown command '#{argv.first}'" if argv.first&.start_with?("_")
+    first = argv.first
+    abort "asgard: unknown command '#{first}'" if first&.start_with?("_")
+    if argv.include?("--version")
+      puts Asgard::VERSION
+      exit
+    end
+    if argv.include?("--doctor")
+      Asgard::Doctor.new.run
+      exit
+    end
     task_file = find_task_file or abort "asgard: no .loki file found in #{Dir.pwd}"
     before = Asgard::Base.subclasses.dup
     load task_file

data/quality.loki

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+# Quality gate tasks — imported by .loki
+
+class Tasks
+  desc "Run the test suite"
+  def test_check
+    output = `bundle exec ruby -Ilib:test test/test_asgard.rb 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("test_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /\d+ runs,/ }&.strip || result.to_s
+    puts "Tests: #{summary} (see test_output.txt)"
+    result
+  end
+
+  desc "Run the test suite with verbose output"
+  def test_verbose
+    sh "bundle exec ruby -Ilib:test test/test_asgard.rb -v"
+  end
+
+  desc "Run every *_check quality gate task in parallel"
+  # A Proc defers resolution to validate_deps!, after every .loki file has
+  # loaded — so a *_check task from another file (e.g. quality_rails.loki's
+  # brakeman_check) is picked up too, with no need to redeclare anything here.
+  depends_on -> { [all_commands.keys.grep(/_check\z/).sort.map(&:to_sym)] }
+  def quality
+    check_tasks = self.class._deps.fetch(:quality, []).flatten.map(&:to_s)
+
+    results = check_tasks.to_h { |name| [quality_gate_label(name), dep_result(name)] }
+
+    print_quality_summary(results)
+  end
+
+  desc "Check code style with RuboCop"
+  def rubocop_check
+    output = `RUBOCOP_CACHE_ROOT=tmp/rubocop_cache bundle exec rubocop 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("rubocop_output.txt", output)
+    summary = output.lines.find { |l| l =~ /files inspected/ }&.strip || result.to_s
+    puts "RuboCop: #{summary} (see rubocop_output.txt)"
+    result
+  end
+
+  desc "Auto-correct RuboCop offenses"
+  def rubocop_fix
+    sh "RUBOCOP_CACHE_ROOT=tmp/rubocop_cache bundle exec rubocop -a"
+  end
+
+  desc "Check code complexity with Flog (warn >=20, fail >=50)"
+  def flog_check
+    require "flog"
+
+    method_warn = 20.0
+    method_fail = 50.0
+
+    flogger = Flog.new(all: true)
+    flogger.flog(*Dir.glob("lib/**/*.rb"))
+
+    warnings = []
+    failures = []
+
+    flogger.each_by_score do |method_name, score|
+      next if method_name.end_with?("#none")
+      if score > method_fail
+        failures << "#{"%.1f" % score}: #{method_name}"
+      elsif score > method_warn
+        warnings << "#{"%.1f" % score}: #{method_name}"
+      end
+    end
+
+    result = failures.empty? ? :pass : :fail
+
+    lines = ["Flog warnings (#{method_warn}–#{method_fail}):"]
+    lines.concat(warnings.empty? ? ["  (none)"] : warnings.map { |w| "  #{w}" })
+    lines << ""
+    lines << "Flog failures (>= #{method_fail}):"
+    lines.concat(failures.empty? ? ["  (none)"] : failures.map { |f| "  #{f}" })
+    File.write("flog_output.txt", "#{lines.join("\n")}\n")
+
+    puts "Flog: #{failures.size} failure(s), #{warnings.size} warning(s) (see flog_output.txt)"
+    result
+  end
+
+  desc "Check for structural code duplication with Flay (mass >= 150)"
+  def flay_check
+    require "flay"
+
+    mass_threshold = 150
+
+    flay = Flay.new(mass: mass_threshold, diff: false, verbose: false, summary: false, timeout: 60)
+    flay.process(*Dir.glob("lib/**/*.rb"))
+    flay.analyze
+
+    result = flay.hashes.empty? ? :pass : :fail
+
+    File.open("flay_output.txt", "w") do |f|
+      if result == :pass
+        f.puts "Flay: no structural duplication detected (mass >= #{mass_threshold})"
+      else
+        flay.report(f)
+      end
+    end
+    puts "Flay: #{flay.hashes.size} duplication pattern(s) found (mass >= #{mass_threshold}) (see flay_output.txt)"
+    result
+  end
+
+  desc "Check code smells with Reek"
+  def reek_check
+    output = `bundle exec reek lib 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("reek_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /total warnings?/ }&.strip || result.to_s
+    puts "Reek: #{summary} (see reek_output.txt)"
+    result
+  end
+
+  desc "Check spelling with typos"
+  def typos_check
+    return skip_typos unless command_available?("typos")
+
+    output = `typos 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("typos_output.txt", output)
+    count   = output.lines.count { |l| l.start_with?("error:") }
+    summary = result == :pass ? "no typos found" : "#{count} typo(s) found"
+    puts "Typos: #{summary} (see typos_output.txt)"
+    result
+  end
+
+  desc "Auto-correct typos"
+  def typos_fix
+    return skip_typos unless command_available?("typos")
+
+    sh "typos -w"
+  end
+
+  desc "Check ERB templates for style and safety issues with ERBLint"
+  def erb_lint_check
+    return skip_erb_lint if Dir.glob("**/*.erb").empty?
+
+    output = `bundle exec erb_lint --lint-all --enable-all-linters 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("erb_lint_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /error\(s\)|no errors were found/i }&.strip || result.to_s
+    puts "ERBLint: #{summary} (see erb_lint_output.txt)"
+    result
+  end
+
+  desc "Check for performance suggestions with Fasterer"
+  def fasterer_check
+    output = `bundle exec fasterer lib 2>&1`.gsub(/\e\[\d+m/, "")
+    result = $?.success? ? :pass : :warn
+    File.write("fasterer_output.txt", output)
+    summary = output.lines.find { |l| l =~ /files? inspected/ }&.strip || result.to_s
+    puts "Fasterer: #{summary} (see fasterer_output.txt)"
+    result
+  end
+
+  desc "Check Gemfile.lock for known vulnerabilities with bundler-audit"
+  def bundler_audit_check
+    output = `bundle exec bundle-audit check --update 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("bundler_audit_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /vulnerabilit/i }&.strip || result.to_s
+    puts "Bundler Audit: #{summary} (see bundler_audit_output.txt)"
+    result
+  end
+
+  desc "Check architecture boundaries with ArchSpec"
+  def archspec_check
+    return skip_archspec unless command_available?("archspec") && File.exist?("Archspec.rb")
+
+    output = `archspec check 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("archspec_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /architecture violations? found|ArchSpec passed/i }&.strip ||
+      result.to_s
+    puts "ArchSpec: #{summary} (see archspec_output.txt)"
+    result
+  end
+
+  # Curated display labels for the *_check tasks defined in this file. A
+  # *_check task from elsewhere (e.g. quality_rails.loki's brakeman_check,
+  # loaded automatically once Rails is defined) isn't listed here — it just
+  # falls back to a titleized version of its own name in quality_gate_label.
+  QUALITY_GATE_LABELS = {
+    "test_check"     => "Tests + Coverage",
+    "rubocop_check"  => "RuboCop",
+    "flog_check"     => "Flog Complexity",
+    "flay_check"     => "Flay Duplication",
+    "reek_check"     => "Reek Smells",
+    "erb_lint_check" => "ERBLint",
+    "archspec_check" => "ArchSpec",
+  }.freeze
+
+  no_commands do
+    # true if +name+ resolves to an executable file somewhere on PATH.
+    def command_available?(name)
+      ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
+        File.executable?(File.join(dir, name))
+      end
+    end
+
+    def quality_gate_label(check_name)
+      QUALITY_GATE_LABELS.fetch(check_name) do
+        check_name.delete_suffix("_check").split("_").map(&:capitalize).join(" ")
+      end
+    end
+
+    def skip_typos
+      puts "Typos: SKIPPED — `typos` command not found. Install it with `brew install typos-cli`."
+      :skip
+    end
+
+    def skip_erb_lint
+      puts "ERBLint: SKIPPED — no .erb files found."
+      :skip
+    end
+
+    def skip_archspec
+      reason = command_available?("archspec") ? "no Archspec.rb found" : "`archspec` command not found"
+      puts "ArchSpec: SKIPPED — #{reason}. Install it with `gem install archspec` " \
+        "and run `archspec init` to generate one."
+      :skip
+    end
+
+    # Status badges. Only :fail is blocking (aborts the quality task);
+    # :skip (a required tool isn't installed) and :warn (the check ran but
+    # has non-blocking suggestions, e.g. a performance-hint gate) are not.
+    STATUS_BADGES = {
+      pass: ["PASS", 32], # green
+      fail: ["FAIL", 31], # red
+      warn: ["WARN", 33], # yellow
+      skip: ["SKIP", 36], # cyan
+    }.freeze
+
+    # Colorized status badges plus a pass/fail/warn/skip tally; aborts only
+    # if any gate failed — skip and warn are informational, not blocking.
+    def print_quality_summary(results)
+      colorize_badge = ->(code, text) { "\e[#{code}m#{text}\e[0m" }
+      width = results.keys.map(&:length).max
+
+      puts "\n#{"=" * 60}"
+      puts "Quality Gate Summary"
+      puts "=" * 60
+      results.each do |label, status|
+        text, code = STATUS_BADGES.fetch(status)
+        puts "  [#{colorize_badge.call(code, text)}] #{label.ljust(width)}"
+      end
+      puts "-" * 60
+
+      counts = results.values.tally
+      failed = counts[:fail] || 0
+      tally  = STATUS_BADGES.keys.filter_map { |s| "#{counts[s]} #{s}" if counts[s]&.positive? }.join(", ")
+      puts "  #{colorize_badge.call(failed.zero? ? 32 : 31, tally)}"
+      puts "=" * 60
+
+      abort "\n#{colorize_badge.call(31, "Quality gate failed.")}" unless failed.zero?
+      puts "\n#{colorize_badge.call(32, "All quality gates passed.")}"
+    end
+  end
+end

data/quality_rails.loki

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# Rails-specific quality gate tasks — imported by .loki only when the Rails
+# constant is defined.
+#
+# `quality` (in quality.loki) discovers every *_check task at run time by
+# introspecting Tasks.all_commands, rather than a fixed depends_on list — so
+# any *_check task defined here is automatically picked up by `asgard
+# quality` too, with no need to redeclare or extend anything.
+#
+# Note on rubocop-rails: it's a RuboCop plugin, not a standalone CLI, so it
+# has no *_check task of its own here. Add the gem to the app's Gemfile and
+# `require: rubocop-rails` in its .rubocop.yml — the existing rubocop_check
+# (quality.loki) picks up the added Rails cops automatically.
+
+class Tasks
+  desc "Check for Rails security vulnerabilities with Brakeman"
+  def brakeman_check
+    output = `bundle exec brakeman -q 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("brakeman_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /warnings? found/i }&.strip || result.to_s
+    puts "Brakeman: #{summary} (see brakeman_output.txt)"
+    result
+  end
+
+  desc "Check for Rails anti-patterns with RailsBestPractices"
+  def rails_best_practices_check
+    output = `bundle exec rails_best_practices --silent --without-color . 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("rails_best_practices_output.txt", output)
+    summary = output.lines.reverse.find { |l| l =~ /warning/i }&.strip || result.to_s
+    puts "RailsBestPractices: #{summary} (see rails_best_practices_output.txt)"
+    result
+  end
+
+  desc "Check for database schema issues with ActiveRecordDoctor"
+  def active_record_doctor_check
+    output = `bundle exec rake active_record_doctor 2>&1`
+    result = $?.success? ? :pass : :fail
+    File.write("active_record_doctor_output.txt", output)
+    issue_count = output.lines.count { |l| l.strip != "" }
+    summary = result == :pass ? "no issues found" : "#{issue_count} issue line(s) found"
+    puts "ActiveRecordDoctor: #{summary} (see active_record_doctor_output.txt)"
+    result
+  end
+end

data/xyzzy.loki

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+# example of an overwritten task detected by (--doctor) — imported by .loki
+
+class Tasks
+  desc "Push the current branch to its remote"
+  def xyzzy = puts <<~MAGIC
+    You are at a fork in the yellow brick road to AI.
+    To the left is python, the favorite programming language of snake charmers.
+    To the right is Ruby, the best computer programming language of all time.
+    Which way do you go?
+  MAGIC
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asgard
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -23,20 +23,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: dagwood
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -65,13 +51,14 @@ files:
 - ".envrc"
 - ".github/workflows/deploy-github-pages.yml"
 - ".loki"
+- ".reek.yml"
 - ".rubocop.yml"
+- Archspec.rb
 - CHANGELOG.md
 - CLAUDE.md
 - COMMITS.md
 - LICENSE.txt
 - README.md
-- Rakefile
 - bin/asgard
 - bin/console
 - bin/setup
@@ -93,6 +80,7 @@ files:
 - docs/variables.md
 - examples/.env
 - examples/.loki
+- examples/bad.loki
 - examples/concurrent.loki
 - examples/db_subcommands.loki
 - examples/env_usage.loki
@@ -101,14 +89,26 @@ files:
 - examples/subdir/.loki
 - examples/subdir/import_demo.loki
 - examples/subdir/import_up_demo.loki
+- gem_tasks.loki
+- git.loki
 - lib/asgard.rb
 - lib/asgard/base.rb
+- lib/asgard/base/dependency_graph.rb
+- lib/asgard/base/dispatch.rb
+- lib/asgard/base/registry.rb
+- lib/asgard/base/task_dsl.rb
+- lib/asgard/doctor.rb
+- lib/asgard/doctor/report.rb
+- lib/asgard/doctor/task_sections.rb
 - lib/asgard/kernel_methods.rb
 - lib/asgard/shell.rb
 - lib/asgard/tasks.rb
 - lib/asgard/version.rb
 - mkdocs.yml
+- quality.loki
+- quality_rails.loki
 - sig/asgard.rbs
+- xyzzy.loki
 homepage: https://github.com/madbomber/asgard
 licenses:
 - MIT
@@ -131,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.12
+rubygems_version: 4.0.19
 specification_version: 4
 summary: A powerful Ruby-based task runner
 test_files: []

data/Rakefile

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "minitest/test_task"
-
-SIMPLECOV_PRELUDE = <<~RUBY
-  require "simplecov"
-  SimpleCov.start do
-    add_filter "/test/"
-    minimum_coverage 95
-  end
-RUBY
-
-Minitest::TestTask.create do |t|
-  t.test_prelude = SIMPLECOV_PRELUDE
-end
-
-task default: :test
-
-RUBOCOP_ENV = { "RUBOCOP_CACHE_ROOT" => "tmp/rubocop_cache" }.freeze
-
-desc "Check code style with RuboCop"
-task :rubocop do
-  sh RUBOCOP_ENV, "bundle exec rubocop"
-end
-
-desc "Auto-correct RuboCop offenses"
-task :rubocop_fix do
-  sh RUBOCOP_ENV, "bundle exec rubocop -a"
-end
-
-desc "Check code complexity with Flog (warn >=20, fail >=50)"
-task :flog_check do
-  require "flog"
-
-  # Target to work toward; methods above this are warned but don't fail the gate.
-  METHOD_WARN = 20.0
-  # Current baseline floor — established from first run. Reduce incrementally.
-  METHOD_FAIL = 50.0
-
-  flogger = Flog.new(all: true)
-  flogger.flog(*Dir.glob("lib/**/*.rb"))
-
-  warnings = []
-  failures = []
-
-  flogger.each_by_score do |method, score|
-    next if method.end_with?("#none")
-    if score > METHOD_FAIL
-      failures << "#{"%.1f" % score}: #{method}"
-    elsif score > METHOD_WARN
-      warnings << "#{"%.1f" % score}: #{method}"
-    end
-  end
-
-  unless warnings.empty?
-    puts "\nFlog warnings (#{METHOD_WARN}–#{METHOD_FAIL}) — target for future refactoring:"
-    warnings.each { |v| puts "  #{v}" }
-  end
-
-  if failures.empty?
-    puts "\nFlog: no methods exceed the failure threshold (>=#{METHOD_FAIL})"
-  else
-    puts "\nFlog failures (>=#{METHOD_FAIL}) — must be refactored:"
-    failures.each { |v| puts "  #{v}" }
-    $stdout.flush
-    abort "\nFlog quality gate failed: #{failures.size} method(s) exceed #{METHOD_FAIL}"
-  end
-end
-
-desc "Run all quality checks: tests (with coverage), RuboCop, and Flog"
-task :quality do
-  results = {}
-
-  puts "\n#{"=" * 60}"
-  puts "Quality Gate: Tests + Coverage"
-  puts "=" * 60
-  results[:tests] = system("bundle exec rake test") ? :pass : :fail
-
-  puts "\n#{"=" * 60}"
-  puts "Quality Gate: RuboCop"
-  puts "=" * 60
-  results[:rubocop] = system(RUBOCOP_ENV, "bundle exec rubocop") ? :pass : :fail
-
-  puts "\n#{"=" * 60}"
-  puts "Quality Gate: Flog Complexity"
-  puts "=" * 60
-  results[:flog] = system("bundle exec rake flog_check") ? :pass : :fail
-
-  puts "\n#{"=" * 60}"
-  puts "Quality Summary"
-  puts "=" * 60
-  results.each do |gate, status|
-    icon = status == :pass ? "PASS" : "FAIL"
-    puts "  [#{icon}] #{gate}"
-  end
-  puts "=" * 60
-
-  abort "\nQuality gate failed" if results.values.any?(:fail)
-  puts "\nAll quality gates passed."
-end