A!leys Galerie

#!/usr/bin/env node
import fs from 'fs';
import readline from 'readline';
import { URL } from 'url';
import { promisify } from 'util';

const readFile = promisify(fs.readFile);
const writeFile = promisify(fs.writeFile);
const readlineInterface = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

const STORAGE_FILE = 'neoshorter.db.json';
const HIGHLIGHTS_FILE = 'neohighlights.txt';
const BASE_URL = 'https://neoshorter.dev/';
const LETTERS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
const SHORT_LENGTH = 8;

let shortcuts = {
  'n, /': 'new short url',
  'l, ?': 'list all short urls',
  'g, !': 'get original url',
  'd, -': 'delete short url',
  'h, H': 'toggle help',
  'x, X': 'exit'
};

async function loadData() {
  try {
    const data = await readFile(STORAGE_FILE, 'utf8');
    return data ? JSON.parse(data) : { urls: {}, stats: { total: 0 } };
  } catch (err) {
    return { urls: {}, stats: { total: 0 } };
  }
}

async function saveData(data) {
  await writeFile(STORAGE_FILE, JSON.stringify(data, null, 2));
}

async function loadHighlights() {
  try {
    const data = await readFile(HIGHLIGHTS_FILE, 'utf8');
    return data.split('\n').filter(line => line.trim());
  } catch (err) {
    return [];
  }
}

async function saveHighlights(highlights) {
  await writeFile(HIGHLIGHTS_FILE, highlights.join('\n'));
}

function generateShortCode() {
  return Array.from({ length: SHORT_LENGTH }, () => LETTERS[Math.floor(Math.random() * LETTERS.length)]).join('');
}

function isValidUrl(url) {
  try {
    new URL(url);
    return true;
  } catch (err) {
    return false;
  }
}

async function newShortUrl() {
  const question = 'Enter URL to shorten (or press Enter to cancel): ';
  const input = await ask(question);

  if (!input) {
    console.log('❌ Cancelled');
    return;
  }

  if (!isValidUrl(input)) {
    console.log('❌ Invalid URL. Please provide a valid URL (e.g., https://example.com)');
    return;
  }

  const existingCode = generateShortCode();
  const data = await loadData();

  if (data.urls[existingCode]) {
    return newShortUrl(); // Retry if collision
  }

  data.urls[existingCode] = input;
  data.stats.total++;

  await saveData(data);
  console.log(`✅ Shortened! Your code: ${existingCode}`);
  console.log(`🔗 Full short URL: ${BASE_URL}${existingCode}`);

  const highlights = await loadHighlights();
  if (highlights.length < 5) {
    const highlight = `Neo-Highlight! ${BASE_URL}${existingCode} -> ${input}`;
    highlights.push(highlight);
    await saveHighlights(highlights);
  }
}

async function listShortUrls() {
  const data = await loadData();
  if (Object.keys(data.urls).length === 0) {
    console.log('📄 No short URLs stored yet.');
    return;
  }

  console.log('\n📋 Your Short URLs:');
  console.log('--------------------');
  Object.entries(data.urls).forEach(([code, url]) => {
    console.log(`  [${code}] ${BASE_URL}${code}`);
    console.log(`    -> ${url}`);
  });
  console.log('--------------------');
}

async function getOriginalUrl() {
  const question = 'Enter short code (or press Enter to cancel): ';
  const input = await ask(question);

  if (!input) {
    console.log('❌ Cancelled');
    return;
  }

  const data = await loadData();
  if (!data.urls[input]) {
    console.log('❌ Short code not found.');
    return;
  }

  console.log(`🔗 Original URL: ${data.urls[input]}`);
  console.log(`📄 Code: ${input}`);
}

async function deleteShortUrl() {
  const question = 'Enter short code to delete (or press Enter to cancel): ';
  const input = await ask(question);

  if (!input) {
    console.log('❌ Cancelled');
    return;
  }

  const data = await loadData();
  if (!data.urls[input]) {
    console.log('❌ Short code not found.');
    return;
  }

  delete data.urls[input];
  data.stats.total--;
  await saveData(data);

  console.log(`❌ Deleted short code: ${input}`);
}

function toggleHelp() {
  console.log('\n🎮 Keyboard Shortcuts:');
  console.log('--------------------');
  Object.entries(shortcuts).forEach(([keys, desc]) => {
    console.log(`  ${keys.padEnd(4)} : ${desc}`);
  });
  console.log('--------------------');
  console.log('\n💡 Tip: Use "n" or "/" to create a new short URL!');
}

async function checkNeoHighlight() {
  const highlights = await loadHighlights();
  if (highlights.length > 0) {
    console.log('\n🌟 Neo-Highlights (Most recent):');
    for (const highlight of highlights.slice(0, 3)) {
      console.log(`  • ${highlight}`);
    }
    console.log();
  }
}

async function ask(question) {
  return new Promise((resolve) => {
    readlineInterface.question(question, resolve);
  });
}

async function main() {
  console.log('🌟 Welcome to NeoShorter! 🌟');
  console.log('Modern URL shortener with file-based storage and Neo-Highlights.\n');

  await checkNeoHighlight();

  const commands = {
    'n, /': newShortUrl,
    'l, ?': listShortUrls,
    'g, !': getOriginalUrl,
    'd, -': deleteShortUrl,
    'h, H': toggleHelp,
    'x, X': () => { readlineInterface.close(); process.exit(0); }
  };

  while (true) {
    const input = await ask('\n🌐 What would you like to do? (' + Object.keys(shortcuts).map(k => k.split(', ').join('/')).join(', ') + '): ');

    if (input.toLowerCase() === 'exit') {
      readlineInterface.close();
      process.exit(0);
    }

    for (const [keys, cmd] of Object.entries(commands)) {
      const triggerKeys = keys.split(', ');
      if (input === triggerKeys[0] || input === triggerKeys[1]) {
        await cmd();
        break;
      }
    }
  }
}

main().catch(err => console.error('Error:', err));

// Dynamic RPG Maker MZ NPC AI - Node.js simulation
// Simulates RPG Maker MZ NPC behaviors with environmental awareness

class DynamicNPC {
  constructor() {
    this.states = {
      idle: true,
      moving: false,
      emotional: 'neutral',
      environment: 'default'
    };
    this.movement = {
      direction: 'down',
      speed: 0.5
    };
    this.behaviors = [
      { type: 'patrol', points: ['A', 'B', 'C'], interval: 3000 },
      { type: 'chat', phrases: ['Hello there!', 'Nice day today!'], interval: 5000 },
      { type: 'react', triggers: ['player_approach', 'darkness'], reactions: ['greet', 'fear'] }
    ];
    this.loadAnimation = this.createLoadAnimation();
  }

  createLoadAnimation() {
    return setInterval(() => {
      process.stdout.write('\rLoading NPC AI... ');
      for (let i = 0; i < 10; i++) {
        process.stdout.write('.');
        // Simulate RPG Maker MZ loading screen effect
        setTimeout(() => {}, 100);
      }
      process.stdout.write('\n');
    }, 1000);
  }

  simulate() {
    console.log('NPC AI simulation started');
    this.loadAnimation();

    setInterval(() => {
      this.updateBehavior();
      this.logState();
    }, 1000);
  }

  updateBehavior() {
    // Environmental reaction simulation
    if (Math.random() > 0.7) {
      this.states.environment = Math.random() > 0.5 ? 'rainy' : 'sunny';
    }

    // Behavior selection
    const behavior = this.behaviors[Math.floor(Math.random() * this.behaviors.length)];

    switch (behavior.type) {
      case 'patrol':
        this.states.moving = true;
        this.movement.direction = ['up', 'down', 'left', 'right'][Math.floor(Math.random() * 4)];
        break;
      case 'chat':
        this.states.emotional = 'happy';
        console.log(`NPC: ${behavior.phrases[Math.floor(Math.random() * behavior.phrases.length)]}`);
        break;
      case 'react':
        this.states.emotional = behavior.reactions[Math.floor(Math.random() * behavior.reactions.length)];
        break;
      default:
        this.states.idle = true;
    }
  }

  logState() {
    console.log(`\nCurrent State:
    - Environment: ${this.states.environment}
    - Emotion: ${this.states.emotional}
    - Movement: ${this.states.moving ? this.movement.direction + ' (' + this.movement.speed + ')' : 'idle'}
    - Behavior: ${this.behaviors.find(b => this.states.emotional === b.reactions[0]?.toLowerCase())?.type || 'idle'}`);
  }
}

// Main execution
const npcAI = new DynamicNPC();
npcAI.simulate();

// RPG Maker MZ plugin adaptation notes:
// This simulates what would be plugin functions like:
// PluginManager.registerBehavior('DynamicNPC', ...)
// Game_Interpreter.prototype.pluginBehavior = function() {...}