password_forge 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '04491df7a00f384358316e13cc7aefcfb779ff7b086fe0f5d4c1d8debc7cb11c'
+  data.tar.gz: 87e0e0c2b7965143d43d0e624fce83da06a591bc2c341e1dae8e280807a49af6
+SHA512:
+  metadata.gz: ab01ba4518870bd2af66924298ba94a6509c703843216678556ba31ce1cdc31d22ecef7a5a996c0ef9cf3f2a8528130101813161d0aed0b0fe57c592082bc786
+  data.tar.gz: c573c0c3ec020471d63fb6bb3de55520bd0b5cdbd957e82755b638ea269fef69220db75a315a21e609b88492b9084fa5967a8456a580d8f74ac5ce0c777149ed

data/.kiro/steering/product.md

@@ -0,0 +1,46 @@
+# Product
+
+## What this is
+
+`password_forge` is a configurable password generator distributed as a Ruby gem.
+It generates random passwords from four selectable character sets — uppercase,
+lowercase, numeric and special — that can be switched on or off independently.
+All sets are enabled by default, and an error is raised if every set is
+disabled. Randomness comes from Ruby's `SecureRandom`.
+
+The public API mirrors the design of an existing C# / NuGet package: a
+constructor with four boolean flags plus a length, and a dedicated exception
+when no character set is selected.
+
+## Goals
+
+1. **Learning vehicle.** This is the author's first Ruby gem. Code favours
+   clarity and idiomatic Ruby over cleverness, and everything is built with TDD.
+2. **Kiro evangelism in the Ruby world.** Beyond the gem itself, the project
+   ships a full "Kiro-native" experience for Ruby gem authors: Kiro skills,
+   project steering (this folder), hooks, and an MCP server. The repository is
+   meant to be a reference example of building and shipping a gem the Kiro way.
+
+## Audience
+
+- Ruby developers who need a small, dependency-free password generator.
+- Ruby developers curious about using Kiro to build and release gems.
+
+## Language
+
+All repository content (code, comments, docs, commit messages) is in **English**.
+The only exception is the author's personal development diary, which is kept
+locally in `private-notes/` and excluded from the repository.
+
+## Release roadmap
+
+The project ships in small, tagged increments. Each version is merged to `main`
+before the next begins:
+
+- **0.0.1** — Core generator, character sets, validation, tests, docs. (done)
+- **0.1.0** — First public release on RubyGems.org via Trusted Publishing.
+- **0.2.0** — Kiro skills for gem authors (feature TDD, version bump, release).
+- **0.3.0** — Project `.kiro/` folder with full steering and conventions.
+- **0.4.0** — Kiro hooks (run specs on save, changelog reminders, etc.).
+- **0.5.0** — A Ruby MCP server exposing password generation as a tool.
+- **0.6.0** — A fluent/builder API layered on top of the keyword-argument API.

data/.kiro/steering/structure.md

@@ -0,0 +1,79 @@
+# Structure
+
+## Directory layout
+
+```
+password-forge-ruby-gem/             # repo root
+├── lib/
+│   ├── password_forge.rb            # Entry point: requires all components
+│   └── password_forge/
+│       ├── version.rb               # VERSION constant
+│       ├── errors.rb                # Error, NoCharsetSelectedError
+│       ├── charset.rb               # Charset value object (character sets + build)
+│       ├── validation.rb            # Validation module (selection + length)
+│       └── generator.rb             # Generator class + PasswordForge.generate
+├── spec/
+│   ├── spec_helper.rb
+│   ├── password_forge_spec.rb       # Top-level (version) spec
+│   └── password_forge/
+│       ├── charset_spec.rb
+│       ├── validation_spec.rb
+│       └── generator_spec.rb
+├── examples/                        # Runnable local demos (not packaged)
+│   ├── smoke_test.rb                # Loads the gem from source and prints samples
+│   └── local-consumer/             # Mini "external" project using the gem via path:
+│       ├── Gemfile
+│       └── run.rb
+├── docs/                            # Extended documentation (not packaged)
+│   ├── README.md                    # Docs index
+│   └── local-testing.md            # How to try the gem locally
+├── sig/                             # RBS type signatures
+├── bin/                             # setup + console helper scripts
+├── .github/workflows/
+│   ├── main.yml                     # CI: RSpec matrix + RuboCop
+│   └── release.yml                  # Trusted Publishing on v* tags
+├── .kiro/                           # Kiro steering / skills / hooks
+├── private-notes/                   # Local-only, git-ignored (dev diary)
+├── password_forge.gemspec
+├── Gemfile
+├── Rakefile
+├── README.md
+├── CHANGELOG.md
+└── LICENSE.txt
+```
+
+`Gemfile.lock` is generated per environment and git-ignored (see Tech), so it is
+not part of the tracked tree above.
+
+## Architecture
+
+The internal design mirrors the original C# separation of concerns while
+staying idiomatic Ruby:
+
+- **`PasswordForge::Charset`** — a module acting as a value object. Holds the
+  frozen `UPPER`, `LOWER`, `NUMERIC` and `SPECIAL` constants and a `build`
+  method that returns the pool of characters for the selected sets.
+- **`PasswordForge::Validation`** — a module with `validate_charset_selection`
+  (raises when no set is selected) and `validate_length` (positive integer).
+- **`PasswordForge::NoCharsetSelectedError`** — the equivalent of the C#
+  `InvalidCharSetException`; subclass of `PasswordForge::Error`.
+- **`PasswordForge::Generator`** — the public class. The constructor validates
+  input and builds the pool; `#generate` returns a `SecureRandom`-backed
+  password.
+- **`PasswordForge.generate(**options)`** — a top-level convenience wrapper.
+
+## Public API conventions
+
+- The `Generator` constructor uses keyword arguments:
+  `upper_case:`, `lower_case:`, `numeric_case:`, `special_case:` (all `true`),
+  and `length:` (default 16). This matches the C# constructor parameter names.
+- A fluent/builder API is planned for v0.6.0 and must be **additive**: the
+  keyword-argument API keeps working unchanged.
+
+## Naming
+
+- **Gem name:** `password_forge` (underscore) — what users `gem install`.
+- **GitHub repo:** `password-forge-ruby-gem` (hyphens) — more descriptive for
+  discovery. The two intentionally differ.
+- Namespace all code under the `PasswordForge` module; one file per component
+  under `lib/password_forge/`.

data/.kiro/steering/tech.md

@@ -0,0 +1,68 @@
+# Tech
+
+## Stack
+
+- **Language:** Ruby, `required_ruby_version >= 3.0.0`.
+- **Test framework:** RSpec.
+- **Linter:** RuboCop (config in `.rubocop.yml`, `TargetRubyVersion: 3.0`).
+- **Randomness:** `SecureRandom` (standard library, no runtime dependencies).
+- **Type signatures:** RBS stubs under `sig/`.
+
+The gem has **no runtime dependencies**.
+
+## Common commands
+
+Run from the repository root (`password-forge-ruby-gem/`):
+
+```bash
+bundle install            # install development dependencies
+bundle exec rake          # default task: RSpec + RuboCop
+bundle exec rspec         # run the test suite only
+bundle exec rubocop       # run the linter only
+bundle exec rubocop -A    # auto-correct safe offences
+gem build password_forge.gemspec   # build the gem locally
+bin/console               # interactive prompt with the gem loaded
+```
+
+## Development workflow
+
+- **TDD.** Write the spec first, watch it fail, implement to green, then
+  refactor. Keep the suite and RuboCop green before every commit.
+- **Branches.** Do feature work on a `feature/vX.Y.Z-*` branch and merge to
+  `main` per milestone. Never push directly to `main` for feature work.
+- **Versioning.** Semantic Versioning. Bump `lib/password_forge/version.rb`,
+  update `CHANGELOG.md` (Keep a Changelog format), then tag `vX.Y.Z`.
+
+## Release process (Trusted Publishing)
+
+Publishing is automated via OIDC — no API tokens are stored.
+
+1. A one-time setup on RubyGems.org registers a trusted publisher:
+   - RubyGem name: `password_forge`
+   - Repository owner: `devandreacarratta`
+   - Repository name: `password-forge-ruby-gem`
+   - Workflow filename: `release.yml`
+   - Environment: `release`
+   For the very first publish (gem not yet on RubyGems), a **pending** trusted
+   publisher is registered from the RubyGems profile before the gem exists.
+2. `.github/workflows/release.yml` triggers on `v*` tags, uses
+   `rubygems/release-gem@v1` with `contents: write` + `id-token: write` and the
+   `release` GitHub environment.
+3. Releasing = bump version, update CHANGELOG, merge to `main`, push the tag.
+
+## Key decisions (recorded so they are not re-litigated)
+
+- **Gem email removed.** `spec.email` is intentionally omitted from the gemspec
+  (it is optional and would be public). The RubyGems account email is separate
+  and private.
+- **`Gemfile.lock` is not committed.** Committing it pinned `BUNDLED WITH 4.x`,
+  which broke CI on Ruby < 3.2 (Bundler 4 requires Ruby 3.2+). Gems resolve the
+  lockfile per environment, so it is git-ignored.
+- **Gem name vs repo name differ on purpose** (`password_forge` vs
+  `password-forge-ruby-gem`).
+- **MFA required for pushes** via `rubygems_mfa_required = "true"` in the
+  gemspec.
+- **CI splits test and lint:** RSpec runs across Ruby 3.0–3.4; RuboCop runs once
+  on 3.4 to avoid version-specific style noise.
+- **Personal diary** lives in `private-notes/` (git-ignored), everything else is
+  English and tracked.

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.0.2] - 2026-09-05
+
+### Added
+
+- `examples/` folder with runnable local demos: `smoke_test.rb` (loads the gem
+  from source and prints sample passwords) and `local-consumer/` (a minimal
+  external project that depends on the gem via a `path:` reference).
+- `docs/` folder with a documentation index (`docs/README.md`) and a
+  local-testing guide (`docs/local-testing.md`).
+- "Trying it locally" section in the README linking to the examples and docs.
+
+### Changed
+
+- Excluded `examples/` and `docs/` from the packaged gem.
+
+### Fixed
+
+- Corrected the directory tree and command paths in the Kiro steering docs
+  (`structure.md`, `tech.md`), which still referenced a nested `password_forge/`
+  root left over from an older project layout.
+
+## [0.0.1] - 2026-09-05
+
+### Added
+
+- `PasswordForge::Generator` with keyword-argument constructor
+  (`upper_case:`, `lower_case:`, `numeric_case:`, `special_case:`, `length:`)
+  and a `SecureRandom`-backed `#generate`.
+- `PasswordForge::Charset` value object exposing the `UPPER`, `LOWER`,
+  `NUMERIC` and `SPECIAL` character sets and a `build` method.
+- `PasswordForge::Validation` for charset selection and length checks.
+- `PasswordForge::NoCharsetSelectedError`, raised when no character set is
+  selected.
+- `PasswordForge.generate` convenience wrapper.
+- RSpec test suite, RuboCop configuration and README.
+
+[Unreleased]: https://github.com/devandreacarratta/password-forge-ruby-gem/compare/v0.0.2...HEAD
+[0.0.2]: https://github.com/devandreacarratta/password-forge-ruby-gem/compare/v0.0.1...v0.0.2
+[0.0.1]: https://github.com/devandreacarratta/password-forge-ruby-gem/releases/tag/v0.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Andrea Carratta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,152 @@
+# PasswordForge
+
+[![Ruby](https://github.com/devandreacarratta/password-forge-ruby-gem/actions/workflows/main.yml/badge.svg)](https://github.com/devandreacarratta/password-forge-ruby-gem/actions/workflows/main.yml)
+
+A configurable password generator for Ruby with selectable character sets.
+
+`PasswordForge` builds passwords from four character categories — uppercase,
+lowercase, numeric and special — that you switch on or off independently. All
+categories are enabled by default, and a clear error is raised if you disable
+every one of them. Randomness is provided by Ruby's `SecureRandom`.
+
+This gem is also a showcase for building and shipping a Ruby gem the **Kiro
+way**. Kiro skills, project steering, hooks and an MCP server are being added
+incrementally (see the [Roadmap](#roadmap)).
+
+## Installation
+
+> **Not on RubyGems yet.** The first public release is planned for 0.1.0 (see
+> the [Roadmap](#roadmap)). Until then, see [Trying it
+> locally](#trying-it-locally) to run the gem from source or via a local path
+> dependency.
+
+Once published, install the gem and add it to the application's Gemfile by
+executing:
+
+```bash
+bundle add password_forge
+```
+
+If Bundler is not being used to manage dependencies, install the gem by
+executing:
+
+```bash
+gem install password_forge
+```
+
+## Usage
+
+### Quick start
+
+```ruby
+require "password_forge"
+
+# All character sets enabled, default length of 16
+PasswordForge.generate
+# => "aB3$xY7!qR2@kL9%"
+```
+
+### Using the generator directly
+
+The constructor takes four boolean flags (all `true` by default) plus a
+`length`. This mirrors the design of the original C# / NuGet package:
+
+```ruby
+generator = PasswordForge::Generator.new(
+  upper_case:   true,  # include A-Z
+  lower_case:   true,  # include a-z
+  numeric_case: true,  # include 0-9
+  special_case: true,  # include special characters
+  length:       16
+)
+
+generator.generate # => "aB3$xY7!qR2@kL9%"
+```
+
+### Examples
+
+```ruby
+# A 20-character password using every character set
+PasswordForge::Generator.new(length: 20).generate
+
+# A 4-digit numeric PIN
+PasswordForge::Generator.new(
+  upper_case: false, lower_case: false, numeric_case: true, special_case: false, length: 4
+).generate
+# => "8391"
+
+# Letters only (no digits, no symbols)
+PasswordForge::Generator.new(
+  numeric_case: false, special_case: false, length: 24
+).generate
+```
+
+### Error handling
+
+Disabling every character set raises `PasswordForge::NoCharsetSelectedError`:
+
+```ruby
+PasswordForge::Generator.new(
+  upper_case: false, lower_case: false, numeric_case: false, special_case: false
+)
+# => raises PasswordForge::NoCharsetSelectedError
+```
+
+A non-positive or non-integer `length` raises `ArgumentError`.
+
+## Character sets
+
+| Flag           | Characters               |
+| -------------- | ------------------------ |
+| `upper_case`   | `A`–`Z`                  |
+| `lower_case`   | `a`–`z`                  |
+| `numeric_case` | `0`–`9`                  |
+| `special_case` | `` !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ `` |
+
+## Trying it locally
+
+You can run the gem without installing it from RubyGems:
+
+- **From this repository:** `ruby examples/smoke_test.rb` prints a few sample
+  passwords straight from the source tree.
+- **From another project:** add `gem "password_forge", path:
+  "/path/to/password-forge-ruby-gem"` to that project's `Gemfile`, run `bundle
+  install`, then `require "password_forge"`. See
+  [`examples/local-consumer/`](examples/local-consumer) for a working example.
+
+Full instructions, including the interactive console and building a local
+`.gem`, are in [docs/local-testing.md](docs/local-testing.md).
+
+## Roadmap
+
+`PasswordForge` is developed in incremental, tagged releases:
+
+- **0.0.1** — Core generator, character sets, validation, tests, docs.
+- **0.0.2** — Local-testing examples (`examples/`) and documentation (`docs/`).
+- **0.1.0** — First public release on RubyGems.org via Trusted Publishing.
+- **0.2.0** — Kiro skills for gem authors (feature TDD, version bump, release).
+- **0.3.0** — Project `.kiro/` folder with steering and conventions.
+- **0.4.0** — Kiro hooks (run specs on save, changelog reminders, and more).
+- **0.5.0** — A Ruby MCP server exposing password generation as a tool.
+- **0.6.0** — A fluent/builder API on top of the keyword-argument API.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then run
+`bundle exec rake` to run the tests and the linter. You can also run
+`bin/console` for an interactive prompt to experiment, or
+`ruby examples/smoke_test.rb` for a quick check straight from source.
+
+To install this gem onto your local machine, run `bundle exec rake install`. For
+the full local workflow — including running it from a separate project and
+uninstalling — see [docs/local-testing.md](docs/local-testing.md).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+<https://github.com/devandreacarratta/password-forge-ruby-gem>.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/password_forge/charset.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module PasswordForge
+  # Value object holding the available character sets and building the pool
+  # of characters from the selected sets.
+  #
+  # The four sets mirror the character categories of the original C# design:
+  # uppercase (A-Z), lowercase (a-z), numeric (0-9) and special (punctuation).
+  module Charset
+    # Uppercase letters, from 'A' to 'Z'.
+    UPPER = ("A".."Z").to_a.freeze
+
+    # Lowercase letters, from 'a' to 'z'.
+    LOWER = ("a".."z").to_a.freeze
+
+    # Numeric digits, from '0' to '9'.
+    NUMERIC = ("0".."9").to_a.freeze
+
+    # Special (punctuation) characters.
+    SPECIAL = %w[! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \\ ] ^ _ ` { | } ~].freeze
+
+    # Builds the pool of characters from the selected sets.
+    #
+    # @param upper [Boolean] include uppercase letters (A-Z)
+    # @param lower [Boolean] include lowercase letters (a-z)
+    # @param numeric [Boolean] include numeric digits (0-9)
+    # @param special [Boolean] include special characters
+    # @return [Array<String>] the combined pool of unique characters
+    def self.build(upper:, lower:, numeric:, special:)
+      pool = []
+      pool.concat(UPPER) if upper
+      pool.concat(LOWER) if lower
+      pool.concat(NUMERIC) if numeric
+      pool.concat(SPECIAL) if special
+      pool
+    end
+  end
+end

data/lib/password_forge/errors.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module PasswordForge
+  # Base error class for all PasswordForge-specific errors.
+  class Error < StandardError; end
+
+  # Raised when a generator is configured with no character set selected,
+  # mirroring the +InvalidCharSetException+ of the original C# design.
+  class NoCharsetSelectedError < Error
+    # Default message shown when no character set is selected.
+    DEFAULT_MESSAGE = "At least one character set must be selected " \
+                      "(upper_case, lower_case, numeric_case or special_case)."
+
+    def initialize(message = DEFAULT_MESSAGE)
+      super
+    end
+  end
+end

data/lib/password_forge/generator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module PasswordForge
+  # Generates random passwords from selectable character sets.
+  #
+  # The constructor mirrors the original C# +PasswordGenerator+ design: four
+  # boolean flags select the character sets, all enabled by default, and a
+  # {NoCharsetSelectedError} is raised when none is selected.
+  #
+  # @example Generate a password with all character sets (default)
+  #   PasswordForge::Generator.new.generate # => "aB3$xY7!qR2@kL9%"
+  #
+  # @example Generate a numeric-only PIN
+  #   PasswordForge::Generator.new(
+  #     upper_case: false, lower_case: false, numeric_case: true, special_case: false, length: 4
+  #   ).generate # => "8391"
+  class Generator
+    # Default password length used when none is specified.
+    DEFAULT_LENGTH = 16
+
+    # @return [Integer] the configured password length
+    attr_reader :length
+
+    # @param upper_case [Boolean] include uppercase letters (A-Z)
+    # @param lower_case [Boolean] include lowercase letters (a-z)
+    # @param numeric_case [Boolean] include numeric digits (0-9)
+    # @param special_case [Boolean] include special characters
+    # @param length [Integer] the length of the generated password
+    # @raise [NoCharsetSelectedError] if no character set is selected
+    # @raise [ArgumentError] if length is not a positive integer
+    def initialize(upper_case: true, lower_case: true, numeric_case: true, special_case: true,
+                   length: DEFAULT_LENGTH)
+      Validation.validate_charset_selection(
+        upper: upper_case, lower: lower_case, numeric: numeric_case, special: special_case
+      )
+      Validation.validate_length(length)
+
+      @length = length
+      @pool = Charset.build(
+        upper: upper_case, lower: lower_case, numeric: numeric_case, special: special_case
+      )
+    end
+
+    # Generates a random password of the configured length.
+    #
+    # Uses {SecureRandom} for cryptographically secure randomness.
+    #
+    # @return [String] the generated password
+    def generate
+      Array.new(@length) { @pool[SecureRandom.random_number(@pool.length)] }.join
+    end
+  end
+
+  # Convenience wrapper around {Generator#generate}.
+  #
+  # @see Generator#initialize
+  # @return [String] the generated password
+  def self.generate(**options)
+    Generator.new(**options).generate
+  end
+end

data/lib/password_forge/validation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module PasswordForge
+  # Validates the configuration of a password generator.
+  #
+  # Mirrors the validation responsibilities of the original C# design:
+  # rejecting a configuration with no character set selected and rejecting
+  # an invalid password length.
+  module Validation
+    # Ensures that at least one character set is selected.
+    #
+    # @param upper [Boolean] uppercase flag
+    # @param lower [Boolean] lowercase flag
+    # @param numeric [Boolean] numeric flag
+    # @param special [Boolean] special flag
+    # @raise [NoCharsetSelectedError] if every flag is false
+    # @return [void]
+    def self.validate_charset_selection(upper:, lower:, numeric:, special:)
+      return if upper || lower || numeric || special
+
+      raise NoCharsetSelectedError
+    end
+
+    # Ensures that the requested password length is a positive integer.
+    #
+    # @param length [Integer] the requested password length
+    # @raise [ArgumentError] if length is not a positive integer
+    # @return [void]
+    def self.validate_length(length)
+      raise ArgumentError, "length must be an Integer, got #{length.class}" unless length.is_a?(Integer)
+      raise ArgumentError, "length must be a positive integer, got #{length}" unless length.positive?
+    end
+  end
+end

data/lib/password_forge/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PasswordForge
+  VERSION = "0.0.2"
+end

data/lib/password_forge.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "password_forge/version"
+require_relative "password_forge/errors"
+require_relative "password_forge/charset"
+require_relative "password_forge/validation"
+require_relative "password_forge/generator"
+
+# PasswordForge generates random passwords from selectable character sets.
+module PasswordForge
+end

data/sig/password_forge.rbs

@@ -0,0 +1,4 @@
+module PasswordForge
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: password_forge
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Andrea Carratta
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: PasswordForge generates random passwords from selectable character sets
+  (uppercase, lowercase, numeric, special). Built as a learning-friendly, well-tested
+  Ruby gem with a clean, idiomatic API.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".kiro/steering/product.md"
+- ".kiro/steering/structure.md"
+- ".kiro/steering/tech.md"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/password_forge.rb
+- lib/password_forge/charset.rb
+- lib/password_forge/errors.rb
+- lib/password_forge/generator.rb
+- lib/password_forge/validation.rb
+- lib/password_forge/version.rb
+- sig/password_forge.rbs
+homepage: https://github.com/devandreacarratta/password-forge-ruby-gem
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/devandreacarratta/password-forge-ruby-gem
+  source_code_uri: https://github.com/devandreacarratta/password-forge-ruby-gem/tree/main
+  changelog_uri: https://github.com/devandreacarratta/password-forge-ruby-gem/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: A configurable password generator with selectable character sets.
+test_files: []