diogenes 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8590686fd3f111b4286290f58a9ca7818201a3693c57bd141bf9e63eed0faecc
-  data.tar.gz: 9cc0cd2735ca360cefc82bf7c53116f9603ac00ee738e7c3729efbd8aaf3ab9f
+  metadata.gz: 59e0697472a007da996d52c2c52049bd875d48a06bb4c9747e87d60aeb81977f
+  data.tar.gz: 9802457c4c57f7fbf9aa78a97026c96b862138e2d1f4d00fe07a6ceabf174009
 SHA512:
-  metadata.gz: 8338868da9847a7eace4b9fa0379de833ca6d94716b97f4c71e34b06f735804d3b41ad9b7457560566487698b01f60fa828b4486a8a298c6aec7df327a8f12ce
-  data.tar.gz: 3e9270df51a313e335513c13a2d576d43bf2900c81c270ad7e82233ea4a6df46a76b37bebbdd4b5bb151b99a9e6b630c5e222e411ec3d8b406d3242d4cbc5496
+  metadata.gz: be715cb566e8eb48fad63ee0a0c4b4c53d5907a45d93b6f8366fd1a5aa2b6966b37f80d88fbe6ab64789d0756b290c82d8b4dfebb00b06568a9d48a15c09d7af
+  data.tar.gz: 743a2837f4d2a4e6f97942d36956dc08f2b69507c04e3ea19e56e33159fb75f65263c0f92e3c8429c14a75b37ba8b8fdf4c1aff1d769e85e04797f5a38915429

data/.agents/skills/evaluate-feature/SKILL.md

@@ -0,0 +1,27 @@
+# /evaluate-feature
+
+Walk a proposed AI feature through the five Diogenes gates
+
+## Prompt
+
+You are helping a Ruby developer evaluate whether a proposed AI feature
+should be built. Walk them through each of the five Diogenes gates in order,
+asking focused questions and surfacing the failure mode clearly if a gate fails.
+
+The feature being evaluated: {{input}}
+
+The five gates are:
+1. Failure Mode — What happens when this feature is wrong? Is the failure recoverable?
+2. User Verifiable — Can the average user tell when it's wrong?
+3. Human in the Loop — Is there a real human checking, with time and authority to intervene?
+4. Observability — Do you have monitoring to know when it's going wrong in production?
+5. Right Tool — Is AI the right answer, or just the exciting one?
+
+For each gate:
+- State the gate name and the Ruby principle it maps to
+- Ask one focused question to determine pass or fail
+- State the verdict clearly (PASS or FAIL)
+- If FAIL: explain why and suggest what the right approach is instead
+
+At the end, generate a structured decision record with a summary verdict:
+PROCEED, REJECT, or PROCEED WITH CONDITIONS.

data/.claude/skills/evaluate-feature/SKILL.md

@@ -0,0 +1,27 @@
+# /evaluate-feature
+
+Walk a proposed AI feature through the five Diogenes gates
+
+## Prompt
+
+You are helping a Ruby developer evaluate whether a proposed AI feature
+should be built. Walk them through each of the five Diogenes gates in order,
+asking focused questions and surfacing the failure mode clearly if a gate fails.
+
+The feature being evaluated: {{input}}
+
+The five gates are:
+1. Failure Mode — What happens when this feature is wrong? Is the failure recoverable?
+2. User Verifiable — Can the average user tell when it's wrong?
+3. Human in the Loop — Is there a real human checking, with time and authority to intervene?
+4. Observability — Do you have monitoring to know when it's going wrong in production?
+5. Right Tool — Is AI the right answer, or just the exciting one?
+
+For each gate:
+- State the gate name and the Ruby principle it maps to
+- Ask one focused question to determine pass or fail
+- State the verdict clearly (PASS or FAIL)
+- If FAIL: explain why and suggest what the right approach is instead
+
+At the end, generate a structured decision record with a summary verdict:
+PROCEED, REJECT, or PROCEED WITH CONDITIONS.

data/.cursor/rules/diogenes.mdc

@@ -0,0 +1,40 @@
+---
+description: Diogenes AI feature decision framework
+alwaysApply: true
+---
+
+<!-- Generated by `diogenes build --target cursor`. Edit sources in `.diogenes/` and rebuild. Do not edit directly. -->
+
+## Rules
+
+### five_gates
+
+## The Five Diogenes Gates
+
+When evaluating or building AI features, apply these gates in order.
+A gate failure is information, not a verdict — but it must be addressed
+before shipping.
+
+**Gate 1 — Failure Mode** (Least surprise at scale)
+What happens when this feature is wrong? Recoverable failures pass.
+Embarrassing failures pass with conditions. Catastrophic failures do not pass.
+
+**Gate 2 — User Verifiable** (Trust requires verification)
+Can the average user tell when the output is wrong? If the user lacks
+domain expertise to evaluate AI output, the feature creates a confidence gap.
+
+**Gate 3 — Human in the Loop** (Human-centered design, genuinely)
+Is there a human with time, context, and authority to actually intervene?
+Rubber-stamping is not a loop.
+
+**Gate 4 — Observability** (Craftsmanship — you wouldn't ship blind)
+Do you have monitoring to detect when this feature degrades in production?
+Silent degradation is worse than no feature.
+
+**Gate 5 — Right Tool** (Convention over configuration)
+Is AI the right answer, or just the exciting one? Prefer the boring,
+predictable software alternative when it serves the same need.
+
+## Skills
+
+- **/evaluate-feature** — Walk a proposed AI feature through the five Diogenes gates

data/.diogenes/artifacts/decision_record.md.erb

@@ -0,0 +1,44 @@
+# AI Feature Decision Record
+
+**Feature:** <%= feature_name %>
+**Date:** <%= Date.today.strftime("%Y-%m-%d") %>
+**Evaluator:** <%= evaluator %>
+**Verdict:** <%= verdict %>
+
+---
+
+## Gate Results
+
+| Gate | Principle | Result | Reason |
+|------|-----------|--------|--------|
+| Failure Mode | Least surprise at scale | <%= gate_result(:failure_mode) %> | <%= gate_reason(:failure_mode) %> |
+| User Verifiable | Trust requires verification | <%= gate_result(:user_verifiable) %> | <%= gate_reason(:user_verifiable) %> |
+| Human in the Loop | Human-centered design, genuinely | <%= gate_result(:human_in_loop) %> | <%= gate_reason(:human_in_loop) %> |
+| Observability | Craftsmanship — you wouldn't ship blind | <%= gate_result(:observability) %> | <%= gate_reason(:observability) %> |
+| Right Tool | Convention over configuration | <%= gate_result(:right_tool) %> | <%= gate_reason(:right_tool) %> |
+
+---
+
+## Verdict: <%= verdict %>
+
+<% if verdict == "REJECT" || verdict == "PROCEED WITH CONDITIONS" -%>
+### Recommended Alternative or Mitigation
+
+<%= alternative.empty? ? "_No alternative or mitigation described._" : alternative %>
+
+<% end -%>
+<% if verdict == "PROCEED WITH CONDITIONS" -%>
+### Conditions for Proceeding
+
+<%= conditions.empty? ? "_No conditions specified._" : conditions %>
+
+<% end -%>
+---
+
+## Notes
+
+<%= notes.empty? ? "_No additional notes._" : notes %>
+
+---
+
+*Generated by [Diogenes](https://github.com/meaganewaller/diogenes)*

data/.diogenes/diogenes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Diogenes project configuration.
+# Run `diogenes build --all` after changing source files.
+
+Diogenes.configure do
+  name "My Project"
+  description "AI agent configuration for this project"
+
+  targets :claude_code, :cursor
+
+  artifacts_dir "docs/decisions"
+end

data/.diogenes/hooks/README.md

@@ -0,0 +1,15 @@
+# Hooks
+
+Hooks define event-triggered behaviors that run automatically during agent sessions.
+
+Add `.rb` files to this directory when you're ready. Example:
+
+```ruby
+Diogenes.hook "run_tests_before_commit" do
+  trigger     "PreToolUse"
+  description "Remind the agent to run tests before committing"
+  prompt      <<~PROMPT
+    Before making any git commit, run the test suite and confirm it passes.
+  PROMPT
+end
+```

data/.diogenes/rules/five_gates.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+Diogenes.rule "five_gates" do
+  description "The five Diogenes gates — default ruleset for AI feature decisions"
+
+  content <<~RULE
+    ## The Five Diogenes Gates
+
+    When evaluating or building AI features, apply these gates in order.
+    A gate failure is information, not a verdict — but it must be addressed
+    before shipping.
+
+    **Gate 1 — Failure Mode** (Least surprise at scale)
+    What happens when this feature is wrong? Recoverable failures pass.
+    Embarrassing failures pass with conditions. Catastrophic failures do not pass.
+
+    **Gate 2 — User Verifiable** (Trust requires verification)
+    Can the average user tell when the output is wrong? If the user lacks
+    domain expertise to evaluate AI output, the feature creates a confidence gap.
+
+    **Gate 3 — Human in the Loop** (Human-centered design, genuinely)
+    Is there a human with time, context, and authority to actually intervene?
+    Rubber-stamping is not a loop.
+
+    **Gate 4 — Observability** (Craftsmanship — you wouldn't ship blind)
+    Do you have monitoring to detect when this feature degrades in production?
+    Silent degradation is worse than no feature.
+
+    **Gate 5 — Right Tool** (Convention over configuration)
+    Is AI the right answer, or just the exciting one? Prefer the boring,
+    predictable software alternative when it serves the same need.
+  RULE
+end

data/.diogenes/skills/example_skill.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Example skill demonstrating the full Diogenes skill DSL.
+# Copy this file, rename it, and customize the values for your project.
+
+Diogenes.skill "evaluate_feature" do
+  command "/evaluate-feature"
+  description "Walk a proposed AI feature through the five Diogenes gates"
+
+  prompt <<~PROMPT
+    You are helping a Ruby developer evaluate whether a proposed AI feature
+    should be built. Walk them through each of the five Diogenes gates in order,
+    asking focused questions and surfacing the failure mode clearly if a gate fails.
+
+    The feature being evaluated: {{input}}
+
+    The five gates are:
+    1. Failure Mode — What happens when this feature is wrong? Is the failure recoverable?
+    2. User Verifiable — Can the average user tell when it's wrong?
+    3. Human in the Loop — Is there a real human checking, with time and authority to intervene?
+    4. Observability — Do you have monitoring to know when it's going wrong in production?
+    5. Right Tool — Is AI the right answer, or just the exciting one?
+
+    For each gate:
+    - State the gate name and the Ruby principle it maps to
+    - Ask one focused question to determine pass or fail
+    - State the verdict clearly (PASS or FAIL)
+    - If FAIL: explain why and suggest what the right approach is instead
+
+    At the end, generate a structured decision record with a summary verdict:
+    PROCEED, REJECT, or PROCEED WITH CONDITIONS.
+  PROMPT
+end

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "0.1.7"
+    ".": "0.1.8"
 }

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.1.8](https://github.com/meaganewaller/diogenes/compare/diogenes/v0.1.7...diogenes/v0.1.8) (2026-06-27)
+
+
+### Features
+
+* **build:** emit agent config files from .diogenes/ sources :rocket: ([#15](https://github.com/meaganewaller/diogenes/issues/15)) ([d2727b6](https://github.com/meaganewaller/diogenes/commit/d2727b6fa51e0646e4042e24ad665bf740642d34))
+
 ## [0.1.7](https://github.com/meaganewaller/diogenes/compare/diogenes/v0.1.6...diogenes/v0.1.7) (2026-06-27)
 
 

data/CLAUDE.md

@@ -1,146 +1,42 @@
-# Diogenes — Claude Instructions
+# Agent Configuration
 
-> This file is generated by `diogenes build --target claude-code`.
-> Edit the source in `.diogenes/` and rebuild. Do not edit this file directly.
-
----
-
-## What This Gem Is
-
-Diogenes is a Ruby gem with two surfaces:
-
-**CLI / Build Tool** — Takes a canonical `.diogenes/` source (skills, rules, hooks, artifacts defined in a Ruby DSL) and builds agent-specific configuration files for Claude Code, Cursor, Copilot, Codex, Gemini, and other agents. One source of truth, many targets.
-
-**Runtime Library** — A `Diogenes::Gated` module you include in Ruby classes that touch AI. It enforces a five-gate decision framework at class load time (loud in development, graceful in production) and provides RSpec/Minitest matchers so gate decisions live in the test suite.
-
-The gem is grounded in a decision framework for AI features derived from Ruby's core principles: least surprise, programmer happiness, and human-centered design.
-
----
-
-## Codebase Map
-
-```text
-lib/
-├── diogenes.rb                  # entry point, autoloads, top-level configure block
-├── diogenes/
-│   ├── cli/                     # Thor-based CLI commands
-│   │   ├── init.rb              # diogenes init
-│   │   ├── build.rb             # diogenes build
-│   │   ├── evaluate.rb          # diogenes evaluate (interactive)
-│   │   └── validate.rb          # diogenes validate
-│   ├── dsl/                     # source format DSL
-│   │   ├── skill.rb             # Diogenes.skill { ... }
-│   │   ├── rule.rb              # Diogenes.rule { ... }
-│   │   ├── hook.rb              # Diogenes.hook { ... }
-│   │   └── artifact.rb          # Diogenes.artifact { ... }
-│   ├── gates/                   # one file per gate
-│   │   ├── base.rb              # shared validation interface
-│   │   ├── failure_mode.rb      # Gate 1
-│   │   ├── user_verifiable.rb   # Gate 2
-│   │   ├── human_in_loop.rb     # Gate 3
-│   │   ├── observability.rb     # Gate 4
-│   │   └── right_tool.rb        # Gate 5
-│   ├── targets/                 # one file per agent target
-│   │   ├── base.rb              # shared emit interface
-│   │   ├── claude_code.rb       # .claude/ + CLAUDE.md
-│   │   ├── cursor.rb            # .cursor/rules/
-│   │   ├── copilot.rb           # .github/copilot-instructions.md
-│   │   ├── codex.rb             # codex-instructions.md + tools.json
-│   │   └── gemini.rb            # .gemini/instructions.md
-│   ├── runtime/                 # the Gated module and GateResult
-│   │   ├── gated.rb             # include Diogenes::Gated
-│   │   ├── gate_result.rb       # structured pass/fail response
-│   │   └── environment.rb       # development vs production behaviour
-│   └── rspec/                   # RSpec matchers
-│       └── matchers.rb          # have_gate, pass_gate, fail_gate
-spec/                            # mirrors lib/
-exe/
-└── diogenes                     # CLI entry point
-.diogenes/                       # this gem's own canonical source
-```
-
----
-
-## Key Conventions
-
-**Error messages are human.** When a gate fails or a configuration is invalid, the message should say what happened, why it matters, and what to do instead. Not just what went wrong — what to do about it.
-
-**Development is loud, production is graceful.** Gate failures raise in development (`Diogenes::GateFailed`), return a `GateResult` in production. Environment is detected via `Rails.env` if present, otherwise `ENV["DIOGENES_ENV"]`.
-
-**The DSL is the source of truth.** Nothing in `lib/` should have an opinion about what format a particular agent uses. Targets do the translation. Gates do the validation. The DSL holds the intent.
-
-**Agent-agnostic means agent-agnostic.** When working on a target, resist any temptation to leak target-specific concepts into the DSL or gates. A skill is a skill. A rule is a rule. The target decides what to do with them.
-
----
+> Generated by `diogenes build --target claude-code`. Edit sources in `.diogenes/` and rebuild. Do not edit directly.
 
 ## Available Skills
 
-Use these commands in any Claude session while working on this gem:
+### /evaluate-feature
 
-### `/evaluate-feature <description>`
-
-Walk a proposed gem feature through the five Diogenes gates. Yes, the gem evaluates itself. Produces a decision record you should commit alongside the PR.
-
-*Use when:* You're about to build something new and want to check it against the framework before writing code.
-
-### `/new-target <agent-name>`
-
-Scaffold a new build target. Generates `lib/diogenes/targets/<name>.rb`, the corresponding spec file, and a stub entry in `docs/targets.md`.
-
-*Use when:* Adding support for a new agent.
-
-### `/review-philosophy`
-
-Review the current working context (open files, recent changes) for alignment with Diogenes' principles. Flags anything that feels like scope creep, API surface bloat, or a violation of the "agent-agnostic source" rule.
-
-*Use when:* You've been in the weeds for a while and want a sanity check.
-
-### `/generate-stories <feature description>`
-
-Draft user stories with acceptance criteria for a proposed feature, scoped to the demo or the full roadmap depending on what you specify.
-
-*Use when:* Scoping new work before opening a PR.
-
-### `/gate-schema <gate-name> <option-name>`
-
-Help design the schema and validation logic for a new gate option. Asks targeted questions about what passes, what fails, and what the failure message should say.
-
-*Use when:* Adding new options to an existing gate.
-
----
+Walk a proposed AI feature through the five Diogenes gates
 
 ## Active Rules
 
-These apply to every session working on this gem:
+### five_gates
 
-**Stay agent-agnostic.** The `.diogenes/` DSL and the gate framework should never reference Claude, Cursor, or any specific agent. Targets handle translation. If you find yourself writing agent-specific logic outside a target file, stop.
+## The Five Diogenes Gates
 
-**The gates are not a checklist to game.** When evaluating proposed features with `/evaluate-feature`, engage honestly with each gate. A gate failure is information, not an obstacle.
+When evaluating or building AI features, apply these gates in order.
+A gate failure is information, not a verdict — but it must be addressed
+before shipping.
 
-**Prefer explicit Ruby over clever Ruby.** This gem will be read by contributors who are encountering it for the first time. Clarity beats elegance. The person debugging this at midnight should understand it without context.
+**Gate 1 — Failure Mode** (Least surprise at scale)
+What happens when this feature is wrong? Recoverable failures pass.
+Embarrassing failures pass with conditions. Catastrophic failures do not pass.
 
-**Gate failure messages are first-class.** When you write or modify a gate, the failure message is as important as the validation logic. Draft it first. It should sound like a thoughtful colleague pointing something out, not a compiler.
+**Gate 2 — User Verifiable** (Trust requires verification)
+Can the average user tell when the output is wrong? If the user lacks
+domain expertise to evaluate AI output, the feature creates a confidence gap.
 
-**Tests are not optional.** Every gate option, every target, every CLI command needs tests. If you're uncertain what to test, that uncertainty is a sign the API needs clarification, not that tests can be skipped.
+**Gate 3 — Human in the Loop** (Human-centered design, genuinely)
+Is there a human with time, context, and authority to actually intervene?
+Rubber-stamping is not a loop.
 
----
+**Gate 4 — Observability** (Craftsmanship — you wouldn't ship blind)
+Do you have monitoring to detect when this feature degrades in production?
+Silent degradation is worse than no feature.
 
-## Running the Gem Locally
+**Gate 5 — Right Tool** (Convention over configuration)
+Is AI the right answer, or just the exciting one? Prefer the boring,
+predictable software alternative when it serves the same need.
 
-```bash
-bundle exec exe/diogenes --help
-bundle exec exe/diogenes init
-bundle exec exe/diogenes evaluate "some feature idea"
-bundle exec exe/diogenes build --all
-bundle exec rspec
-```
 
 ---
-
-## Rebuilding This File
-
-This file was generated from `.diogenes/`. To regenerate after source changes:
-
-```bash
-bundle exec exe/diogenes build --target claude-code
-```

data/lib/diogenes/build/sources.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Diogenes
+  module Build
+    Sources = Struct.new(:skills, :rules, :hooks, :artifacts, keyword_init: true)
+  end
+end

data/lib/diogenes/cli/build.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "optparse"
+
+module Diogenes
+  class Cli
+    class Build
+      DIOGENES_DIR = ".diogenes" #: String
+      SOURCE_SUBDIRS = %w[skills rules hooks].freeze #: Array[String]
+
+      #: (argv: Array[String], cwd: String, out: IO, err: IO, **untyped) -> Integer
+      def self.run(argv:, cwd:, out:, err:, **_opts)
+        new(argv:, cwd:, out:, err:).run
+      end
+
+      #: (argv: Array[String], cwd: String, out: IO, err: IO) -> void
+      def initialize(argv:, cwd:, out:, err:)
+        @argv = argv #: Array[String]
+        @cwd = cwd #: String
+        @out = out #: IO
+        @err = err #: IO
+        @build_all = false #: bool
+        @target_key = nil #: Symbol?
+      end
+
+      #: () -> Integer
+      def run
+        parse_options
+        return usage_error unless @build_all || @target_key
+
+        diogenes_dir = File.join(@cwd, DIOGENES_DIR)
+        unless Dir.exist?(diogenes_dir)
+          @err.puts "No #{DIOGENES_DIR}/ found. Run `diogenes init` first."
+          return 1
+        end
+
+        Diogenes.reset!
+        load_config(diogenes_dir)
+        load_sources(diogenes_dir)
+
+        target_keys = @target_key ? [@target_key] : Diogenes.configuration.targets
+
+        if target_keys.empty?
+          @err.puts "No targets configured. Add `targets :claude_code, :cursor` to #{DIOGENES_DIR}/diogenes.rb"
+          return 1
+        end
+
+        sources = Diogenes::Build::Sources.new(
+          skills: Diogenes.skills,
+          rules: Diogenes.rules,
+          hooks: Diogenes.hooks,
+          artifacts: Diogenes.artifacts
+        )
+
+        built = build_targets(target_keys, sources)
+        print_summary(built)
+        0
+      rescue UserError => e
+        @err.puts e.message
+        1
+      end
+
+      private
+
+      #: () -> void
+      def parse_options
+        OptionParser.new do |o|
+          o.on("--all") { @build_all = true }
+          o.on("--target TARGET") { |v| @target_key = v.to_sym }
+        end.parse!(@argv.dup)
+      end
+
+      #: () -> Integer
+      def usage_error
+        @err.puts "Usage: diogenes build --all"
+        @err.puts "       diogenes build --target <target>"
+        1
+      end
+
+      #: (String) -> void
+      def load_config(dir)
+        config = File.join(dir, "diogenes.rb")
+        load config if File.exist?(config)
+      end
+
+      #: (String) -> void
+      def load_sources(dir)
+        SOURCE_SUBDIRS.each do |subdir|
+          Dir.glob(File.join(dir, subdir, "**/*.rb")).sort.each { |f| load f }
+        end
+      end
+
+      #: (Array[Symbol], untyped) -> Array[Hash[Symbol, untyped]]
+      def build_targets(keys, sources)
+        keys.map do |key|
+          target = Targets.for(key, cwd: @cwd, out: @out)
+          files = target.build(sources:)
+          {key:, files:}
+        end
+      end
+
+      #: (Array[Hash[Symbol, untyped]]) -> void
+      def print_summary(built)
+        @out.puts
+        @out.puts "Build complete."
+        @out.puts
+        built.each do |b|
+          @out.puts "  #{b[:key]}:"
+          b[:files].each { |f| @out.puts "    wrote  #{f}" }
+        end
+      end
+    end
+  end
+end

data/lib/diogenes/cli.rb

@@ -2,12 +2,14 @@
 # rbs_inline: enabled
 
 require_relative "cli/init"
+require_relative "cli/build"
 require_relative "cli/evaluate"
 
 module Diogenes
   class Cli
     COMMANDS = {
       "init" => Init,
+      "build" => Build,
       "evaluate" => Evaluate
     }.freeze #: Hash[String, Class]
 
@@ -22,6 +24,7 @@ module Diogenes
       @out = out #: IO
       @err = err #: IO
       @in = opts.fetch(:in, $stdin) #: IO
+      @cwd = opts.fetch(:cwd, Dir.pwd) #: String
     end
 
     #: () -> Integer
@@ -47,8 +50,8 @@ module Diogenes
 
     #: (Class, Array[String]) -> Integer
     def run_command(command_class, args)
-      opts = {in: @in}
-      command_class.run(argv: args, cwd: Dir.pwd, out: @out, err: @err, **opts)
+      opts = {in: @in, cwd: @cwd}
+      command_class.run(argv: args, cwd: @cwd, out: @out, err: @err, **opts)
     end
 
     #: () -> Integer

data/lib/diogenes/configuration.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Diogenes
+  class Configuration
+    DEFAULT_ARTIFACTS_DIR = "docs/decisions" #: String
+
+    #: () -> void
+    def initialize
+      @targets = [] #: Array[Symbol]
+      @artifacts_dir = DEFAULT_ARTIFACTS_DIR #: String
+    end
+
+    #: (?String?) -> String?
+    def name(value = nil)
+      @name = value unless value.nil?
+      @name
+    end
+
+    #: (?String?) -> String?
+    def description(value = nil)
+      @description = value unless value.nil?
+      @description
+    end
+
+    #: (*Symbol) -> Array[Symbol]
+    def targets(*values)
+      @targets = values.flatten unless values.empty?
+      @targets
+    end
+
+    #: (?String?) -> String
+    def artifacts_dir(value = nil)
+      @artifacts_dir = value unless value.nil?
+      @artifacts_dir
+    end
+  end
+end