random_name_generator 4.0.0 → 4.0.2

data/docs/superpowers/specs/2026-07-18-lang-gen-skill-design.md

@@ -0,0 +1,122 @@
+# `/lang-gen` skill — design
+
+**Date:** 2026-07-18
+**Status:** Approved, pending implementation plan
+
+## Context
+
+`random_name_generator` composes fake names from small language files under
+`lib/languages/`. Each file is a tiny DSL:
+
+- One syllable per line.
+- Leading `-` → **prefix** (pre) bucket; leading `+` → **suffix** (sur) bucket;
+  no leading sign → **middle** (mid) bucket. `Generator#push` reads these.
+- Trailing flags encode phonotactics, per `lib/random_name_generator/syllable.rb`:
+  - `+v` — next syllable must start with a vowel.
+  - `+c` — next syllable must start with a consonant.
+  - `-v` — this syllable may only follow one ending in a vowel.
+  - `-c` — this syllable may only follow one ending in a consonant.
+
+Adding a language today is a manual two-step: drop a `.txt` in `lib/languages/`
+(edgy themes go in `lib/languages/experimental/`, like `curse.txt`), then wire a
+`File.new(...)` constant into `lib/random_name_generator.rb`.
+
+`/lang-gen` automates this as a **guided authoring skill**: turn a free-text
+theme into a well-flagged syllable file plus its integration.
+
+## Goal
+
+`/lang-gen <free text theme>` (e.g. `/lang-gen german curse words`) produces a
+new, ready-to-use language: a syllable `.txt`, a registered constant, a smoke
+spec, a README entry, and sample output for a quality check.
+
+## Decisions (from brainstorming)
+
+| Question | Decision |
+|----------|----------|
+| Output scope | **Full integration** — `.txt` + constant + README entry + smoke spec |
+| File destination | **experimental/ for edgy themes**; tame themes → `lib/languages/` |
+| Skill location | **Project** `.claude/skills/lang-gen/SKILL.md`, committed |
+| Linguistic method | **Hybrid** — seed from real roots, then extend with same-flavor invented syllables |
+| Size & flags | **Match existing files** (~20–40 per bucket) **+ smart flags** |
+| Verification | **Sample and show** ~10 composed names + parse-check |
+
+## Design
+
+### Trigger and argument parsing
+
+- Invoked as `/lang-gen <free text theme>`. The whole argument string is the theme.
+- Derive:
+  - **slug** — concise kebab-case, 1–2 meaningful words, dropping filler
+    ("words", "generator", articles). `german curse words` → `german-curse`.
+  - **constant** — SCREAMING_SNAKE of the slug. `german-curse` → `GERMAN_CURSE`.
+  - **destination** — edgy/NSFW/joke themes (curse, insult, swear, drunk, etc.)
+    → `lib/languages/experimental/`; otherwise `lib/languages/`.
+- Show the derived slug / constant / destination and **confirm with the user**
+  before writing, so they can rename or re-route.
+- Guard against collisions: if the slug file or constant already exists, stop and
+  ask (do not overwrite an existing language).
+
+### Syllable generation (hybrid, seeded-then-extended)
+
+The skill body instructs Claude to:
+
+1. Recall a handful of **real theme roots** appropriate to the theme
+   (German curses: `schei`, `arsch`, `sau`, `verdammt`, `dreck`, `mist`, …).
+2. Slot fragments into the three buckets:
+   - prefixes (`-`) — natural word beginnings,
+   - middles (bare) — connective interior fragments,
+   - suffixes (`+`) — natural word endings / intensifiers.
+3. **Pad** each bucket with same-flavor **invented** syllables until each holds
+   roughly **20–40** entries, matching `goblin.txt` scale.
+4. Apply `+v/+c/-v/-c` flags where they prevent awkward clusters, following the
+   exact semantics in `syllable.rb` (e.g. a consonant-final prefix that would
+   clash gets a flag; a lone vowel-ending fragment gets `+c`). Flags are used
+   judiciously, not on every line.
+
+### Full integration
+
+After the `.txt` is written:
+
+- **Constant** — add `CONST = File.new("#{dirname}/languages/<path>")` to
+  `lib/random_name_generator.rb`. Edgy themes go under the existing
+  `# Experimental` block; tame themes alongside the curated constants. The
+  curated `flip_mode` arrays are **not** modified (they stay hand-picked).
+- **Spec** — add a minimal RSpec smoke test following existing `spec/`
+  conventions: the file loads, parses, all three buckets are non-empty, and
+  `compose` returns a non-empty String.
+- **README** — add the new language under a short experimental-languages note
+  (link to the file), consistent with how the curated four are listed.
+
+### Verification (sample and show)
+
+Before declaring done, the skill:
+
+- **Parse-checks**: every line is a valid syllable; pre, mid, and sur buckets are
+  all non-empty.
+- **Samples**: loads the new constant through the gem and prints ~10 names via
+  `RandomNameGenerator.new(RandomNameGenerator::CONST).compose`.
+- If output looks broken or monotonous, it iterates on the syllable file before
+  finishing.
+
+### Skill packaging
+
+- Lives at `.claude/skills/lang-gen/SKILL.md` with YAML frontmatter
+  (`name`, `description`, trigger guidance).
+- Per the project rule, add a link to `README.md` under a `## Skills` section
+  using the skill's `name` as link text and its `description` as the blurb.
+
+## Constraints / notes
+
+- **Git is manual.** State-changing git is off-limits to the assistant; the
+  spec-commit and final commit are surfaced as suggested commands for the user
+  to run, not executed by the skill.
+- **No overwrite.** The skill never clobbers an existing language file or
+  constant without explicit confirmation.
+
+## Out of scope (YAGNI)
+
+- Editing `flip_mode` / `flip_mode_cyrillic` sampler arrays.
+- Cyrillic (`-ru`) variants of generated languages.
+- Bulk / batch generation of multiple themes at once.
+- Programmatic scraping of external wordlists.

data/docs/superpowers/specs/2026-07-19-lang-gen-portable-prompt.md

@@ -0,0 +1,124 @@
+# Lang-Gen Portable Prompt
+
+Use this prompt with any LLM that can edit files and run commands in the repository.
+
+## Goal
+
+Generate a new `random_name_generator` language from a free-text theme such as `german curse words`. The result should be a fully integrated language file with a registered constant, a smoke spec, a README entry, and verification output.
+
+## Language File DSL
+
+Authoritative source: `lib/random_name_generator/syllable.rb`.
+
+Each line of a language `.txt` file is one syllable:
+
+- Leading `-` = prefix bucket, a name beginning.
+- Leading `+` = suffix bucket, a name ending.
+- No leading sign = middle bucket, an interior fragment.
+
+Optional whitespace-separated flags after the syllable constrain adjacency:
+
+- `+v` = the next syllable must start with a vowel.
+- `+c` = the next syllable must start with a consonant.
+- `-v` = this syllable may only follow one ending in a vowel.
+- `-c` = this syllable may only follow one ending in a consonant.
+
+A valid language needs all three buckets to be non-empty. `Generator#compose` picks a prefix, fills with middles, and ends with a suffix while honoring flags.
+
+## Workflow
+
+Follow these steps in order. Do not skip verification.
+
+### 1. Parse the theme and derive names
+
+From the theme string, derive and show the user for confirmation:
+
+- Slug: concise kebab-case, 1-2 meaningful words, dropping filler such as `words`, `generator`, and articles. Example: `german curse words` -> `german-curse`.
+- Constant: SCREAMING_SNAKE version of the slug. Example: `german-curse` -> `GERMAN_CURSE`.
+- Destination: edgy themes such as curse, insult, swear, NSFW, or drunk go in `lib/languages/experimental/<slug>.txt`; tame themes go in `lib/languages/<slug>.txt`.
+
+Before writing anything, check for collisions. If the target `.txt` file or the constant already exists, stop and ask the user how to proceed. Never overwrite.
+
+### 2. Author the syllable file
+
+1. Recall a handful of real roots for the theme. Example for German curses: `schei`, `arsch`, `sau`, `verdammt`, `dreck`, `mist`, `depp`, `blöd`.
+2. Slot fragments into buckets: prefixes (`-`) are natural beginnings, middles are connective interiors, and suffixes (`+`) are natural endings or intensifiers.
+3. Extend each bucket with same-flavor invented syllables until each bucket has roughly 20-40 entries, matching the scale of `lib/languages/goblin.txt`.
+4. Add `+v`, `+c`, `-v`, and `-c` flags only where they prevent awkward clusters. Most lines should carry no flag.
+
+Write the file to the destination chosen in step 1.
+
+### 3. Register the constant
+
+Edit `lib/random_name_generator.rb` and add the new `File` constant next to the matching group of constants. Put edgy themes under the existing `# Experimental` comment and tame themes with the curated constants.
+
+Use the existing pattern:
+
+```ruby
+CONSTANT_NAME = File.new("#{dirname}/languages/<relative/path>.txt")
+```
+
+Do not change `flip_mode` or `flip_mode_cyrillic`; those arrays are curated.
+
+### 4. Add a smoke spec
+
+Add an example to `spec/random_name_generator_spec.rb` following the existing `with languages` conventions. The test should assert that the constant is a `File`, that its `path` includes the expected filename, and that a `Generator` built from it composes a non-empty `String`.
+
+Example shape:
+
+```ruby
+it "when it has a <Theme> language" do
+  expect(RandomNameGenerator::CONSTANT_NAME).to be_a(File)
+  expect(RandomNameGenerator::CONSTANT_NAME.path).to include("languages/<relative/path>.txt")
+  name = RandomNameGenerator::Generator.new(RandomNameGenerator::CONSTANT_NAME).compose
+  expect(name).to be_a(String)
+  expect(name).not_to be_empty
+end
+```
+
+### 5. Add a README entry
+
+Add the new language to `README.md`. Edgy or experimental languages should go under a short experimental-languages note. Tame ones should join the curated list. Link to the file using the same style as the existing entries.
+
+### 6. Verify
+
+First parse-check the language file and confirm all three buckets are non-empty. Then sample about 10 composed names so the user can eyeball them. Finally, run the targeted spec.
+
+Suggested commands:
+
+```bash
+bundle exec ruby -Ilib -rrandom_name_generator -e '
+  g = RandomNameGenerator::Generator.new(RandomNameGenerator::CONSTANT_NAME)
+  abort "empty pre"  if g.pre_syllables.empty?
+  abort "empty mid"  if g.mid_syllables.empty?
+  abort "empty sur"  if g.sur_syllables.empty?
+  puts "buckets OK: #{g.pre_syllables.size}/#{g.mid_syllables.size}/#{g.sur_syllables.size}"
+'
+```
+
+```bash
+bundle exec ruby -Ilib -rrandom_name_generator -e '
+  g = RandomNameGenerator::Generator.new(RandomNameGenerator::CONSTANT_NAME)
+  10.times { puts g.compose }
+'
+```
+
+```bash
+bundle exec rspec spec/random_name_generator_spec.rb
+```
+
+If names look broken or monotonous, iterate on the `.txt` file and re-sample before finishing.
+
+### 7. Hand off the commit
+
+Do not run git commands yourself. Surface the exact command for the user:
+
+```bash
+git add lib/languages README.md lib/random_name_generator.rb spec/random_name_generator_spec.rb && git commit -m "Add <Theme> language via lang-gen"
+```
+
+## Guardrails
+
+- Never overwrite an existing language file or constant without confirmation.
+- Never run state-changing git commands; only suggest them.
+- Keep bucket sizes and flag style consistent with existing `lib/languages/*.txt` files.

data/exe/random_name_generator

@@ -11,9 +11,12 @@ opts = Slop.parse do |o|
   o.bool "-e", "--elven", "Use Elven eyllable file"
   o.bool "-g", "--goblin", "Use Goblin eyllable file"
   o.bool "-r", "--roman", "Use Roman eyllable file"
+  o.bool "-k", "--klingon", "Use Klingon eyllable file"
   o.bool "-f", "--flipmode", "Flip mode in effect"
   o.bool "-c", "--cyrillic", "Use Cyrillic mode"
   o.bool "-x", "--xrated", "Generate Curse words [NEEDS WORK]"
+  o.bool "-d", "--demonic", "Generate Demonic names"
+  o.bool "-ß", "--german-curse", "Generate German Curse words [NEEDS WORK]"
   o.bool "-?", "--help", "How to"
 end
 
@@ -26,7 +29,10 @@ else
   lang = RandomNameGenerator::ELVEN if opts.elven?
   lang = RandomNameGenerator::GOBLIN if opts.goblin?
   lang = RandomNameGenerator::ROMAN if opts.roman?
+  lang = RandomNameGenerator::KLINGON if opts.klingon?
   lang = RandomNameGenerator::CURSE if opts.xrated?
+  lang = RandomNameGenerator::DEMONIC if opts.demonic?
+  lang = RandomNameGenerator::GERMAN_CURSE if opts.german_curse?
 end
 
 if opts.flipmode?