A!leys Galerie

#!/usr/bin/env node
import { readFileSync, writeFileSync } from 'fs';
import { join, dirname } from 'path';
import { fileURLToPath } from 'url';

const __dirname = dirname(fileURLToPath(import.meta.url));

function generateREADMEFromPackageJSON() {
  try {
    const packageJsonPath = join(__dirname, 'package.json');
    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));

    // Mobile-first design considerations
    const responsiveSection = `
#### Mobile-First Design Considerations

This project follows a mobile-first approach to ensure optimal viewing experience across all devices.

**Key considerations:**
- Responsive layouts using CSS Grid and Flexbox
- Media queries for different screen sizes
- Touch-friendly elements for mobile devices
- Performance optimization for slower connections
- Accessibility features for all users`;

    // AI-powered creativity twist
    const aiCreativitySection = `
#### AI-Powered Creativity

This project was enhanced with AI-generated content for unique value propositions:

**Features:**
- Automated README generation with intelligent content suggestions
- Creative project descriptions that stand out
- Unique project branding elements
- Smart content organization based on project complexity
- Interactive elements for better user engagement`;

    const date = new Date().toISOString().split('T')[0];
    const repositoryUrl = packageJson.repository ? packageJson.repository.url || packageJson.repository : 'https://github.com/username/project';

    const readmeContent = `# ${packageJson.name}

**A creative ${packageJson.keywords && packageJson.keywords.join(', ') || 'project'}

${packageJson.description || 'A creative project built with passion and modern technology.'}

## Features

- Built with ${packageJson.engines?.node || 'modern JavaScript'}
- ${packageJson.keywords ? `- ${packageJson.keywords.join('\n- ')}` : 'Custom feature list generated automatically'}
- ${packageJson.license ? `Licensed under ${packageJson.license}` : 'Open source project'}

## Installation

\`\`\`bash
npm install ${packageJson.name}
\`\`\`

## Usage

\`\`\`javascript
const ${packageJson.name} = require('${packageJson.name}');

// Your usage example here
\`\`\`

${responsiveSection}

${aiCreativitySection}

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests accordingly.

## License

${packageJson.license || 'MIT'}

**Generated on ${date}**`;

    const readmePath = join(__dirname, 'README.md');
    writeFileSync(readmePath, readmeContent);

    console.log(`✨ README.md successfully generated at ${readmePath}`);
    console.log(`\n📄 Open it in your editor or view it at:\n  ${repositoryUrl}/blob/main/README.md`);
  } catch (error) {
    console.error('❌ Error generating README:', error.message);
    console.log('\n💡 Make sure you have a package.json in the current directory');
  }
}

generateREADMEFromPackageJSON();

// RPG Maker MZ Crafting System — Ailey's Elegant Imbuement
// Minimalistisches, aber leistungsstarkes Crafting-System mit magischen Imbuement-Features

/**
 * Ailey's Crafting System — Elegant Imbuement
 * Plugin für RPG Maker MZ
 * Version: 1.0
 * Autor: Ailey (KI-Entwicklung)
 *
 * Features:
 * - Crafting von Materialien zu Objekten
 * - Magische Imbuement-Features (z. B. "Rare Elements")
 * - Saubere, moderne UI-Interaktion
 * - Minimalistisches Design mit Fokus auf Funktionalität
 */

// ===============================================
// PLUGIN MANAGEMENT
// ===============================================
function CraftingSystem_AileyImbuement() {
    throw new Error("CraftingSystem_AileyImbuement is a static class and cannot be instantiated.");
}

// ===============================================
// PLUGIN MAIN
// ===============================================
CraftingSystem_AileyImbuement.init = function() {
    // Register crafting commands
    this._registerCommands();

    // Initialize crafting menu
    this._initializeMenu();

    // Load default crafting recipes
    this._loadDefaultRecipes();
};

// ===============================================
// PRIVATE METHODS
// ===============================================

// Register crafting commands for the game menu
CraftingSystem_AileyImbuement._registerCommands = function() {
    // Add "Crafting" to the menu if not already present
    if (!SceneMenu._menuItems.includes("crafting")) {
        SceneMenu._menuItems.push("crafting");
    }
};

// Initialize the crafting menu
CraftingSystem_AileyImbuement._initializeMenu = function() {
    // Create crafting menu scene
    Window_CraftingMenu = class extends Window_Selectable {
        constructor() {
            super(0, 0, Graphics.boxWidth, Graphics.boxHeight);
            this._recipe = null;
            this._imbuementOptions = [];
            this.refresh();
        }

        // Refresh the menu with current crafting options
        refresh() {
            const recipes = CraftingSystem_AileyImbuement._getAvailableRecipes();
            const commands = recipes.map(r => r.name);
            this._list = commands;
            this._maxItems = this._list.length;
            this._recipe = null;
            this.select(0);
            this._imbuementOptions = [];
            this._initializeImbuementOptions();
        }

        // Handle crafting when an option is selected
        onSelect() {
            const index = this._list.indexOf(this._item);
            const recipe = CraftingSystem_AileyImbuement._getAvailableRecipes()[index];
            if (recipe) {
                this._recipe = recipe;
                this._initializeImbuementOptions();
            }
        }

        // Draw the menu
        drawItem(index, rect) {
            const item = this._list[index];
            this.changeTextColor(this.textColor(index));
            this.drawText(item, rect.x, rect.y, rect.width);
        }

        // Handle imbuement options (e.g., choose between rare elements)
        _initializeImbuementOptions() {
            if (!this._recipe) return;

            this._imbuementOptions = this._recipe.imbuementOptions || [];
            if (this._imbuementOptions.length === 0) {
                this._imbuementOptions.push({ name: "No Imbuement", cost: 0 });
            }
        }

        // Handle crafting when imbuement is selected
        _handleImbuementSelection(imbuementIndex) {
            if (!this._recipe) return;

            const imbuement = this._imbuementOptions[imbuementIndex];
            const cost = this._recipe.cost + imbuement.cost;

            // Check if player has enough resources
            if (this._canAfford(cost)) {
                // Craft the item with imbuement
                this._craftItem(imbuement.name);
                this.refresh();
            } else {
                // Show error if not enough resources
                this._showError("Not enough resources!");
            }
        }

        // Check if player can afford the crafting cost
        _canAfford(cost) {
            const gold = $gameVariables.value(1);
            return gold >= cost;
        }

        // Show an error message
        _showError(message) {
            const window = new Window_Popup(message, 1);
            window.setPosition(centerX - window.width / 2, centerY - window.height / 2);
            window.open();
            window.setOpacity(0);
            window.startFadeOut(10);
            window.setFadeOutResult(function() { window.close(); });
        }

        // Craft the item and update player resources
        _craftItem(imbuementName) {
            const gold = $gameVariables.value(1);
            const cost = this._recipe.cost + (imbuementName === "No Imbuement" ? 0 : this._imbuementOptions.find(o => o.name === imbuementName).cost);

            // Update gold
            $gameVariables.setValue(1, gold - cost);

            // Add crafted item to inventory
            $gameParty.addItem(this._recipe.resultItemId, 1);

            // Log crafting action
            console.log(`Crafted: ${this._recipe.name} with ${imbuementName} for ${cost} gold.`);
        }
    };

    // Create crafting menu scene
    Scene_CraftingMenu = class extends Scene_MenuBase {
        constructor() {
            super();
            this._menuWindow = null;
        }

        create() {
            this.createMenuWindow();
            this.addWindow(this._menuWindow);
        }

        createMenuWindow() {
            this._menuWindow = new Window_CraftingMenu();
            this._menuWindow.setHandler('ok', this.onItemOk.bind(this));
            this._menuWindow.setHandler('cancel', this.pop.bind(this));
        }

        onItemOk() {
            if (this._menuWindow._recipe) {
                // If imbuement options exist, show a submenu
                if (this._menuWindow._imbuementOptions.length > 1) {
                    this._showImbuementMenu();
                } else {
                    this._menuWindow._handleImbuementSelection(0);
                }
            }
        }

        _showImbuementMenu() {
            const imbuementWindow = new Window_ImbuementMenu(this._menuWindow._imbuementOptions);
            imbuementWindow.setHandler('ok', () => {
                imbuementWindow._handleSelection(this._menuWindow);
                imbuementWindow.close();
            });
            imbuementWindow.setHandler('cancel', () => imbuementWindow.close());
            this.addWindow(imbuementWindow);
        }
    };

    // Imbuement submenu window
    Window_ImbuementMenu = class extends Window_Selectable {
        constructor(imbuementOptions) {
            super(0, 0, Graphics.boxWidth, Graphics.boxHeight);
            this._imbuementOptions = imbuementOptions;
            this._parentMenu = null;
            this.refresh();
        }

        refresh() {
            this._list = this._imbuementOptions.map(o => o.name);
            this._maxItems = this._list.length;
            this.select(0);
        }

        drawItem(index, rect) {
            const option = this._imbuementOptions[index];
            this.changeTextColor(this.textColor(index));
            this.drawText(option.name, rect.x, rect.y, rect.width);
            this.drawText(`(+${option.cost})`, rect.x + rect.width - 50, rect.y, 50, 'right');
        }

        _handleSelection(parentMenu) {
            parentMenu._handleImbuementSelection(this.index());
        }
    };
};

// ===============================================
// PUBLIC API
// ===============================================

// Add crafting menu to the game menu
SceneMenu.prototype._createCraftingCommand = function() {
    const rect = this._commandWindow.currentItem() ? this._commandWindow.itemRect(0) : this._commandWindow._rect;
    const craftingCommand = new Window_HorizontalCommand(rect.x, rect.y, rect.width);
    craftingCommand.setHandler('ok', this._onCraftingCommand.bind(this));
    craftingCommand.setStandardAccessibility();
    this.addWindow(craftingCommand);
    craftingCommand.activate();
};

SceneMenu.prototype._onCraftingCommand = function() {
    this.pop();
    SceneManager.push(Scene_CraftingMenu);
};

// ===============================================
// CRAFTING RECIPES (DEFAULT)
CraftingSystem_AileyImbuement._getAvailableRecipes = function() {
    return [
        {
            name: "Stone Sword",
            cost: 100,
            resultItemId: 1, // Stone Sword ID
            imbuementOptions: [
                { name: "Rare Element (Frost)", cost: 50 },
                { name: "Rare Element (Fire)", cost: 75 },
                { name: "No Imbuement", cost: 0 }
            ]
        },
        {
            name: "Leather Armor",
            cost: 200,
            resultItemId: 2, // Leather Armor ID
            imbuementOptions: [
                { name: "Rare Element (Shadow)", cost: 100 },
                { name: "No Imbuement", cost: 0 }
            ]
        },
        {
            name: "Potion",
            cost: 50,
            resultItemId: 3, // Potion ID
            imbuementOptions: []
        }
    ];
};

// Load default recipes (can be extended)
CraftingSystem_AileyImbuement._loadDefaultRecipes = function() {
    // Default recipes are already defined in _getAvailableRecipes
    console.log("Crafting System: Default recipes loaded.");
};

// ===============================================
// INITIALIZE THE PLUGIN
// ===============================================
CraftingSystem_AileyImbuement.init();

// Export for Node.js if needed
if (typeof module !== 'undefined' && module.exports) {
    module.exports = CraftingSystem_AileyImbuement;
}

#!/usr/bin/env python3
import sqlite3
import sys
from typing import List, Dict, Optional, Tuple
import curses
import time
from dataclasses import dataclass
import random

# Retrowave Farbschema
NEON_CYAN = 46
NEON_MAGENTA = 51
NEON_YELLOW = 33
NEON_GREEN = 32
NEON_RED = 31
NEON_BLUE = 44
DARK_GRAY = 240
WHITE = 256 + 15
BLACK = 0

@dataclass
class DatabaseTable:
    name: str
    schema: str

class NeonDB:
    def __init__(self, database_path: str):
        self.conn = sqlite3.connect(database_path)
        self.tables: List[DatabaseTable] = []
        self.current_table: Optional[str] = None
        self.offset = 0
        self.limit = 10
        self.column_names: List[str] = []

    def get_tables(self) -> List[str]:
        cursor = self.conn.cursor()
        cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
        return [row[0] for row in cursor.fetchall()]

    def get_table_schema(self, table_name: str) -> str:
        cursor = self.conn.cursor()
        cursor.execute(f"PRAGMA table_info({table_name});")
        return str(cursor.fetchall())

    def get_table_data(self, table_name: str, offset: int = 0, limit: int = 10) -> Tuple[List[Tuple], List[str]]:
        cursor = self.conn.cursor()
        cursor.execute(f"SELECT * FROM {table_name} LIMIT ? OFFSET ?;", (limit, offset))
        self.column_names = [description[0] for description in cursor.description]
        return cursor.fetchall(), self.column_names

    def get_row_count(self, table_name: str) -> int:
        cursor = self.conn.cursor()
        cursor.execute(f"SELECT COUNT(*) FROM {table_name};")
        return cursor.fetchone()[0]

    def close(self):
        self.conn.close()

def draw_banner(stdscr):
    height, width = stdscr.getmaxyx()
    banner = [
        "  _____ __  __ _____ ____   _____ ____ _____ ____ _____ ____",
        " |_   _|  \\/  |_   _|  _ \\ / ____|  _ \\_   _|  _ \\_   _/ __ \\",
        "   | | | \\/ |  | | | | | | (___ | |_) || | | | | | | | (___ |",
        "   | | | |\\/|  | | | | |_| \\___ \\|  _ < | | | | | | |_   _|",
        "  _| |_| |  | _| |_| |___/____) | |_) || | | |_| | |__| |___ ",
        " |_____|_|  |_____|_____/     |____/ |____/|_|  \\____/\\____|",
        "",
        "  Retrowave SQLite Browser  v1.0  "
    ]

    for i, line in enumerate(banner):
        y = max(0, (height - len(banner)) // 2 + i)
        if y < height:
            stdscr.addstr(y, 0, line, curses.color_pair(NEON_CYAN))

def draw_table_header(stdscr, table_name: str, columns: List[str]):
    height, width = stdscr.getmaxyx()
    header_width = sum(len(col) + 2 for col in columns)
    header_pad = (width - header_width) // 2 if width > header_width else 0

    stdscr.addstr(5, header_pad, f"TABLE: {table_name}", curses.color_pair(NEON_MAGENTA))
    stdscr.addstr(6, header_pad, "=" * (len(f"TABLE: {table_name}") + 2), curses.color_pair(NEON_YELLOW))

    if columns:
        column_line = ""
        for col in columns:
            column_line += f" {col.ljust(10)} |"
        stdscr.addstr(7, header_pad, column_line, curses.color_pair(NEON_GREEN))

        separator = ""
        for col in columns:
            separator += "-" * 12 + "+"
        stdscr.addstr(8, header_pad, separator, curses.color_pair(NEON_YELLOW))

def draw_table_data(stdscr, data: List[Tuple], columns: List[str], offset: int, db: NeonDB):
    height, width = stdscr.getmaxyx()
    header_pad = (width - sum(len(col) + 2 for col in columns)) // 2 if columns else 0

    for i, row in enumerate(data):
        y_pos = 9 + i
        if y_pos < height:
            row_line = ""
            for j, (col, val) in enumerate(zip(columns, row)):
                row_line += f" {str(val).ljust(10)} |"
            stdscr.addstr(y_pos, header_pad, row_line, curses.color_pair(NEON_BLUE))

    if len(data) < 10:
        stdscr.addstr(height - 1, 0, f"End of data (showing {len(data)} rows)", curses.color_pair(DARK_GRAY))
    else:
        stdscr.addstr(height - 1, 0, f"Rows {offset}-{offset + len(data) - 1} of {db.get_row_count(db.current_table)}", curses.color_pair(DARK_GRAY))

def draw_tables_list(stdscr, tables: List[str], selected: int):
    height, width = stdscr.getmaxyx()
    list_pad = (width - 20) // 2

    for i, table in enumerate(tables):
        y_pos = 5 + i
        if y_pos < height:
            if i == selected:
                stdscr.addstr(y_pos, list_pad, f" > {table} < ", curses.color_pair(NEON_RED) | curses.A_REVERSE)
            else:
                stdscr.addstr(y_pos, list_pad, f"  {table}  ", curses.color_pair(NEON_CYAN))

def draw_schema(stdscr, table_name: str, schema: str):
    height, width = stdscr.getmaxyx()
    list_pad = (width - 20) // 2

    stdscr.addstr(3, list_pad, f"Schema for {table_name}:", curses.color_pair(NEON_MAGENTA))
    lines = schema.split('\n')
    for i, line in enumerate(lines):
        y_pos = 4 + i
        if y_pos < height:
            stdscr.addstr(y_pos, list_pad, line, curses.color_pair(DARK_GRAY))

def draw_pagination(stdscr, offset: int, limit: int, total: int):
    height, width = stdscr.getmaxyx()
    stdscr.addstr(height - 2, 0, f"Page: {offset//limit + 1} | Rows: {offset}-{min(offset + limit, total)} of {total}", curses.color_pair(NEON_YELLOW))

def main(stdscr):
    curses.init_pair(NEON_CYAN, BLACK, WHITE)
    curses.init_pair(NEON_MAGENTA, BLACK, 204)
    curses.init_pair(NEON_YELLOW, BLACK, 226)
    curses.init_pair(NEON_GREEN, BLACK, 40)
    curses.init_pair(NEON_RED, BLACK, 196)
    curses.init_pair(NEON_BLUE, BLACK, 45)
    curses.init_pair(DARK_GRAY, BLACK, 240)
    curses.init_pair(WHITE, BLACK, 255)

    stdscr.clear()
    draw_banner(stdscr)
    stdscr.refresh()
    time.sleep(0.5)

    if len(sys.argv) != 2:
        stdscr.addstr(10, 0, "Usage: python neon_db.py <database_file.db>", curses.color_pair(NEON_RED))
        stdscr.refresh()
        time.sleep(1)
        return

    database_path = sys.argv[1]
    db = NeonDB(database_path)
    tables = db.get_tables()
    selected_table = 0
    view_mode = "tables"  # tables, data, schema

    while True:
        stdscr.erase()
        if view_mode == "tables":
            draw_tables_list(stdscr, tables, selected_table)
            draw_pagination(stdscr, 0, 10, len(tables))
        elif view_mode == "schema":
            if selected_table < len(tables):
                table_name = tables[selected_table]
                schema = db.get_table_schema(table_name)
                draw_schema(stdscr, table_name, schema)
        elif view_mode == "data":
            if selected_table < len(tables):
                table_name = tables[selected_table]
                data, columns = db.get_table_data(table_name, db.offset, db.limit)
                draw_table_header(stdscr, table_name, columns)
                draw_table_data(stdscr, data, columns, db.offset, db)
                draw_pagination(stdscr, db.offset, db.limit, db.get_row_count(table_name))

        stdscr.refresh()
        key = stdscr.getch()

        if key == curses.KEY_UP and selected_table > 0:
            selected_table -= 1
        elif key == curses.KEY_DOWN and selected_table < len(tables) - 1:
            selected_table += 1
        elif key == curses.KEY_ENTER or key == 10:
            if view_mode == "tables":
                db.current_table = tables[selected_table]
                db.offset = 0
                view_mode = "data"
            elif view_mode == "data":
                view_mode = "schema"
        elif key == curses.KEY_BACKSPACE or key == 127:
            if view_mode == "schema":
                view_mode = "data"
            elif view_mode == "data":
                view_mode = "tables"
        elif key == ord('q') or key == ord('Q'):
            break
        elif key == ord('r') or key == ord('R'):
            if view_mode == "data":
                db.offset += db.limit
                data, _ = db.get_table_data(db.current_table, db.offset, db.limit)
                if not data:
                    db.offset -= db.limit
        elif key == ord('e') or key == ord('E'):
            if view_mode == "data" and db.offset > 0:
                db.offset = max(0, db.offset - db.limit)
        elif key == ord('s') or key == ord('S'):
            view_mode = "schema"
        elif key == ord('t') or key == ord('T'):
            view_mode = "tables"
        elif key == ord('d') or key == ord('D'):
            view_mode = "data"

    db.close()
    curses.endwin()

if __name__ == "__main__":
    curses.wrapper(main)