regex-dungeon 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Haneul-two
+
+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.

package/README.md

@@ -0,0 +1,131 @@
+# 🗡️ regex-dungeon
+
+![regex-dungeon gameplay](assets/demo.gif)
+
+A **zero-dependency terminal roguelike that teaches regex**. Each floor throws monsters at you — some you *must* slay, some you *must* spare — and you fight them with **one regular expression**. Match the right ones, miss the wrong ones, descend deeper.
+
+> 🇰🇷 한국어 설명은 [아래](#-한국어)에 있습니다.
+
+```
+Floor 3/8  Anchors ^ $   ♥♥♥♡♡
+  ^ = start, $ = end. Without them, a pattern matches substrings too.
+
+  ▲ SLAY   cat
+  ○ SPARE  category
+  ○ SPARE  scatter
+  ○ SPARE  tomcat
+
+  your pattern ▶ ^cat$
+
+  ▲ cat        ✓ slain
+  ○ category   ✓ spared
+  ○ scatter    ✓ spared
+  ○ tomcat     ✓ spared
+  Floor cleared!  +110
+```
+
+One file, **zero dependencies**, runs with one command. Auto-detects your language (English / 한국어).
+
+## Play
+
+Requires [Node.js](https://nodejs.org) ≥ 16. No install needed:
+
+```bash
+npx regex-dungeon
+```
+
+Or clone and run:
+
+```bash
+git clone https://github.com/Haneul-two/regex-dungeon.git
+cd regex-dungeon
+node index.js
+```
+
+## How it works
+
+- Each floor teaches **one regex concept** (literals → `.`/classes → anchors → quantifiers → optionals → `\d{n}` → groups/`|` → a boss email).
+- You type a single pattern. The game tests it against every monster:
+  - **▲ SLAY** monsters *must* match.
+  - **○ SPARE** monsters *must not* match.
+- Get it perfect → floor cleared. Any mistake → lose a heart (♥). Run out → you die.
+- **Shorter patterns score higher** (beat par), fewer attempts score higher.
+- Stuck? Type `?` for a hint, or `??` to reveal the answer (that floor scores 0).
+
+```bash
+regex-dungeon --lang ko     # force Korean (or set BEAR_LANG=ko)
+regex-dungeon --selftest    # verify every floor is solvable
+regex-dungeon --help
+```
+
+## Contributing floors
+
+Floors live in the `FLOORS` array in `index.js`. A floor is just data:
+
+```js
+{
+  concept: { en: 'Quantifier +', ko: '수량자 +' },
+  lesson:  { en: '`+` means "one or more"...', ko: '`+` 는 "1개 이상"...' },
+  slay:    ['go', 'goo', 'goooo'],   // MUST match
+  spare:   ['g', 'ga', 'good'],      // must NOT match
+  par:     6,                        // target pattern length
+  solution:'^go+$'                   // used by --selftest and the ?? reveal
+}
+```
+
+PRs with new floors are very welcome — run `npm test` (it's `--selftest`) to confirm your floor is solvable by its own `solution`, then open a PR.
+
+## License
+
+MIT
+
+---
+
+## 🇰🇷 한국어
+
+**의존성 없는 터미널 로그라이크로 정규식을 배우는 게임.** 각 층마다 몬스터가 나오는데, 어떤 놈은 *반드시 처치*하고 어떤 놈은 *반드시 살려둬야* 합니다. 무기는 **정규식 하나**. 맞춰야 할 놈만 매치하고 엉뚱한 놈은 피하면서 던전을 내려가세요. 단일 파일, 의존성 0, 명령어 한 줄. 언어는 자동 감지(영어 / 한국어)됩니다.
+
+```
+3/8 층  앵커 ^ $   ♥♥♥♡♡
+  ^ 시작, $ 끝. 없으면 부분 문자열도 매치돼 버립니다.
+
+  ▲ 처치   cat
+  ○ 회피   category
+  ○ 회피   scatter
+  ○ 회피   tomcat
+
+  네 패턴 ▶ ^cat$
+  ...
+  층 클리어!  +110
+```
+
+### 플레이
+
+[Node.js](https://nodejs.org) ≥ 16 필요. 설치 없이 실행:
+
+```bash
+npx regex-dungeon
+```
+
+### 규칙
+
+- 각 층은 **정규식 개념 1개**를 가르칩니다 (리터럴 → `.`/문자클래스 → 앵커 → 수량자 → 선택 → `\d{n}` → 그룹/`|` → 보스 이메일).
+- 패턴 하나를 입력하면 모든 몬스터에 대해 테스트합니다.
+  - **▲ 처치** 몬스터는 *반드시* 매치돼야 함.
+  - **○ 회피** 몬스터는 *절대* 매치되면 안 됨.
+- 완벽하면 층 클리어. 실수하면 하트(♥) 감소. 다 잃으면 사망.
+- **패턴이 짧을수록**, 시도가 적을수록 점수가 높습니다.
+- 막히면 `?` 로 힌트, `??` 로 정답 공개(해당 층 0점).
+
+```bash
+regex-dungeon --lang ko     # 한국어 강제 (또는 BEAR_LANG=ko)
+regex-dungeon --selftest    # 모든 층이 풀리는지 검증
+```
+
+### 층 기여하기
+
+층은 `index.js` 의 `FLOORS` 배열에 데이터로 들어 있습니다. 새 층 PR을 환영합니다 — `npm test`(=`--selftest`)로 본인 층이 `solution` 으로 풀리는지 확인 후 PR 해주세요.
+
+### License
+
+MIT

package/index.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * regex-dungeon — a zero-dependency terminal roguelike that teaches regex.
+ * Descend the dungeon; slay the monsters that must die, spare the rest,
+ * using one regular expression per floor. MIT licensed.
+ */
+
+const readline = require('readline');
+
+// ─── colors ────────────────────────────────────────────────────────────────
+const NO_COLOR = process.env.NO_COLOR || !process.stdout.isTTY;
+const c = (code) => (s) => (NO_COLOR ? s : `\x1b[${code}m${s}\x1b[0m`);
+const red = c('31'), green = c('32'), yellow = c('33');
+const cyan = c('36'), magenta = c('35'), dim = c('2'), bold = c('1');
+
+// ─── i18n ────────────────────────────────────────────────────────────────--
+const LANG =
+  (process.argv.includes('--lang')
+    ? process.argv[process.argv.indexOf('--lang') + 1]
+    : (process.env.BEAR_LANG || process.env.LANG || 'en')
+  ).toLowerCase().startsWith('ko')
+    ? 'ko'
+    : 'en';
+
+const T = {
+  en: {
+    title: 'REGEX DUNGEON',
+    subtitle: 'slay with a single regex',
+    floor: 'Floor',
+    slay: 'SLAY',
+    spare: 'SPARE',
+    prompt: 'your pattern',
+    slain: 'slain',
+    missed: 'missed!',
+    spared: 'spared',
+    hit: 'HIT!',
+    cleared: 'Floor cleared!',
+    invalid: 'Invalid regex — that spell fizzles. (no damage)',
+    damage: 'You took 1 damage.',
+    hintTip: "Type ? for a hint, ?? to reveal the answer (no score).",
+    hint: 'Hint',
+    answer: 'Answer',
+    gameover: 'YOU DIED',
+    victory: 'YOU CLEARED THE DUNGEON',
+    floorsCleared: 'Floors cleared',
+    score: 'Score',
+    share: 'Share',
+    shareMsg: (n, total) =>
+      `I cleared ${n}/${total} floors of regex-dungeon! 🗡️`,
+    playAgain: 'Run `npx regex-dungeon` to try again.',
+    quitHint: '(ctrl+c to quit)',
+  },
+  ko: {
+    title: '정규식 던전',
+    subtitle: '정규식 하나로 처치하라',
+    floor: '층',
+    slay: '처치',
+    spare: '회피',
+    prompt: '네 패턴',
+    slain: '처치됨',
+    missed: '놓침!',
+    spared: '회피됨',
+    hit: '오격!',
+    cleared: '층 클리어!',
+    invalid: '잘못된 정규식 — 주문이 불발됐다. (피해 없음)',
+    damage: '피해 1을 입었다.',
+    hintTip: '? 입력 시 힌트, ?? 입력 시 정답 공개(점수 없음).',
+    hint: '힌트',
+    answer: '정답',
+    gameover: '당신은 죽었다',
+    victory: '던전을 클리어했다',
+    floorsCleared: '클리어한 층',
+    score: '점수',
+    share: '공유',
+    shareMsg: (n, total) => `regex-dungeon ${total}층 중 ${n}층 클리어! 🗡️`,
+    playAgain: '다시 하려면 `npx regex-dungeon` 실행.',
+    quitHint: '(ctrl+c 로 종료)',
+  },
+}[LANG];
+
+// ─── floors ──────────────────────────────────────────────────────────────--
+// Each floor teaches one concept. `slay` MUST match, `spare` must NOT match.
+// `par` is the target pattern length (shorter than par earns bonus points).
+// `solution` is used for the --selftest and the ?? reveal.
+const FLOORS = [
+  {
+    concept: { en: 'Literals', ko: '리터럴' },
+    lesson: {
+      en: 'A regex with no special chars matches that exact text anywhere in a string.',
+      ko: '특수문자 없는 정규식은 그 글자가 문자열 어딘가에 있으면 매치됩니다.',
+    },
+    slay: ['cat'],
+    spare: ['dog', 'cap', 'bat'],
+    par: 3,
+    solution: 'cat',
+  },
+  {
+    concept: { en: 'The dot & classes', ko: '점(.)과 문자클래스' },
+    lesson: {
+      en: '`.` matches any one char; `[aou]` matches any one char in the set.',
+      ko: '`.` 는 아무 글자 하나, `[aou]` 는 집합 안의 글자 하나와 매치됩니다.',
+    },
+    slay: ['cat', 'cot', 'cut'],
+    spare: ['cap', 'cog', 'dog'],
+    par: 5,
+    solution: 'c[aou]t',
+  },
+  {
+    concept: { en: 'Anchors ^ $', ko: '앵커 ^ $' },
+    lesson: {
+      en: '`^` = start, `$` = end. Without them, a pattern matches substrings too.',
+      ko: '`^` 시작, `$` 끝. 없으면 부분 문자열도 매치돼 버립니다.',
+    },
+    slay: ['cat'],
+    spare: ['category', 'scatter', 'tomcat'],
+    par: 5,
+    solution: '^cat$',
+  },
+  {
+    concept: { en: 'Quantifier +', ko: '수량자 +' },
+    lesson: {
+      en: '`+` means "one or more of the previous". `go+` = g then 1+ o.',
+      ko: '`+` 는 "앞 글자 1개 이상". `go+` = g 다음 o 1개 이상.',
+    },
+    slay: ['go', 'goo', 'goooo'],
+    spare: ['g', 'ga', 'good'],
+    par: 6,
+    solution: '^go+$',
+  },
+  {
+    concept: { en: 'Optional ?', ko: '선택 ?' },
+    lesson: {
+      en: '`?` makes the previous char optional. Great for spelling variants.',
+      ko: '`?` 는 앞 글자를 선택적으로. 철자 변형에 유용합니다.',
+    },
+    slay: ['color', 'colour'],
+    spare: ['collar', 'coler'],
+    par: 8,
+    solution: '^colou?r$',
+  },
+  {
+    concept: { en: 'Digits & {n}', ko: '숫자 \\d 와 {n}' },
+    lesson: {
+      en: '`\\d` = a digit, `{4}` = exactly four of them. Perfect for years.',
+      ko: '`\\d` 숫자 하나, `{4}` 정확히 4개. 연도에 딱 맞습니다.',
+    },
+    slay: ['2026', '1999'],
+    spare: ['20', 'abcd', '12a4'],
+    par: 7,
+    solution: '^\\d{4}$',
+  },
+  {
+    concept: { en: 'Groups & | (OR)', ko: '그룹과 | (OR)' },
+    lesson: {
+      en: '`(cat|dog)` matches cat OR dog. Parens group; `|` is alternation.',
+      ko: '`(cat|dog)` 는 cat 또는 dog. 괄호로 묶고 `|` 로 양자택일.',
+    },
+    slay: ['cat', 'dog'],
+    spare: ['cow', 'fox'],
+    par: 11,
+    solution: '^(cat|dog)$',
+  },
+  {
+    concept: { en: 'BOSS — Email', ko: '보스 — 이메일' },
+    lesson: {
+      en: 'Combine it all: `\\S` = non-space. Match something@something.something.',
+      ko: '총동원: `\\S` 는 공백 아닌 글자. something@something.something 매치.',
+    },
+    slay: ['a@b.com', 'jane.doe@mail.io'],
+    spare: ['a@b', '@b.com', 'ab.com', 'a b@c.com'],
+    par: 14,
+    solution: '^\\S+@\\S+\\.\\S+$',
+    boss: true,
+  },
+];
+
+// ─── core logic (pure, used by game + selftest) ──────────────────────────────
+function evaluate(pattern, floor) {
+  let re;
+  try {
+    re = new RegExp(pattern);
+  } catch (e) {
+    return { valid: false };
+  }
+  const rows = [
+    ...floor.slay.map((s) => ({ s, target: true })),
+    ...floor.spare.map((s) => ({ s, target: false })),
+  ].map((row) => {
+    const matched = re.test(row.s);
+    return { ...row, matched, correct: matched === row.target };
+  });
+  const mistakes = rows.filter((r) => !r.correct).length;
+  return { valid: true, rows, mistakes, cleared: mistakes === 0 };
+}
+
+// ─── rendering ───────────────────────────────────────────────────────────--
+function banner() {
+  const line = '═'.repeat(40);
+  console.log(magenta(`╔${line}╗`));
+  console.log(magenta('║') + bold(center(`🗡️  ${T.title}  🗡️`, 40)) + magenta('║'));
+  console.log(magenta('║') + dim(center(T.subtitle, 40)) + magenta('║'));
+  console.log(magenta(`╚${line}╝`));
+}
+
+function center(s, w) {
+  // width-aware enough for our ASCII-ish content
+  const len = [...s].length + (s.match(/🗡️/g) || []).length; // emojis ~2 cols
+  const pad = Math.max(0, w - len);
+  const left = Math.floor(pad / 2);
+  return ' '.repeat(left) + s + ' '.repeat(pad - left);
+}
+
+function hearts(hp, max) {
+  return red('♥'.repeat(hp)) + dim('♡'.repeat(max - hp));
+}
+
+function showFloor(i, floor, hp, maxHp) {
+  console.log();
+  console.log(
+    bold(`${T.floor} ${i + 1}/${FLOORS.length}`) +
+      '  ' +
+      cyan(floor.concept[LANG]) +
+      '   ' +
+      hearts(hp, maxHp)
+  );
+  console.log(dim('  ' + floor.lesson[LANG]));
+  console.log();
+  for (const s of floor.slay) console.log('  ' + red('▲ ' + T.slay) + '  ' + bold(s));
+  for (const s of floor.spare) console.log('  ' + dim('○ ' + T.spare) + '  ' + dim(s));
+  console.log();
+  console.log(dim('  ' + T.hintTip));
+}
+
+function showResult(result) {
+  console.log();
+  for (const r of result.rows) {
+    const ok = r.correct;
+    let verb;
+    if (r.target) verb = r.matched ? green('✓ ' + T.slain) : red('✗ ' + T.missed);
+    else verb = r.matched ? red('✗ ' + T.hit) : green('✓ ' + T.spared);
+    const mark = r.target ? red('▲') : dim('○');
+    console.log('  ' + mark + ' ' + (ok ? r.s : bold(r.s)).padEnd(18) + verb);
+  }
+  console.log();
+}
+
+// ─── game loop ───────────────────────────────────────────────────────────--
+async function play() {
+  banner();
+  const maxHp = 5;
+  let hp = maxHp;
+  let score = 0;
+  let cleared = 0;
+
+  // Queue-based line reader: robust to buffered/piped input as well as
+  // interactive typing (rl.question would drop lines that arrive between asks).
+  const rl = readline.createInterface({ input: process.stdin });
+  const queue = [];
+  let waiting = null;
+  let closed = false;
+  rl.on('line', (line) => {
+    if (waiting) {
+      const w = waiting;
+      waiting = null;
+      w(line);
+    } else queue.push(line);
+  });
+  rl.on('close', () => {
+    closed = true;
+    if (waiting) {
+      const w = waiting;
+      waiting = null;
+      w(null);
+    }
+  });
+  const ask = (q) =>
+    new Promise((res) => {
+      process.stdout.write(q);
+      if (queue.length) res(queue.shift());
+      else if (closed) res(null);
+      else waiting = res;
+    });
+
+  for (let i = 0; i < FLOORS.length; i++) {
+    const floor = FLOORS[i];
+    showFloor(i, floor, hp, maxHp);
+    let attempts = 0;
+    let usedReveal = false;
+    let floorDone = false;
+
+    while (!floorDone) {
+      const raw = await ask('\n  ' + cyan(T.prompt) + ' ▶ ');
+      if (raw === null) {
+        // stdin closed (ctrl+D / end of piped input) — bail out gracefully
+        rl.close();
+        return endCard(false, cleared, score);
+      }
+      const ans = raw.trim();
+
+      if (ans === '?') {
+        console.log('  ' + yellow(T.hint + ': ') + floor.lesson[LANG]);
+        continue;
+      }
+      if (ans === '??') {
+        usedReveal = true;
+        console.log('  ' + yellow(T.answer + ': ') + bold(floor.solution));
+        continue;
+      }
+      if (ans === '') continue;
+
+      attempts++;
+      const result = evaluate(ans, floor);
+      if (!result.valid) {
+        console.log('  ' + yellow(T.invalid));
+        attempts--; // a fizzle costs nothing
+        continue;
+      }
+      showResult(result);
+
+      if (result.cleared) {
+        const parBonus = Math.max(0, floor.par - ans.length) * 5;
+        const attemptPenalty = (attempts - 1) * 10;
+        let gain = usedReveal ? 0 : Math.max(10, 100 + parBonus - attemptPenalty);
+        score += gain;
+        cleared++;
+        console.log('  ' + green(bold(T.cleared)) + dim(`  +${gain}`));
+        floorDone = true;
+      } else {
+        hp -= 1;
+        console.log('  ' + red(T.damage) + '  ' + hearts(hp, maxHp));
+        if (hp <= 0) {
+          rl.close();
+          return endCard(false, cleared, score);
+        }
+      }
+    }
+  }
+
+  rl.close();
+  return endCard(true, cleared, score);
+}
+
+function endCard(won, cleared, score) {
+  const line = '═'.repeat(40);
+  console.log();
+  console.log(magenta(`╔${line}╗`));
+  console.log(
+    magenta('║') +
+      bold(center(won ? '🏆 ' + T.victory : '💀 ' + T.gameover, 40)) +
+      magenta('║')
+  );
+  console.log(magenta('║') + center('', 40) + magenta('║'));
+  console.log(
+    magenta('║') +
+      center(`${T.floorsCleared}: ${cleared}/${FLOORS.length}`, 40) +
+      magenta('║')
+  );
+  console.log(magenta('║') + center(`${T.score}: ${score}`, 40) + magenta('║'));
+  console.log(magenta(`╚${line}╝`));
+  console.log();
+  console.log('  ' + dim(T.share + ': ') + T.shareMsg(cleared, FLOORS.length));
+  console.log('  ' + dim('▶ github.com/Haneul-two/regex-dungeon'));
+  console.log('  ' + dim(T.playAgain));
+  console.log();
+}
+
+// ─── selftest: verify every floor is solvable by its intended answer ─────────
+function selftest() {
+  let pass = 0;
+  for (let i = 0; i < FLOORS.length; i++) {
+    const f = FLOORS[i];
+    const r = evaluate(f.solution, f);
+    const ok = r.valid && r.cleared;
+    console.log(
+      `${ok ? green('PASS') : red('FAIL')}  Floor ${i + 1}  ${f.concept.en}  /${f.solution}/`
+    );
+    if (ok) pass++;
+    else if (r.valid) {
+      for (const row of r.rows.filter((x) => !x.correct))
+        console.log(`        ${row.target ? 'should match' : 'should NOT match'}: "${row.s}"`);
+    }
+  }
+  console.log(`\n${pass}/${FLOORS.length} floors valid`);
+  process.exit(pass === FLOORS.length ? 0 : 1);
+}
+
+// ─── entry ───────────────────────────────────────────────────────────────--
+if (process.argv.includes('--selftest')) {
+  selftest();
+} else if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  console.log(`regex-dungeon — learn regex by playing in your terminal.
+
+Usage:
+  npx regex-dungeon            play the game
+  regex-dungeon --lang ko      force Korean (or BEAR_LANG=ko)
+  regex-dungeon --selftest     verify all floors are solvable
+  regex-dungeon --help         show this help`);
+} else {
+  play().catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });
+}
+
+module.exports = { evaluate, FLOORS };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "regex-dungeon",
+  "version": "0.1.0",
+  "description": "A zero-dependency terminal roguelike that teaches regex — slay the monsters that must die, spare the rest, with one regular expression per floor.",
+  "bin": {
+    "regex-dungeon": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "test": "node index.js --selftest"
+  },
+  "keywords": [
+    "regex",
+    "regexp",
+    "game",
+    "cli",
+    "terminal",
+    "roguelike",
+    "learn",
+    "education",
+    "tui",
+    "interactive"
+  ],
+  "author": "Haneul-two",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Haneul-two/regex-dungeon.git"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ]
+}