okf 1.9.0 → 1.10.0

data/lib/okf/cli/index.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module OKF
+  class CLI
+    # The progressive-disclosure map (spec §6): every directory that holds concepts
+    # or carries an index.md, with its authored index body, a type/tag rollup, its
+    # child directories, and — for a directory with no index.md — the listing
+    # synthesized from the concepts there. The "orient before you read" view. `--area`
+    # is repeatable (one or many directories; `root` is the bundle root); `--no-body`
+    # drops the prose to a skeleton; advisory, exit 0.
+    class Index < Command
+      def self.id
+        :index
+      end
+
+      def self.group
+        :read
+      end
+
+      def self.help_rows
+        [
+          [ "index     <dir|@slug> [--json] [--area A] [--no-body]", "the index map: dirs, their listings and rollups" ]
+        ]
+      end
+
+      def call(argv)
+        options = { json: false, body: true, areas: nil }
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: okf index <dir|@slug> [--area AREA] [--no-body] [--json]"
+          json_flags(o, options, "emit the index map as JSON")
+          projection_flags(o, options)
+          o.on("--area AREA", "only this directory/area (repeatable; `root` for the bundle root)") { |v| (options[:areas] ||= []) << v }
+          o.on("--[no-]body", "include each index's prose body (default: yes)") { |v| options[:body] = v }
+          help_flag(o)
+        end
+        dir = positional_dir(parser, argv) or return 2
+
+        folder = OKF::Bundle::Folder.load(dir)
+        report_skipped(folder)
+        entries = folder.directory_index
+        selected = select_directories(entries, options[:areas])
+        if options[:json]
+          # --no-body is shorthand for --except body, so asking for the body by
+          # name in the same breath is a contradiction. Letting --fields quietly
+          # win would hand back the very thing the other flag was there to drop.
+          if !options[:body] && Array(options[:fields]).map(&:downcase).include?("body")
+            return usage_error("--no-body and --fields body contradict each other: drop one")
+          end
+
+          options[:except] = Array(options[:except]) + [ "body" ] unless options[:body] || options[:fields]
+          return print_index_map_json(dir, selected, options)
+        end
+        print_index_map(dir, selected, options[:body])
+        0
+      end
+
+      private
+
+      # Narrow the map to the named directories/areas — case-insensitive, `root`
+      # matching the bundle root (".") so no shell quoting is needed. No --area passed
+      # keeps the whole map.
+      def select_directories(entries, areas)
+        return entries if areas.nil? || areas.empty?
+
+        wanted = areas.map { |area| area.downcase == "root" ? "." : area.downcase }
+        entries.select { |entry| wanted.include?(entry[:dir].downcase) }
+      end
+
+      def print_index_map(dir, entries, body)
+        noun = entries.size == 1 ? "directory" : "directories"
+        @out.puts "Index map — #{bundle_label(dir)} (#{entries.size} #{noun})"
+        entries.each do |entry|
+          @out.puts
+          @out.puts "  #{index_dir_label(entry)}#{index_dir_meta(entry)}"
+          subdirs = entry[:subdirs]
+          @out.puts "    → #{subdirs.map { |sub| "#{File.basename(sub)}/" }.join("  ")}" unless subdirs.empty?
+          if entry[:present]
+            print_index_body(entry[:body]) if body
+          else
+            print_synthesized_listing(entry[:listing])
+          end
+        end
+      end
+
+      def index_dir_label(entry)
+        base = entry[:dir] == "." ? "(root)" : "#{entry[:dir]}/"
+        entry[:present] ? base : "#{base}  (no index.md)"
+      end
+
+      def index_dir_meta(entry)
+        count = "#{entry[:count]} #{pluralize(entry[:count], "concept")}"
+        types = entry[:types].map { |type, n| "#{OKF.blank?(type) ? "Untyped" : type} #{n}" }.join(", ")
+        types.empty? ? "  ·  #{count}" : "  ·  #{count} · #{types}"
+      end
+
+      def print_index_body(body)
+        text = body.to_s.strip
+        return if text.empty?
+
+        text.each_line { |line| @out.puts "    #{line.chomp}" }
+      end
+
+      def print_synthesized_listing(listing)
+        listing.each do |item|
+          suffix = item[:description].empty? ? "" : " — #{truncate(item[:description], 72)}"
+          @out.puts "    • #{item[:title]}#{suffix}"
+        end
+      end
+
+      def print_index_map_json(dir, entries, options)
+        emit_list_json(dir, "directories", entries.map { |entry| index_map_entry_json(entry) }, options)
+      end
+
+      def index_map_entry_json(entry)
+        {
+          "dir" => entry[:dir], "index_path" => entry[:index_path],
+          "present" => entry[:present], "synthesized" => entry[:synthesized],
+          "count" => entry[:count], "types" => entry[:types], "tags" => entry[:tags],
+          "subdirs" => entry[:subdirs], "body" => entry[:body],
+          "listing" => entry[:listing].map { |item| stringify(item) }
+        }
+      end
+    end
+
+    register(Index)
+  end
+end

data/lib/okf/cli/lint.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module OKF
+  class CLI
+    # The curation judge: is this bundle *good*? Advisory by design — findings
+    # never change the exit code unless --fail-on says so, because a stub or a
+    # loose leaf can be deliberate. Freshness is off unless --stale-after asks.
+    class Lint < Command
+      # Lint findings grouped for display, in category order.
+      LINT_CATEGORIES = {
+        "Reachability" => %i[orphan not_in_index disconnected_component unlinked],
+        "Backlog" => %i[missing_concept broken_index_entry],
+        "Completeness" => %i[stub missing_title missing_description missing_timestamp],
+        "Freshness" => %i[stale],
+        "Provenance" => %i[uncited_external broken_citation],
+        "Hygiene" => %i[duplicate_title unused_reference_def undefined_reference self_link]
+      }.freeze
+
+      def self.id
+        :lint
+      end
+
+      def self.group
+        :judge
+      end
+
+      def self.help_rows
+        [
+          [ "lint      <dir|@slug> [--json] [--fail-on warn] [...]", "report curation-quality issues" ]
+        ]
+      end
+
+      def call(argv)
+        options = { json: false, min_body: OKF::Bundle::Linter::DEFAULT_MIN_BODY, stale_after: nil, only: nil, except: nil, fail_on: :never }
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: okf lint <dir|@slug> [--json] [--min-body N] [--stale-after DUR] [--only a,b] [--except a,b] [--fail-on warn]"
+          json_flags(o, options, "emit a JSON report")
+          o.on("--min-body N", Integer, "stub threshold in body characters (default #{OKF::Bundle::Linter::DEFAULT_MIN_BODY})") { |v| options[:min_body] = v }
+          o.on("--stale-after DUR", "flag concepts older than DUR (e.g. 90d, 12w, 2026-01-01)") { |v| options[:stale_after] = v }
+          o.on("--only LIST", Array, "run only these checks (comma-separated)") { |v| options[:only] = v.map(&:to_sym) }
+          o.on("--except LIST", Array, "skip these checks (comma-separated)") { |v| options[:except] = v.map(&:to_sym) }
+          o.on("--fail-on LEVEL", %w[never warn], "exit 1 when a finding at LEVEL exists (never | warn)") { |v| options[:fail_on] = v.to_sym }
+          help_flag(o)
+        end
+        dir = positional_dir(parser, argv) or return 2
+
+        unknown = ((options[:only] || []) + (options[:except] || [])) - OKF::Bundle::Linter::CHECKS
+        unless unknown.empty?
+          @err.puts "error: unknown check(s): #{unknown.uniq.join(", ")}"
+          return 2
+        end
+
+        stale_before = parse_stale_after(options[:stale_after])
+        if stale_before == :invalid
+          @err.puts "error: invalid --stale-after `#{options[:stale_after]}` (use 90d, 12w, or an ISO date like 2026-01-01)"
+          return 2
+        end
+
+        folder = OKF::Bundle::Folder.load(dir)
+        report = folder.lint(min_body: options[:min_body], stale_before: stale_before, only: options[:only], except: options[:except])
+        note_skipped(report.stats[:skipped])
+        options[:json] ? print_lint_json(dir, report) : print_lint(dir, report)
+        options[:fail_on] == :warn && report.warnings.any? ? 1 : 0
+      end
+
+      private
+
+      # Turn a --stale-after value (90d, 12w, or an ISO date) into an absolute cutoff
+      # Time so the pure Linter never reads the clock. nil when unset, :invalid on a
+      # bad value.
+      def parse_stale_after(value)
+        return nil if value.nil?
+
+        if (match = value.match(/\A(\d+)([dw])\z/))
+          days = match[1].to_i * (match[2] == "w" ? 7 : 1)
+          Time.now - (days * 86_400)
+        else
+          Date.iso8601(value).to_time
+        end
+      rescue ArgumentError
+        :invalid
+      end
+
+      def print_lint(dir, report)
+        stats = report.stats
+        @out.puts "OKF lint — #{bundle_label(dir)}"
+        @out.puts "  concepts: #{stats[:concepts]}   edges: #{stats[:edges]}   index.md: #{stats[:indexes]}   log.md: #{stats[:logs]}"
+        summary = lint_summary(stats)
+        @out.puts "  #{summary}" unless summary.empty?
+
+        LINT_CATEGORIES.each do |name, checks|
+          findings = report.findings.select { |finding| checks.include?(finding[:check]) }
+          next if findings.empty?
+
+          @out.puts
+          @out.puts "  #{name}"
+          findings.each do |finding|
+            @out.puts "    #{lint_glyph(finding)}  #{[ finding[:path], finding[:message] ].compact.join(": ")}"
+          end
+        end
+
+        @out.puts
+        @out.puts "  #{lint_verdict(report)}"
+      end
+
+      def print_lint_json(dir, report)
+        emit_json(bundle_head(dir).merge(
+          "healthy" => report.healthy?,
+          "stats" => report.stats,
+          "findings" => report.findings
+        ))
+      end
+
+      def lint_summary(stats)
+        parts = []
+        hubs = stats[:hubs].map { |hub| "#{hub[:id]} (×#{hub[:in_degree]})" }.join(", ")
+        types = stats[:types].map { |type, count| "#{type} #{count}" }.join(", ")
+        parts << "hubs: #{hubs}" unless hubs.empty?
+        parts << "types: #{types}" unless types.empty?
+        parts.join("   ")
+      end
+
+      def lint_glyph(finding)
+        finding[:severity] == :warn ? paint("! warn", 33) : "· info"
+      end
+
+      def lint_verdict(report)
+        warnings = report.warnings.size
+        infos = report.info.size
+        return paint("✓ healthy — no issues", 32) if warnings.zero? && infos.zero?
+
+        marker = warnings.zero? ? paint("✓", 32) : paint("⚠", 33)
+        "#{marker} #{warnings} warn, #{infos} info"
+      end
+    end
+
+    register(Lint)
+  end
+end

data/lib/okf/cli/loose.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module OKF
+  class CLI
+    # List the "loose" files — concepts with graph degree 0 (no cross-links in or
+    # out), grouped by folder. A folder-grouped view over lint's `unlinked` check,
+    # for the common "which files float in the graph?" question. Advisory (exit 0):
+    # a terminal leaf can be loose by design. `--json` for a machine substrate.
+    class Loose < Command
+      def self.id
+        :loose
+      end
+
+      def self.group
+        :judge
+      end
+
+      def self.help_rows
+        [
+          [ "loose     <dir|@slug> [--json]", "list files with no graph links, by folder" ]
+        ]
+      end
+
+      def call(argv)
+        options = { json: false }
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: okf loose <dir|@slug> [--json]"
+          json_flags(o, options, "emit the loose files as JSON")
+          help_flag(o)
+        end
+        dir = positional_dir(parser, argv) or return 2
+
+        folder = OKF::Bundle::Folder.load(dir)
+        report_skipped(folder)
+        files = loose_files(folder.graph(minimal: true))
+        options[:json] ? print_loose_json(dir, files) : print_loose(dir, files)
+        0
+      end
+
+      private
+
+      # Degree-0 nodes as { id:, title:, dir: }, sorted by path — the same set lint's
+      # `unlinked` check reports, resolved to titles/folders for display.
+      def loose_files(graph)
+        titles = graph.nodes.map { |node| [ node[:id], node[:title] ] }.to_h
+        graph.unlinked_ids
+             .map { |id| { id: id, title: titles[id], dir: File.dirname("#{id}.md") } }
+             .sort_by { |file| file[:id] }
+      end
+
+      def print_loose(dir, files)
+        @out.puts "Loose files — #{bundle_label(dir)} (#{files.size})"
+        if files.empty?
+          @out.puts "  #{paint("✓ none — every concept links or is linked", 32)}"
+          return
+        end
+
+        files.group_by { |file| file[:dir] }.sort_by(&:first).each do |folder, group|
+          width = group.map { |file| File.basename("#{file[:id]}.md").length }.max
+          @out.puts
+          @out.puts "  #{folder == "." ? "(root)" : "#{folder}/"}"
+          group.each do |file|
+            @out.puts "    #{File.basename("#{file[:id]}.md").ljust(width)}  #{file[:title]}"
+          end
+        end
+      end
+
+      def print_loose_json(dir, files)
+        emit_json(bundle_head(dir).merge(
+          "count" => files.size,
+          "loose" => files.map { |file| stringify(file) }
+        ))
+      end
+    end
+
+    register(Loose)
+  end
+end

data/lib/okf/cli/registry.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module OKF
+  class CLI
+    # The registry umbrella, split by what each verb keys on. `set`/`del`/`list`
+    # act on entries — `set` keys on the bundle's path, so --as means one thing
+    # ("the slug this entry has") whether it adds or renames. `default`/`rename`
+    # act on slugs, the names actually to hand once a bundle is registered. Every
+    # positional stays unambiguous, and `config` is left free for real settings.
+    class Registry < Command
+      # The `registry` umbrella's subcommands — the dispatch, and the words a
+      # flag-first invocation is checked against.
+      SUBCOMMANDS = %w[set del list default rename].freeze
+
+      def self.id
+        :registry
+      end
+
+      def self.group
+        :registry
+      end
+
+      def self.help_rows
+        [
+          [ "registry  list [--json]", "list registered bundles (* marks the default)" ],
+          [ "registry  set <dir|@slug> [--as SLUG] [--default]", "add or update a bundle (a bare `server` serves them)" ],
+          [ "registry  del <dir|@slug>", "remove a bundle from the registry" ],
+          [ "registry  default <@slug>", "move a bundle to the front (the default)" ],
+          [ "registry  rename <@slug> <new>", "rename a registered bundle (<new> is a new name, not a ref)" ]
+        ]
+      end
+
+      def call(argv)
+        require "okf/registry"
+
+        sub = argv.first
+        case sub
+        when "set" then registry_set(argv.drop(1))
+        when "del" then registry_del(argv.drop(1))
+        when "list" then registry_list(argv.drop(1))
+        when "default" then registry_default(argv.drop(1))
+        when "rename" then registry_rename(argv.drop(1))
+        else
+          # A bare word that isn't a known subcommand is a typo (`registry remove x`
+          # must not silently render the list and read as success).
+          return usage_error("unknown registry subcommand '#{sub}' (expected: #{SUBCOMMANDS.join(", ")})") if sub && !sub.start_with?("-")
+
+          # Same rule for a subcommand hiding behind a flag: `registry --json set
+          # dir` would otherwise list an empty registry and exit 0, having written
+          # nothing the user asked for. It cannot just be dispatched from wherever
+          # it turns up — the word may be a flag's value (`registry --as set <dir>`
+          # asks for the slug "set"), and a grammar where that reading depends on
+          # which flag precedes it is a trapdoor. So the subcommand must lead, and
+          # the error says which one was found rather than guessing at the intent.
+          stray = argv.find { |arg| SUBCOMMANDS.include?(arg) }
+          return usage_error("put the subcommand first: okf registry #{stray} … (flags follow it)") if stray
+
+          registry_list(argv)
+        end
+      end
+
+      private
+
+      # Add a bundle to the persistent registry (so a later bare `okf server` finds
+      # it), or update one already there. The entry is keyed by the bundle's path: a
+      # path already registered refreshes its title in place, and --as renames it. A
+      # new path is added, slugged by directory basename unless --as says otherwise.
+      def registry_set(argv)
+        options = { as: nil, default: false }
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: okf registry set <dir|@slug> [--as SLUG] [--default]"
+          o.on("--as SLUG", "slug to register under (default: directory basename)") { |v| options[:as] = v }
+          o.on("--default", "put it first — the bundle a bare `okf server` opens") { options[:default] = true }
+          help_flag(o)
+        end
+        # No no_extras? here: positional_dir has already refused a trailing
+        # argument. The sibling subcommands need the call because they take their
+        # positional through `positional`, which does not check.
+        dir = positional_dir(parser, argv) or return 2
+
+        reg = OKF::Registry.load
+        # Said before the upsert: after it, an update is indistinguishable from an
+        # add, and "registered" for what was a rename reads as a duplicate entry.
+        known = reg.listing.any? { |row| row[:dir] == File.expand_path(dir) }
+        entry = reg.add(dir, as: options[:as], default: options[:default])
+        # Through report_skipped like every other bundle-reading verb: the reader
+        # tolerates a file it cannot open, so a count taken straight off the graph
+        # reports "0 concepts" for a bundle whose files are simply unreadable.
+        folder = OKF::Bundle::Folder.load(entry.path)
+        report_skipped(folder)
+        count = folder.graph(minimal: true).nodes.size
+        @out.puts "#{known ? "updated" : "registered"} #{entry.slug} → #{entry.path} (#{count} #{pluralize(count, "concept")})"
+        0
+      rescue OKF::Error => e
+        usage_error(e.message)
+      end
+
+      # Remove a bundle from the persistent registry by slug or by its directory.
+      def registry_del(argv)
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: okf registry del <dir|@slug>"
+          help_flag(o)
+        end
+        slug = positional(parser, argv) or return 2
+        no_extras?(argv) or return 2
+
+        reg = OKF::Registry.load
+        slug = registry_slug(slug, reg) or return 2
+        removed = reg.remove(slug)
+        return usage_error("no such bundle: #{slug}") unless removed
+
+        @out.puts "removed #{removed.slug}"
+        0
+      rescue OKF::Error => e
+        usage_error(e.message)
+      end
+
+      def registry_list(argv)
+        options = { json: false }
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: okf registry list [--json] [--pretty]\n       " \
+                     "okf registry set <dir|@slug> | del <dir|@slug> | default <@slug> | rename <@slug> <new>"
+          json_flags(o, options, "emit the registry as JSON")
+          help_flag(o)
+        end
+        begin
+          parser.parse!(argv)
+        rescue OptionParser::ParseError => e
+          @err.puts e.message
+          return 2
+        end
+        no_extras?(argv) or return 2
+
+        reg = OKF::Registry.load
+        return emit_list_json({ "registry" => reg.path }, "bundles", reg.listing.map { |row| stringify(row) }, options) if options[:json]
+
+        print_registry(reg)
+        0
+      rescue OKF::Error => e
+        usage_error(e.message)
+      end
+
+      # Choose which registered bundle a bare `okf server` opens at `/`, by moving
+      # it to the front of the registry. The listing is ordered and the JSON is
+      # meant to be hand-editable, so the move is stated rather than left to be
+      # discovered from a reordered file.
+      def registry_default(argv)
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: okf registry default <@slug>\n       " \
+                     "moves it to the front — the first registered bundle is the default until you do"
+          help_flag(o)
+        end
+        slug = positional(parser, argv) or return 2
+        no_extras?(argv) or return 2
+
+        reg = OKF::Registry.load
+        slug = registry_slug(slug, reg) or return 2
+        reg.default = slug
+        @out.puts "default bundle → #{reg.default.slug} (now first)"
+        0
+      rescue OKF::Error => e
+        usage_error(e.message)
+      end
+
+      # The @ref grammar for a verb that takes a *slug*, read by name. These three
+      # must reach an entry whose directory is gone — that is the one worth
+      # deleting or renaming — so they cannot go through resolve_ref, which
+      # insists the directory exist. Without this the refs only appeared to work:
+      # `normalize` strips the `@` off `@slug`, so `default @slug` resolved by
+      # accident while a bare `@` normalized to "" and failed. Returns the slug,
+      # or nil after reporting.
+      def registry_slug(arg, registry)
+        return arg unless arg.start_with?("@")
+
+        asked = arg[1..-1]
+        return asked unless asked.empty?
+
+        default = registry.default
+        return default.slug if default
+
+        @err.puts "error: no bundle is registered, so `@` names nothing (okf registry set <dir>)"
+        nil
+      end
+
+      # Rename a registered bundle's slug — its mount path and switcher name.
+      def registry_rename(argv)
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: okf registry rename <@slug> <new>"
+          help_flag(o)
+        end
+        parser.parse!(argv)
+        old_slug, new_slug = argv.shift(2)
+        if old_slug.nil? || new_slug.nil?
+          @err.puts parser.banner
+          return 2
+        end
+        no_extras?(argv) or return 2
+
+        reg = OKF::Registry.load
+        # The old name may be a ref; the new one is a name being minted, never one.
+        old_slug = registry_slug(old_slug, reg) or return 2
+        entry = reg.rename(old_slug, new_slug)
+        # The slug it *found*, not the argv that found it: rename normalizes to look
+        # the entry up, so echoing the raw ask names a bundle that never existed.
+        @out.puts "renamed #{OKF::Registry.normalize(old_slug)} → #{entry.slug}"
+        0
+      rescue OptionParser::ParseError => e
+        @err.puts e.message
+        2
+      rescue OKF::Error => e
+        usage_error(e.message)
+      end
+
+      def print_registry(reg)
+        return @out.puts "no bundles registered — okf registry set <dir>" if reg.empty?
+
+        rows = reg.listing
+        width = rows.map { |row| row[:slug].length }.max
+        rows.each do |row|
+          marker = row[:default] ? "*" : " "
+          missing = row[:missing] ? "  (missing)" : ""
+          @out.puts "#{marker} #{row[:slug].ljust(width)}  #{row[:title]}  (#{row[:dir]})#{missing}"
+        end
+      end
+    end
+
+    register(Registry)
+  end
+end

data/lib/okf/cli/render.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module OKF
+  class CLI
+    # The static counterpart to `server`: bake the whole bundle into one
+    # self-contained HTML file (bodies, catalog, index, logs baked in, no server
+    # needed — e.g. hosting on GitHub Pages). Prints to stdout unless -o is given.
+    class Render < Command
+      def self.id
+        :render
+      end
+
+      def self.group
+        :act
+      end
+
+      def self.help_rows
+        [
+          [ "render    <dir|@slug> [-o FILE] [--layout NAME] [...]", "write a static, self-contained HTML graph" ]
+        ]
+      end
+
+      def call(argv)
+        require "okf/render/graph"
+
+        options = { output: nil, title: nil, link: nil, layout: "cose" }
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: okf render <dir|@slug> [-o FILE] [--layout NAME] [-t title] [-l url]"
+          o.on("-o", "--output FILE", "write to FILE instead of stdout") { |v| options[:output] = v }
+          o.on("-t", "--title TITLE", "graph title (default: parent/bundle dir name)") { |v| options[:title] = v }
+          o.on("-l", "--link URL", "source URL shown in the header") { |v| options[:link] = v }
+          o.on("--layout NAME", OKF::Render::Graph::LAYOUTS, "initial layout (#{OKF::Render::Graph::LAYOUTS.join(", ")})") { |v| options[:layout] = v }
+          help_flag(o)
+        end
+        dir = positional_dir(parser, argv) or return 2
+
+        folder = OKF::Bundle::Folder.load(dir)
+        report_skipped(folder)
+        html = OKF::Render::Graph.static(folder, title: options[:title], link: options[:link], layout: options[:layout])
+        if options[:output]
+          # A bad -o path (a missing directory, a permission denial) is a bad
+          # *argument*: exit 2 with the reason, never a backtrace and an exit code
+          # that means "failing bundle".
+          begin
+            File.write(options[:output], html)
+          rescue SystemCallError => e
+            return usage_error("cannot write #{options[:output]}: #{e.message}")
+          end
+          # Off the bundle, not a second graph: Graph.build maps one node per
+          # concept, so the counts are identical — and Folder#graph is not
+          # memoized, so asking for one here would build a whole second graph
+          # (Render::Graph.static already built one) to print one number. Only
+          # the graph, to be exact: the concepts are parsed once at Folder.load
+          # and Graph.build reads them from memory, so this costs no disk.
+          count = folder.bundle.concepts.size
+          @out.puts "wrote #{count} #{pluralize(count, "concept")} to #{options[:output]}"
+        else
+          @out.print html
+        end
+        0
+      end
+    end
+
+    register(Render)
+  end
+end