beachio-hammer 0.1.0.pre5 → 0.1.0.pre7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 761f1f1873cb333406eeab947ee2ae1edde559b69fa38497810c96bdf802f58e
-  data.tar.gz: 6721ab8889e4129b9c886fa875b92579d359a9012852d69aaa711fa1e29c08eb
+  metadata.gz: 7f49550d59c10cbcb9b8ed9dae068082d5962abd833fcf2b6b039d07ce409b5e
+  data.tar.gz: 4e04f20a894021945d2366a00a4b4239404541d139d60ed99c93c49afff767e5
 SHA512:
-  metadata.gz: 23c9ab030b80757ac305dc66d4f0a35c9df394e248fa22ce62e8164d96c9b1573c4771b49ea82770574c113a7c4fd56ccfd26e294bda7f4515ede443dca28bfa
-  data.tar.gz: 5b670417365cbd83d7a706f3a1dc03edaadbcde2ca5cff920651446f66c790565d97a798e3a784fed847493cd62e1051cd27a0a4b23d11d67cd46014fb85314b
+  metadata.gz: 69c67662fc6d413a3af72e8873ad96345e8e363a87fac6657c1c10385239ab195201805c2e9d1784beae717316f15e9835ba81f1483e39f43b8028c971d03ab4
+  data.tar.gz: 0efecd32fde11e6c6b6be017f427554cd7d57c11ad633d766c8b61be499b660cf7f61928e25dbcfd53db52cfe1ed765016c0ab0a5aa0d71a13503b921ed4f029

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    beachio-hammer (0.1.0.pre5)
+    beachio-hammer (0.1.0.pre6)
       json (~> 2.7)
 
 GEM

data/PUBLISH.md

@@ -38,7 +38,18 @@ gem build beachio-hammer.gemspec
 gem push beachio-hammer-*.gem
 ```
 
-Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre5`**
+Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre7`**
+
+### 0.1.0.pre7 changes
+
+- Fix gem packaging: include `lib/hammer/check_command.rb` (pre6 omitted untracked file)
+
+### 0.1.0.pre6 changes (`hammer check`)
+
+- Add `hammer check` for content validation (Swift CLI parity)
+- Flags: `--project`, `--strict`, `--format json|human`
+- Rule IDs: `CONFIG_MISSING`, `CONFIG_INVALID`, `COLLECTION_DIR_MISSING`, `TEMPLATE_MISSING`, `PARSE_ERROR`, `REQUIRED_FIELD_MISSING`, `SLUG_MISSING`, `PROJECT_NOT_FOUND`
+- Agent QC: `hammer check --strict --format json`
 
 ### 0.1.0.pre5 changes (collection loops on static pages)
 
@@ -68,16 +79,17 @@ Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre5`**
 Pin the published gem version in the executor Dockerfile:
 
 ```dockerfile
-RUN gem install beachio-hammer -v 0.1.0.pre5
+RUN gem install beachio-hammer -v 0.1.0.pre6
 ```
 
-Build step in the agent:
+Validate and build in the agent:
 
 ```bash
+hammer check --project "$WORKSPACE" --strict --format json
 hammer build --project "$WORKSPACE" --mode export --format json --clean
 ```
 
-### CLI contract
+### CLI contract — `hammer build`
 
 | Flag | Default | Notes |
 |------|---------|-------|
@@ -100,6 +112,29 @@ hammer build --project "$WORKSPACE" --mode export --format json --clean
 }
 ```
 
+### CLI contract — `hammer check`
+
+| Flag | Default | Notes |
+|------|---------|-------|
+| `--project` | cwd (walk-up for markers) | Project root |
+| `--strict` | off | Treat warnings as errors |
+| `--format` | `human` | `json` for agent parsing |
+
+**Exit codes:** `0` pass (or warnings without `--strict`), `1` check failures, `2` project/config error, `3` internal.
+
+**JSON stdout** (`--format json`):
+
+```json
+{
+  "status": "pass",
+  "errors": [{ "ruleId", "message", "file", "suggestion" }],
+  "warnings": [{ "ruleId", "message", "file", "suggestion" }],
+  "stats": { "filesChecked", "durationMs" }
+}
+```
+
+**Rule IDs:** `CONFIG_MISSING` (warn), `CONFIG_INVALID`, `COLLECTION_DIR_MISSING`, `TEMPLATE_MISSING`, `PARSE_ERROR`, `REQUIRED_FIELD_MISSING`, `SLUG_MISSING` (warn), `PROJECT_NOT_FOUND` (JSON `status: "error"`, exit 2).
+
 ### Parity fixtures
 
 | Fixture | Path | Files |

data/lib/beachio-hammer.rb

@@ -23,6 +23,7 @@ require_relative "hammer/content/page_generator"
 require_relative "hammer/content/builder"
 require_relative "hammer/builder"
 require_relative "hammer/build_command"
+require_relative "hammer/check_command"
 require_relative "hammer/cli"
 
 module Hammer

data/lib/hammer/check_command.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Hammer
+  module CheckCommand
+    module_function
+
+    def run(argv)
+      options = parse_options(argv)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      project_dir, project_exit = resolve_project(options)
+      return project_exit if project_exit
+
+      errors = []
+      warnings = []
+      files_checked = 0
+
+      config_path = File.join(project_dir, "content.config.json")
+
+      unless File.file?(config_path)
+        warnings << issue(
+          rule_id: "CONFIG_MISSING",
+          message: "No content.config.json found",
+          file: project_dir,
+          suggestion: "Create a content.config.json to enable content validation"
+        )
+        duration_ms = elapsed_ms(start)
+        status = options[:strict] && !warnings.empty? ? "fail" : "pass"
+        output_result(status, errors, warnings, files_checked, duration_ms, options[:format])
+        return options[:strict] && !warnings.empty? ? 1 : 0
+      end
+
+      config = load_config(config_path, errors, warnings, files_checked, start, options[:format])
+      return 1 unless config
+
+      parser = Content::Parser.new(source_directory: project_dir)
+
+      config.collections.each do |collection_name, collection_config|
+        content_dir = File.join(project_dir, collection_config.path)
+
+        unless File.directory?(content_dir)
+          errors << issue(
+            rule_id: "COLLECTION_DIR_MISSING",
+            message: "Content directory not found for collection '#{collection_name}'",
+            file: collection_config.path,
+            suggestion: "Create the directory at #{collection_config.path}"
+          )
+          next
+        end
+
+        if collection_config.template
+          template_path = File.join(project_dir, collection_config.template)
+          unless File.file?(template_path)
+            errors << issue(
+              rule_id: "TEMPLATE_MISSING",
+              message: "Template not found for collection '#{collection_name}'",
+              file: collection_config.template,
+              suggestion: "Create the template file at #{collection_config.template}"
+            )
+          end
+        end
+
+        file_extension = collection_config.format || "md"
+        discover_content_files(content_dir, file_extension).each do |file_path|
+          files_checked += 1
+          relative_path = file_path.delete_prefix("#{project_dir}/")
+
+          document = parse_content_file(parser, file_path, file_extension, relative_path, errors)
+          next unless document
+
+          collection_config.validate_required_fields(document.metadata).each do |field|
+            errors << issue(
+              rule_id: "REQUIRED_FIELD_MISSING",
+              message: "Missing required field '#{field}' in collection '#{collection_name}'",
+              file: relative_path,
+              suggestion: "Add '#{field}' to the front matter"
+            )
+          end
+
+          next unless collection_config.slug
+
+          slug_config = collection_config.slug
+          slug_field = slug_config["field"] || slug_config[:field]
+          slug_fallback = slug_config["fallback"] || slug_config[:fallback]
+          slug_value = document.metadata[slug_field] || document.metadata[slug_fallback]
+          next unless slug_value.nil? || (slug_value.is_a?(String) && slug_value.empty?)
+
+          warnings << issue(
+            rule_id: "SLUG_MISSING",
+            message: "No slug or fallback value for collection '#{collection_name}'",
+            file: relative_path,
+            suggestion: "Add '#{slug_field}' or '#{slug_fallback}' to front matter"
+          )
+        end
+      end
+
+      duration_ms = elapsed_ms(start)
+      has_failed = !errors.empty? || (options[:strict] && !warnings.empty?)
+      status = has_failed ? "fail" : "pass"
+      output_result(status, errors, warnings, files_checked, duration_ms, options[:format])
+      has_failed ? 1 : 0
+    end
+
+    def parse_options(argv)
+      options = {
+        project: nil,
+        strict: false,
+        format: :human
+      }
+
+      i = 0
+      while i < argv.length
+        arg = argv[i]
+        case arg
+        when "--project"
+          options[:project] = argv[i += 1]
+        when "--strict"
+          options[:strict] = true
+        when "--format"
+          fmt = argv[i += 1].to_s.downcase
+          options[:format] = fmt == "json" ? :json : :human
+        else
+          warn "Unknown option: #{arg}"
+          raise ConfigError, "Unknown option: #{arg}"
+        end
+        i += 1
+      end
+
+      options
+    end
+
+    def resolve_project(options)
+      [ProjectResolver.resolve(explicit_path: options[:project]), nil]
+    rescue ConfigError => e
+      if options[:format] == :json
+        OutputFormatter.format_check_result(
+          status: "error",
+          errors: [issue(
+            rule_id: "PROJECT_NOT_FOUND",
+            message: e.message,
+            file: "",
+            suggestion: "Specify a project path with --project"
+          )],
+          warnings: [],
+          files_checked: 0,
+          duration_ms: 0,
+          format: :json
+        )
+      else
+        warn "Error: #{e.message}"
+      end
+      [nil, 2]
+    end
+
+    def load_config(config_path, errors, warnings, files_checked, start, format)
+      Content::Config.load(config_path)
+    rescue StandardError => e
+      errors << issue(
+        rule_id: "CONFIG_INVALID",
+        message: "content.config.json is invalid: #{e.message}",
+        file: "content.config.json",
+        suggestion: "Check the JSON syntax and structure"
+      )
+      duration_ms = elapsed_ms(start)
+      output_result("fail", errors, warnings, files_checked, duration_ms, format)
+      nil
+    end
+
+    def discover_content_files(content_dir, file_extension)
+      Dir.glob(File.join(content_dir, "**", "*")).select do |path|
+        File.file?(path) && File.extname(path).delete_prefix(".") == file_extension
+      end
+    end
+
+    def parse_content_file(parser, file_path, file_extension, relative_path, errors)
+      if file_extension == "md"
+        parser.parse_markdown_file(file_path)
+      else
+        parser.parse_yaml_file(file_path)
+      end
+    rescue StandardError => e
+      errors << issue(
+        rule_id: "PARSE_ERROR",
+        message: "Failed to parse content file: #{e.message}",
+        file: relative_path,
+        suggestion: "Check the file format and front matter syntax"
+      )
+      nil
+    end
+
+    def issue(rule_id:, message:, file:, suggestion:)
+      { rule_id: rule_id, message: message, file: file, suggestion: suggestion }
+    end
+
+    def output_result(status, errors, warnings, files_checked, duration_ms, format)
+      OutputFormatter.format_check_result(
+        status: status,
+        errors: errors,
+        warnings: warnings,
+        files_checked: files_checked,
+        duration_ms: duration_ms,
+        format: format
+      )
+    end
+
+    def elapsed_ms(start)
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).to_i
+    end
+  end
+end

data/lib/hammer/cli.rb

@@ -2,13 +2,17 @@
 
 module Hammer
   module CLI
+    KNOWN_COMMANDS = %w[build check].freeze
+
     module_function
 
     def run(argv)
-      command = argv.first == "build" ? argv.shift : "build"
+      command = resolve_command(argv)
       case command
       when "build"
         BuildCommand.run(argv)
+      when "check"
+        CheckCommand.run(argv)
       else
         warn "Unknown command: #{command}"
         2
@@ -23,5 +27,13 @@ module Hammer
       warn "Build failed: #{e.message}"
       1
     end
+
+    def resolve_command(argv)
+      return "build" if argv.empty?
+      return argv.shift if KNOWN_COMMANDS.include?(argv.first)
+      return "build" if argv.first.start_with?("-")
+
+      argv.first
+    end
   end
 end

data/lib/hammer/content/config.rb

@@ -22,6 +22,24 @@ module Hammer
         output&.dig("filename") || output_path
       end
 
+      def validate_required_fields(metadata)
+        return [] unless fields
+
+        missing = []
+        fields.each do |field_name, field_config|
+          next unless field_config.required == true
+
+          unless metadata.key?(field_name)
+            missing << field_name
+            next
+          end
+
+          value = metadata[field_name]
+          missing << field_name if value.is_a?(String) && value.empty?
+        end
+        missing
+      end
+
       def self.from_hash(hash)
         fields = (hash["fields"] || {}).transform_values { |f| FieldConfig.from_hash(f) }
         new(

data/lib/hammer/output_formatter.rb

@@ -29,5 +29,56 @@ module Hammer
         puts "Build finished in #{duration.round(2)}s — #{file_count} files (#{build_size})"
       end
     end
+
+    def format_check_result(status:, errors:, warnings:, files_checked:, duration_ms:, format:)
+      if format == :json
+        payload = {
+          "status" => status,
+          "errors" => errors.map { |e| check_issue_hash(e) },
+          "warnings" => warnings.map { |w| check_issue_hash(w) },
+          "stats" => {
+            "filesChecked" => files_checked,
+            "durationMs" => duration_ms
+          }
+        }
+        puts JSON.pretty_generate(payload)
+        return
+      end
+
+      puts ""
+      if status == "pass"
+        puts "\u2714 #{files_checked} files validated"
+      else
+        puts "\u2716 #{errors.length} error#{errors.length == 1 ? '' : 's'}"
+      end
+
+      errors.each do |error|
+        puts ""
+        puts "[#{error[:rule_id]}]"
+        puts error[:message]
+        puts "  #{error[:file]}"
+        puts "  Suggestion: #{error[:suggestion]}" if error[:suggestion]
+      end
+
+      unless warnings.empty?
+        puts ""
+        puts "\u26A0 #{warnings.length} warning#{warnings.length == 1 ? '' : 's'}"
+        warnings.each do |warning|
+          puts "  [#{warning[:rule_id]}] #{warning[:message]}"
+          puts "    #{warning[:file]}"
+        end
+      end
+      puts ""
+    end
+
+    def check_issue_hash(issue)
+      hash = {
+        "ruleId" => issue[:rule_id],
+        "message" => issue[:message],
+        "file" => issue[:file]
+      }
+      hash["suggestion"] = issue[:suggestion] if issue[:suggestion]
+      hash
+    end
   end
 end

data/lib/hammer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hammer
-  VERSION = "0.1.0.pre5"
+  VERSION = "0.1.0.pre7"
 end

data/spec/check_command_spec.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "fileutils"
+require "json"
+require "stringio"
+require "tmpdir"
+
+CONTENT_FIXTURE = File.expand_path("../../Test Projects/content-generation-test", __dir__)
+
+RSpec.describe Hammer::CheckCommand do
+
+  def capture_check(argv, project: CONTENT_FIXTURE)
+    out = StringIO.new
+    original = $stdout
+    $stdout = out
+    exit_code = Hammer::CheckCommand.run(["--project", project, *argv])
+    [out.string, exit_code]
+  ensure
+    $stdout = original
+  end
+
+  describe "content-generation-test fixture" do
+    it "passes validation" do
+      stdout, exit_code = capture_check(["--format", "json"])
+      result = JSON.parse(stdout)
+
+      expect(exit_code).to eq(0)
+      expect(result["status"]).to eq("pass")
+      expect(result["errors"]).to be_empty
+      expect(result["stats"]["filesChecked"]).to be > 0
+    end
+
+    it "passes with --strict when no warnings" do
+      _stdout, exit_code = capture_check(["--strict", "--format", "json"])
+      expect(exit_code).to eq(0)
+    end
+  end
+
+  describe "CONFIG_MISSING" do
+    it "passes with warning when not strict" do
+      Dir.mktmpdir do |dir|
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(0)
+        expect(result["status"]).to eq("pass")
+        expect(result["warnings"].map { |w| w["ruleId"] }).to include("CONFIG_MISSING")
+        expect(result["stats"]["filesChecked"]).to eq(0)
+      end
+    end
+
+    it "fails with --strict" do
+      Dir.mktmpdir do |dir|
+        stdout, exit_code = capture_check(["--strict", "--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["status"]).to eq("fail")
+        expect(result["warnings"].map { |w| w["ruleId"] }).to include("CONFIG_MISSING")
+      end
+    end
+  end
+
+  describe "CONFIG_INVALID" do
+    it "fails and does not scan files" do
+      Dir.mktmpdir do |dir|
+        File.write(File.join(dir, "content.config.json"), "{ invalid json")
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["status"]).to eq("fail")
+        expect(result["errors"].map { |e| e["ruleId"] }).to include("CONFIG_INVALID")
+        expect(result["stats"]["filesChecked"]).to eq(0)
+      end
+    end
+  end
+
+  describe "COLLECTION_DIR_MISSING" do
+    it "reports missing collection directory" do
+      Dir.mktmpdir do |dir|
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate(
+            "collections" => {
+              "posts" => { "path" => "content/missing" }
+            }
+          )
+        )
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["errors"].map { |e| e["ruleId"] }).to include("COLLECTION_DIR_MISSING")
+      end
+    end
+  end
+
+  describe "TEMPLATE_MISSING" do
+    it "reports missing template file" do
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir_p(File.join(dir, "content", "posts"))
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate(
+            "collections" => {
+              "posts" => {
+                "path" => "content/posts",
+                "template" => "templates/missing.html"
+              }
+            }
+          )
+        )
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["errors"].map { |e| e["ruleId"] }).to include("TEMPLATE_MISSING")
+      end
+    end
+  end
+
+  describe "REQUIRED_FIELD_MISSING" do
+    it "reports missing required front matter fields" do
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir_p(File.join(dir, "content", "posts"))
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate(
+            "collections" => {
+              "posts" => {
+                "path" => "content/posts",
+                "fields" => {
+                  "title" => { "type" => "string", "required" => true }
+                }
+              }
+            }
+          )
+        )
+        File.write(File.join(dir, "content", "posts", "no-title.md"), "---\ndate: 2024-01-01\n---\n\nBody")
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["errors"].map { |e| e["ruleId"] }).to include("REQUIRED_FIELD_MISSING")
+      end
+    end
+  end
+
+  describe "SLUG_MISSING" do
+    it "warns when slug and fallback are absent" do
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir_p(File.join(dir, "content", "posts"))
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate(
+            "collections" => {
+              "posts" => {
+                "path" => "content/posts",
+                "slug" => { "field" => "slug", "fallback" => "title" }
+              }
+            }
+          )
+        )
+        File.write(File.join(dir, "content", "posts", "post.md"), "---\ndate: 2024-01-01\n---\n\nBody")
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(0)
+        expect(result["warnings"].map { |w| w["ruleId"] }).to include("SLUG_MISSING")
+      end
+    end
+
+    it "fails with --strict" do
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir_p(File.join(dir, "content", "posts"))
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate(
+            "collections" => {
+              "posts" => {
+                "path" => "content/posts",
+                "slug" => { "field" => "slug", "fallback" => "title" }
+              }
+            }
+          )
+        )
+        File.write(File.join(dir, "content", "posts", "post.md"), "---\ndate: 2024-01-01\n---\n\nBody")
+        _stdout, exit_code = capture_check(["--strict", "--format", "json"], project: dir)
+        expect(exit_code).to eq(1)
+      end
+    end
+  end
+
+  describe "PARSE_ERROR" do
+    it "reports unparseable content files" do
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir_p(File.join(dir, "content", "posts"))
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate("collections" => { "posts" => { "path" => "content/posts" } })
+        )
+        allow(Hammer::Content::Parser).to receive(:new).and_wrap_original do |method, **kwargs|
+          parser = method.call(**kwargs)
+          allow(parser).to receive(:parse_markdown_file).and_raise(StandardError, "bad front matter")
+          parser
+        end
+        File.write(File.join(dir, "content", "posts", "bad.md"), "---\ntitle: ok\n---\n\nBody")
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["errors"].map { |e| e["ruleId"] }).to include("PARSE_ERROR")
+      end
+    end
+  end
+
+  describe "PROJECT_NOT_FOUND" do
+    it "returns exit 2 with JSON error status" do
+      stdout, exit_code = capture_check(["--format", "json"], project: "/nonexistent/path")
+      result = JSON.parse(stdout)
+
+      expect(exit_code).to eq(2)
+      expect(result["status"]).to eq("error")
+      expect(result["errors"].first["ruleId"]).to eq("PROJECT_NOT_FOUND")
+    end
+  end
+
+  describe "CollectionConfig#validate_required_fields" do
+    it "flags missing keys and empty strings" do
+      config = Hammer::Content::CollectionConfig.new(
+        fields: {
+          "title" => Hammer::Content::FieldConfig.new(required: true),
+          "count" => Hammer::Content::FieldConfig.new(required: true)
+        }
+      )
+
+      missing = config.validate_required_fields("title" => "", "count" => 0)
+      expect(missing).to contain_exactly("title")
+    end
+  end
+end
+
+RSpec.describe Hammer::CLI do
+  def capture_cli(argv)
+    out = StringIO.new
+    original = $stdout
+    $stdout = out
+    exit_code = Hammer::CLI.run(argv)
+    [out.string, exit_code]
+  ensure
+    $stdout = original
+  end
+
+  it "dispatches hammer check" do
+    stdout, exit_code = capture_cli(["check", "--project", CONTENT_FIXTURE, "--format", "json"])
+    result = JSON.parse(stdout)
+
+    expect(exit_code).to eq(0)
+    expect(result["status"]).to eq("pass")
+  end
+
+  it "defaults to build for flag-only invocation" do
+    stdout, exit_code = capture_cli(["--project", CONTENT_FIXTURE, "--format", "json", "--quiet"])
+    result = JSON.parse(stdout)
+
+    expect(exit_code).to eq(0)
+    expect(result["status"]).to eq("success")
+  end
+
+  it "returns exit 2 for unknown commands" do
+    _stdout, exit_code = capture_cli(["unknown"])
+    expect(exit_code).to eq(2)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: beachio-hammer
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre5
+  version: 0.1.0.pre7
 platform: ruby
 authors:
 - Beach.io
@@ -54,6 +54,7 @@ files:
 - lib/beachio-hammer.rb
 - lib/hammer/build_command.rb
 - lib/hammer/builder.rb
+- lib/hammer/check_command.rb
 - lib/hammer/cli.rb
 - lib/hammer/content/builder.rb
 - lib/hammer/content/config.rb
@@ -78,6 +79,7 @@ files:
 - scripts/test-content.rb
 - scripts/tree-diff.rb
 - spec/blog_listing_spec.rb
+- spec/check_command_spec.rb
 - spec/encoding_spec.rb
 - spec/parity/classic_spec.rb
 - spec/parity/content_spec.rb