mintikaryu 1.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2026 Aayush Anand
+
+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,56 @@
+# 🐉 Mintikaryū - The Ancient Summoning
+
+*A sacred CLI tool to summon the ancient dragon Mintikaryū (みんてぃかりゅう) from the deepest realms of the terminal.*
+
+![The Manifestation of Mintikaryū](./render1775404114849.gif)
+
+> *"When the digital abyss burns with the fires of ancient times, Mintikaryū shall rise to reclaim its hollow domain."*
+
+## 📜 The Sacred Grimoire (Features)
+
+- **The Flames of Genesis**: A dynamic, physics-based inferno simulation forged in pure ASCII, representing the primordial energies of creation.
+- **The Gracious Ascension**: Watch in awe as Mintikaryū majestically ascends from the bottomless depths of your screen to assert absolute dominion over your terminal.
+- **Arcane Adaptability**: The ritual seamlessly adapts to the shifting dimensions of your terminal window, preserving the ancient aesthetic undisturbed.
+- **True Emerald Auras**: Ensorcelled with raw, true-color ANSI incantations to bathe your screen in the authentic, vibrant glow of the dragon's mythic scales.
+
+## 🕯️ Reagents for the Ritual (Prerequisites)
+
+- **Node.js**: The sacred runtime. Ensure you have a modern version supporting ESM modules (Node 12.20.0 or higher).
+
+## 🔮 Forging the Pact (Installation)
+
+To embed the `summon-dragon` incantation into your system so it may be cast anywhere within your digital kingdom, you must bind its essence globally. 
+
+Trace these arcane coordinates within the project's sanctum (root directory):
+
+```bash
+npm install
+npm link
+```
+
+Once the pact is woven, you may call upon the ancient beast simply by chanting in your terminal:
+
+```bash
+summon-dragon
+```
+
+### The Solitary Invocation (Running Locally)
+
+Should you wish to cast the spell solely within the confines of its origin folder, without forging a global pact:
+
+```bash
+npm install
+node index.js
+```
+
+## ⚔️ Banishing the Beast (Controls)
+
+A dragon's presence commands heavy tolls upon the mortal realm. To banish Mintikaryū back to its slumber, sever the connection by invoking the celestial banishment sigil: 
+
+Press `CTRL + C`
+
+## ⚒️ The Arcane Foundation
+
+- **Node.js Subsystems**: Tapping into the raw, fundamental energies of the operating system.
+- `cli-cursor`: Master of illusions, concealing the cursor to perfect the summoning circle.
+- `"type": "module"`: Strict adherence to the ancient laws of modern ECMAScript.

package/colorUtils.js

@@ -0,0 +1,8 @@
+export function colorize(hex, text) {
+  if (!hex) return text;
+  const hashLess = hex.startsWith('#') ? hex.slice(1) : hex;
+  const r = parseInt(hashLess.slice(0, 2), 16);
+  const g = parseInt(hashLess.slice(2, 4), 16);
+  const b = parseInt(hashLess.slice(4, 6), 16);
+  return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+}

package/dragon.js

@@ -0,0 +1,12 @@
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const dragonArt = fs.readFileSync(join(__dirname, 'dragon.txt'), 'utf8');
+export const dragonLines = dragonArt.split('\n');
+
+export const dragonWidth = Math.max(...dragonLines.map(l => l.length));
+export const dragonHeight = dragonLines.length;

package/dragon.txt

@@ -0,0 +1,36 @@
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⠆⠀⠀⢠⡞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡾⡇⠀⠀⠀⡿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⠟⣶⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣇⠹⣆⠀⢠⠃⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡏⡏⠀⠘⡼⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣦⡈⠓⢾⠀⣧⡀⠀⠀⠀⠀⠀⣤⣤⣴⣶⣦⢤⣄⡀⠀⠀⢸⠀⣧⠀⠀⢧⠘⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣿⣦⣼⠀⡿⡏⠙⠲⠤⣀⡀⠀⠈⠙⣆⠈⠓⣄⠙⢢⡀⠈⣆⠘⢇⠀⠸⡇⠘⣆⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⢻⠀⢸⣹⡀⠠⣀⠀⠉⠙⠲⢄⡈⣆⠀⠈⢣⡀⢱⣄⣸⢦⣤⣑⢄⡇⠀⠸⡆⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⡀⠘⣇⢻⣶⣌⠙⢦⡀⠀⠀⠉⠺⢦⠀⠨⡇⠀⠙⣶⣉⣴⠛⠻⠱⣄⠀⢱⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣴⣖⣉⣇⠀⠸⡄⠹⣌⠳⣦⡙⢶⣄⠀⠀⠀⠙⢆⣟⠀⡸⠫⢿⡜⣆⠀⠀⠘⢆⠈⡆⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣠⠽⣿⠀⠀⠹⡄⠈⢧⡈⠻⣆⠙⣧⣀⠀⠀⠀⠹⣄⡀⠀⡜⠳⣘⡄⠀⠀⠘⣇⡇⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⣾⣿⣛⠛⠛⠿⣦⡀⠀⠙⢤⠀⠱⣦⢽⣧⡈⢻⡇⠀⠀⢀⣹⣏⣼⡁⠀⢙⣧⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢈⡇⠀⠀⢳⡳⣀⠀⠀⢳⡄⠈⢷⣌⣷⣠⡿⣿⣫⣿⣾⣿⣄⠀⡴⠋⠙⠳⣶⣶⢬⣿⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⣤⣴⣯⣤⣤⣤⣤⣷⡈⢷⣦⡀⠙⢦⠀⣈⠛⢿⣾⣿⠋⢁⠔⠚⠻⢟⠣⠀⠔⠉⠙⢮⣙⣿⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⣠⣾⠿⢭⡉⠀⠀⠀⠈⠉⠙⠛⣿⣦⡉⢿⣦⣌⢣⡈⢷⡀⡼⢿⡄⠈⠀⡠⠒⠚⠳⢄⠀⢀⠖⠙⢿⣿⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠘⠁⠀⠀⣠⣇⣠⣤⣤⣤⣤⡴⠚⢉⣿⣿⣦⡈⠙⣷⣽⣄⣿⠃⠀⠙⢷⣼⡁⠀⡀⠐⠒⠯⣉⠀⢠⠴⣿⣆⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⣠⣴⡿⠛⠋⠉⠁⠉⢹⠟⠀⠀⠀⣠⣽⣿⣷⡀⠸⠿⢿⡇⠀⠀⠀⠀⢹⣷⣦⣇⠀⢀⠘⠙⠛⡇⠀⠸⣿⣿⡀⠀⠀⠀
+⠀⠀⠀⠀⢀⣼⣯⣅⠀⠀⠀⠀⣀⡴⠋⠀⠐⠒⠉⠉⠉⠛⣿⣷⣄⡀⢸⣧⠀⠀⠀⠀⠀⢻⣿⣿⣿⣾⠀⠀⠀⠀⡄⠀⡇⠈⣧⠀⠀⠀
+⠀⠀⠀⢀⠟⠁⠀⣸⣠⡴⠾⢿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠨⢟⣛⣿⡟⠉⢳⣄⠀⠀⠀⠀⢻⡈⠉⠻⣷⣀⠀⠀⢸⣼⣇⣧⡿⠀⠀⠀
+⠀⠀⠀⠀⢀⡴⠞⠋⠀⠀⢠⠞⠀⠀⠀⠀⢀⣠⠤⢔⣾⣿⠿⠛⢿⢹⠁⠀⠀⠙⢷⡄⠀⠀⠀⠙⠻⣿⣿⡟⣟⠛⠁⣿⠀⣿⠁⠀⠀⠀
+⠀⠀⠀⣰⠟⠁⠀⠀⢀⣠⠏⠀⠀⠀⣠⠖⠋⣠⣾⡟⠛⣧⠀⠀⠘⢿⡄⠀⠀⠀⠀⠳⠀⠀⠀⠀⠀⠈⢿⣇⠹⠀⠀⢸⡀⣿⠀⠀⠀⠀
+⠀⠀⢰⣏⣄⠀⣠⣶⢿⠏⠀⠀⠀⠞⠁⣠⣾⡿⡏⠀⠀⠈⠳⣄⣀⣀⣻⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⢦⠀⠀⠘⢇⢹⠀⠀⠀⠀
+⠀⠀⡿⠁⣰⡾⠛⠀⡜⠀⠀⠀⠀⢀⣼⡿⠃⠘⢳⡀⠀⠀⢠⠋⠳⢄⡀⠙⢦⣀⠀⠀⠀⢀⠀⠀⠀⠀⠀⠙⠾⠀⠀⠀⠈⠋⣇⠀⠀⠀
+⠀⠀⠁⣼⠛⠀⠀⣸⠃⠀⠀⠀⢀⣾⡟⣷⠀⠀⠀⠙⠒⠒⠚⢷⠖⠋⢉⡿⠋⠉⠓⢦⣄⠸⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⡆⠀⠀
+⠀⠀⣸⠃⠀⢀⣴⡇⠀⠀⠀⢀⣾⡟⠉⠉⢧⡀⠀⠀⠘⣆⣀⠤⢷⣶⠟⠀⠀⠀⠀⠀⠈⠱⣄⠉⠳⢤⡀⠀⠀⠀⢰⡎⠉⠲⠄⢹⠲⡄
+⠀⠀⣧⠞⣧⣾⢿⠁⠀⠀⠀⣼⡿⡁⠀⠀⠀⠈⠹⡟⠛⠙⣆⡤⣾⡟⠀⠀⠀⠀⠀⠀⠀⠀⠈⢳⡀⠀⠙⢦⡀⠀⢀⣿⣄⠀⠀⠀⠀⢸
+⠀⢸⠃⣰⡟⠁⣾⠀⠀⠀⢸⣿⣤⠧⣄⠀⠀⠀⢀⣱⠤⠒⠁⢠⡿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢦⣵⡄⢻⠀⠸⡻⣿⣄⣤⠀⠀⡼
+⠀⠉⢸⡟⠀⠀⡿⠀⠀⠀⣿⡇⠀⠀⠀⠉⢹⡏⠉⠈⣷⠤⠴⣿⢻⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢷⠀⢧⡀⠀⠾⠀⠀⢸⢠⠇
+⠀⠀⡿⠁⠀⠀⡇⠀⠀⢰⡟⢱⣄⠀⠀⠀⠀⢣⠤⠚⠁⠀⢰⣿⠘⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⠷⣄⡉⠳⢦⣀⡤⣾⡟⠀
+⠀⢸⣇⡤⠤⣄⡇⠀⠀⣿⡏⠉⠈⠙⠒⡖⠒⠉⢷⡀⠀⣠⢾⡟⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠛⠛⠛⠀⠀⠀⠀⠀
+⠀⣼⠏⠀⢀⣿⡇⠀⢀⣿⡀⠀⠀⠀⠀⠙⣆⣀⠴⠋⠉⠑⢾⡇⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⢹⠀⢀⣿⠏⣇⠀⢸⣿⢑⡤⣀⣀⣀⡴⠛⣇⠀⠀⠀⢀⣼⡇⠀⠸⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⣼⡏⠀⣧⠀⣼⡿⠉⠀⠈⠉⢧⡀⠀⢈⡷⠒⠒⠫⣼⡇⠀⠀⢿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⢠⣿⣠⢦⣿⠀⣿⣧⠀⠀⠀⠀⠀⢉⣞⠉⠀⠀⠀⠀⢸⣧⠀⠀⠈⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⣿⠁⢸⣿⢰⣿⣏⡳⠤⣤⡤⠖⠉⠘⢦⡀⠀⠀⣠⡾⣿⠀⠀⠀⠸⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠋⠀⡞⣿⢸⣿⠀⠀⠀⠈⠣⡀⠀⢀⣠⠛⠉⠉⠉⠓⣿⡄⠀⠀⠀⠘⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⣾⠃⣿⡇⠀⠀⠀⠀⠀⢈⣿⣏⠀⠀⠀⠀⠀⠀⠀⢸⠿⣷⡀⠀⠈⠛⢶⣄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⢠⡇⠀⣿⣿⣦⣤⣤⣶⠟⠁⠈⠈⠳⢤⣀⣀⣀⡤⠴⠚⠚⠛⣷⡄⠀⠀⠀⠉⠛⠳⢤⣄⡀⠀⠀⠀⠀⠀⠀⠀

package/fire.js

@@ -0,0 +1,112 @@
+import { colorize } from './colorUtils.js';
+
+// 1. Softer character palette (Removed aggressive shapes)
+const FIRE_CHARS = ' .,:;+*xX%#'.split('');
+
+// 2. Warmer, subtler palette (More deep reds, peaks at warm amber, no harsh white)
+const COLORS = [
+  null,
+  '#1a0000', '#330000', '#4d0000', '#660000', '#800000',
+  '#991a00', '#b33300', '#cc4d00', '#e66600', '#ff8000',
+  '#ff9933', '#ffb366', '#ffcc99' 
+];
+
+export class FireSystem {
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    
+    this.firePixels = new Array(this.width * this.height).fill(0);
+    this.initBottomRow();
+  }
+
+  resize(width, height) {
+    this.width = width;
+    this.height = height;
+    this.firePixels = new Array(this.width * this.height).fill(0);
+    this.initBottomRow();
+  }
+
+  initBottomRow() {
+    const bottomY = this.height - 1;
+    const maxIntensity = COLORS.length - 1;
+    
+    for (let x = 0; x < this.width; x++) {
+      this.firePixels[bottomY * this.width + x] = maxIntensity;
+    }
+  }
+
+  update() {
+    for (let x = 0; x < this.width; x++) {
+      for (let y = 1; y < this.height; y++) {
+        const src = y * this.width + x;
+        
+        // 3. Decoupled physics: Heat drops gently but consistently
+        // Drops by 1 about 60% of the time, resulting in shorter, smoother flames
+        const heatLoss = Math.random() > 0.4 ? 1 : 0; 
+        
+        // 4. Subtler wind: mostly straight up, occasional gentle sway
+        const windChance = Math.random();
+        let shiftX = 0;
+        if (windChance < 0.25) shiftX = -1; // Gentle drift left
+        else if (windChance > 0.75) shiftX = 1; // Gentle drift right
+        
+        let destX = x + shiftX;
+        
+        // Boundary wrapping/clamping
+        if (destX < 0) destX = 0;
+        if (destX >= this.width) destX = this.width - 1;
+        
+        const dest = (y - 1) * this.width + destX;
+        let pixel = this.firePixels[src] - heatLoss;
+        
+        if (pixel < 0) pixel = 0;
+        
+        this.firePixels[dest] = pixel;
+      }
+    }
+    
+    // 5. Softer base generation
+    // Instead of a solid wall of max intensity, we poke "holes" in the bottom
+    // row to create the illusion of individual, distinct flames swaying up.
+    const bottomY = this.height - 1;
+    for (let x = 0; x < this.width; x++) {
+       if (Math.random() < 0.35) {
+         // Drop intensity by 0 to 3 levels to create gaps
+         const drop = Math.floor(Math.random() * 4); 
+         this.firePixels[bottomY * this.width + x] = Math.max(0, (COLORS.length - 1) - drop);
+       } else {
+         this.firePixels[bottomY * this.width + x] = COLORS.length - 1;
+       }
+    }
+  }
+
+  draw(buffer) {
+    const maxIntensity = COLORS.length - 1;
+    for (let y = 0; y < this.height; y++) {
+      if (!buffer[y]) buffer[y] = new Array(this.width).fill(' ');
+      
+      for (let x = 0; x < this.width; x++) {
+        let intensity = this.firePixels[y * this.width + x];
+        if (intensity < 0) intensity = 0;
+        if (intensity > maxIntensity) intensity = maxIntensity;
+
+        // Explicitly render empty space for 0 intensity to avoid artifacts
+        if (intensity === 0) {
+            buffer[y][x] = ' ';
+            continue;
+        }
+
+        const charIndex = Math.floor((intensity / maxIntensity) * (FIRE_CHARS.length - 1));
+        const char = FIRE_CHARS[charIndex];
+        
+        const colorHex = COLORS[intensity];
+        if (colorHex) {
+          buffer[y][x] = colorize(colorHex, char);
+        } else {
+          buffer[y][x] = char; 
+        }
+      }
+    }
+  }
+}

package/index.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+import cliCursor from "cli-cursor";
+import { colorize } from "./colorUtils.js";
+import readline from "readline";
+import { dragonLines, dragonWidth, dragonHeight } from "./dragon.js";
+import { FireSystem } from "./fire.js";
+
+function exitGracefully() {
+  cliCursor.show();
+  process.stdout.write("\x1b[2J\x1b[3J\x1b[H"); // Clear full screen and history, move to top
+  process.exit(0);
+}
+
+process.on("SIGINT", exitGracefully);
+process.on("SIGTERM", exitGracefully);
+
+let width = process.stdout.columns || 80;
+let height = process.stdout.rows || 24;
+
+const fire = new FireSystem(width, height);
+
+// Dragon starting position (bottom centered)
+let dragonX = (width - dragonWidth) / 2;
+let dragonY = height;
+
+// Movement speeds (frames)
+let dy = 0.5;
+
+// Prepare color function for dragon
+const colorDragon = (char) => colorize("#22c55e", char);
+
+cliCursor.hide();
+
+function render() {
+  // Update dimensions in case of resize
+  const newWidth = process.stdout.columns || 80;
+  const newHeight = process.stdout.rows || 24;
+
+  if (width !== newWidth || height !== newHeight) {
+    width = newWidth;
+    height = newHeight;
+    fire.resize(width, height);
+  }
+
+  // Clear buffer (2D array of spaces)
+  const buffer = [];
+  for (let y = 0; y < height; y++) {
+    buffer.push(new Array(width).fill(" "));
+  }
+
+  // Update logic
+  fire.update();
+
+  // Keep horizontally centered
+  dragonX = (width - dragonWidth) / 2;
+
+  // Move up until centered vertically
+  const targetY = (height - dragonHeight) / 2;
+  if (dragonY > targetY) {
+    dragonY -= dy;
+    if (dragonY < targetY) dragonY = targetY;
+  }
+
+  // Draw fire
+  fire.draw(buffer);
+
+  // Draw dragon over rain
+  const drX = Math.floor(dragonX);
+  const drY = Math.floor(dragonY);
+
+  for (let r = 0; r < dragonHeight; r++) {
+    const screenY = drY + r;
+    if (screenY >= 0 && screenY < height) {
+      const line = dragonLines[r];
+      for (let c = 0; c < line.length; c++) {
+        const char = line[c];
+        // Treat both space and Braille blank pattern as transparent
+        if (char !== " " && char !== "⠀") {
+          const screenX = drX + c;
+          if (screenX >= 0 && screenX < width) {
+            buffer[screenY][screenX] = colorDragon(char);
+          }
+        }
+      }
+    }
+  }
+
+  // Create frame string
+  let frame = "";
+  for (let y = 0; y < height; y++) {
+    frame += buffer[y].join("") + (y === height - 1 ? "" : "\n");
+  }
+
+  // Render to screen by clearing and writing frame
+  // \x1b[H moves cursor to 0,0. It's faster and less flickery than clearing screen entirely.
+  process.stdout.write("\x1b[H" + frame);
+}
+
+// Clear screen once before loop
+process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+
+setInterval(render, 53); // ~30 FPS

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "mintikaryu",
+  "version": "1.0.0",
+  "description": "A sacred CLI tool to summon the ancient fire dragon Mintikaryū (みんてぃかりゅう)",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cli",
+    "terminal",
+    "ascii-art",
+    "animation",
+    "dragon",
+    "fire",
+    "ansi",
+    "true-color",
+    "japanese-dragon",
+    "fire-simulation",
+    "terminal-art",
+    "mythology"
+  ],
+  "author": "Aayush Anand",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aayushananda/Dragon_god.git"
+  },
+  "dependencies": {
+    "cli-cursor": "^5.0.0"
+  },
+  "type": "module",
+  "bin": {
+    "summon-dragon": "index.js"
+  }
+}