@ak--47/dungeon-master 1.0.0 → 1.1.0

package/scripts/json-to-dungeon.mjs

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+
+/**
+ * Converts a frontend JSON dungeon file to a proper JavaScript dungeon file
+ * Usage: node scripts/json-to-dungeon.js <input.json> [output-name]
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Get command line arguments
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+    console.error('❌ Error: Please provide an input JSON file');
+    console.log('Usage: node scripts/json-to-dungeon.js <input.json> [output-name]');
+    console.log('Example: node scripts/json-to-dungeon.js /path/to/dungeon.json my-dungeon');
+    process.exit(1);
+}
+
+const inputPath = path.resolve(args[0]);
+const outputName = args[1] || path.basename(inputPath, '.json');
+
+try {
+    // Read the JSON file
+    console.log(`📖 Reading ${inputPath}...`);
+    const jsonContent = readFileSync(inputPath, 'utf-8');
+    const dungeonData = JSON.parse(jsonContent);
+
+    // Extract schema and hooks
+    const schema = dungeonData.schema || dungeonData;
+    const hooksString = dungeonData.hooks || null;
+
+    // Convert to JavaScript
+    console.log('🔄 Converting to JavaScript module...');
+    const jsContent = convertToJavaScript(schema, hooksString, outputName);
+
+    // Write to same directory as input file
+    const outputPath = path.join(path.dirname(inputPath), `${outputName}.js`);
+    writeFileSync(outputPath, jsContent, 'utf-8');
+
+    console.log(`✅ Successfully created ${outputPath}`);
+    console.log(`\n💡 You can now import and use this dungeon:`);
+    console.log(`   import config from '${path.relative(process.cwd(), outputPath)}';`);
+
+} catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+}
+
+/**
+ * Convert JSON schema to JavaScript module string
+ */
+function convertToJavaScript(schema, hooksString, name) {
+    const lines = [];
+
+    // File header
+    lines.push(`/**`);
+    lines.push(` * Generated dungeon: ${name}`);
+    lines.push(` * Created: ${new Date().toISOString()}`);
+    lines.push(` * Source: Converted from frontend JSON`);
+    lines.push(` */`);
+    lines.push('');
+
+    // Imports
+    lines.push(`import Chance from 'chance';`);
+    lines.push(`let chance = new Chance();`);
+    lines.push(`import dayjs from "dayjs";`);
+    lines.push(`import utc from "dayjs/plugin/utc.js";`);
+    lines.push(`dayjs.extend(utc);`);
+    lines.push(`import { uid, comma } from 'ak-tools';`);
+    lines.push(`import {
+	pickAWinner, weighNumRange, date, integer, weighChoices,
+	choose, range, exhaust, maybe, takeSome, randomElement, randomInt,
+	weighArray
+} from "../lib/utils/utils.js";`);
+    lines.push(`import { createTextGenerator, generateBatch } from "../lib/generators/text.js";`);
+    lines.push('');
+
+    // Config object
+    lines.push(`/** @type {import('../types').Dungeon} */`);
+    lines.push(`const config = ${convertValueToJS(schema, 1)};`);
+    lines.push('');
+
+    // Hook function (if exists)
+    if (hooksString) {
+        lines.push(`// Apply the hook function`);
+        lines.push(`config.hook = ${hooksString};`);
+        lines.push('');
+    }
+
+    // Export
+    lines.push(`export default config;`);
+    lines.push('');
+
+    return lines.join('\n');
+}
+
+/**
+ * Convert a JavaScript value to its source code representation
+ */
+function convertValueToJS(value, indentLevel = 0) {
+    const indent = '\t'.repeat(indentLevel);
+    const nextIndent = '\t'.repeat(indentLevel + 1);
+
+    // Null
+    if (value === null || value === undefined) {
+        return 'null';
+    }
+
+    // Boolean
+    if (typeof value === 'boolean') {
+        return String(value);
+    }
+
+    // Number
+    if (typeof value === 'number') {
+        return String(value);
+    }
+
+    // String
+    if (typeof value === 'string') {
+        // Handle multi-line strings
+        if (value.includes('\n')) {
+            return '`' + value.replace(/`/g, '\\`') + '`';
+        }
+        // Use double quotes for regular strings
+        return '"' + value.replace(/"/g, '\\"') + '"';
+    }
+
+    // Function (stored as object with functionName and args)
+    if (value && typeof value === 'object' && value.functionName) {
+        const funcName = value.functionName;
+        const args = value.args || [];
+        const argsStr = args.map(arg => convertValueToJS(arg, 0)).join(', ');
+
+        // Handle arrow functions
+        if (funcName === 'arrow') {
+            return value.body || '() => {}';
+        }
+
+        // Handle chance bindings
+        if (funcName.startsWith('chance.')) {
+            return `${funcName}.bind(chance)`;
+        }
+
+        // Regular function calls
+        return `${funcName}(${argsStr})`;
+    }
+
+    // Array
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return '[]';
+        }
+
+        // Check if it's a simple array (all primitives)
+        const allPrimitives = value.every(v =>
+            v === null ||
+            typeof v === 'boolean' ||
+            typeof v === 'number' ||
+            typeof v === 'string'
+        );
+
+        if (allPrimitives && value.length <= 5) {
+            // Inline simple arrays
+            const items = value.map(v => convertValueToJS(v, 0));
+            return `[${items.join(', ')}]`;
+        }
+
+        // Multi-line arrays
+        const items = value.map(v => `${nextIndent}${convertValueToJS(v, indentLevel + 1)}`);
+        return `[\n${items.join(',\n')}\n${indent}]`;
+    }
+
+    // Object
+    if (typeof value === 'object') {
+        const keys = Object.keys(value);
+
+        if (keys.length === 0) {
+            return '{}';
+        }
+
+        const entries = keys.map(key => {
+            const val = convertValueToJS(value[key], indentLevel + 1);
+            // Use quotes for keys with special characters or spaces
+            const needsQuotes = /[^a-zA-Z0-9_$]/.test(key) || /^\d/.test(key);
+            const keyStr = needsQuotes ? `"${key}"` : key;
+            return `${nextIndent}${keyStr}: ${val}`;
+        });
+
+        return `{\n${entries.join(',\n')}\n${indent}}`;
+    }
+
+    // Fallback
+    return 'null';
+}

package/scripts/run-dungeon.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import generate from '../index.js';
+const { NODE_ENV = "unknown" } = process.env;
+
+// Get the dungeon file path from command line arguments
+const dungeonPath = process.argv[2];
+
+if (!dungeonPath) {
+	console.error('❌ Error: No dungeon file specified');
+	console.error('Usage: node run-dungeon.js <path-to-dungeon.js>');
+	process.exit(1);
+}
+
+// Resolve the absolute path
+const absolutePath = path.isAbsolute(dungeonPath)
+	? dungeonPath
+	: path.resolve(process.cwd(), dungeonPath);
+
+// Handle Ctrl+C gracefully — let user-loop finish current user, then exit
+process.on('SIGINT', () => {
+	// Second Ctrl+C forces immediate exit
+	process.on('SIGINT', () => process.exit(1));
+});
+
+console.log(`\n🎲 Running dungeon: ${path.basename(absolutePath)}\n`);
+
+try {
+	// Dynamically import the dungeon configuration
+	const { default: config } = await import(absolutePath);
+
+	if (!config) {
+		console.error('❌ Error: Dungeon file must export a default configuration object');
+		process.exit(1);
+	}
+
+	// Run the dungeon (always verbose when run locally)
+	config.verbose = true;
+	const results = await generate(config);
+
+	// Display results
+	console.log('\n✅ Dungeon run complete!');
+	console.log('═'.repeat(50));
+	console.log(`📊 Results:`);
+	console.log(`   Users: ${results.userCount.toLocaleString()}`);
+	console.log(`   Events: ${results.eventCount.toLocaleString()}`);
+	if (results.groupCount) {
+		console.log(`   Groups: ${results.groupCount.toLocaleString()}`);
+	}
+	if (results.time) {
+		console.log(`   Duration: ${results.time.human || results.time.delta + 'ms'}`);
+	}
+
+	if (results.avgEPS) {
+		console.log(`   Avg EPS: ${results.avgEPS.toLocaleString()}`);
+	}
+
+	if (results.files && results.files.length > 0) {
+		console.log(`\n📁 Files written:`);
+		results.files.forEach(file => {
+			console.log(`   - ${file}`);
+		});
+	}
+
+	console.log('═'.repeat(50) + '\n');
+
+	// if (NODE_ENV === 'dev') debugger;
+
+
+
+} catch (error) {
+	console.error('❌ Error running dungeon:', error.message);
+	console.error(error.stack);
+	process.exit(1);
+}

package/scripts/run-many.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import { fork } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import dotenv from "dotenv";
+dotenv.config();
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+import main from "../index.js";
+const CONCURRENCY = 10
+
+/**
+ * Run multiple dungeons concurrently from the command line.
+ *
+ * Usage:
+ *   node scripts/run-many.mjs dungeons/vertical/gaming.js dungeons/vertical/media.js dungeons/vertical/food-delivery.js
+ *   node scripts/run-many.mjs dungeons/vertical/*.js
+ */
+
+const args = process.argv.slice(2);
+
+if (process.env.__SIM_CHILD) {
+	// CHILD: run the assigned dungeon
+	const dungeonPath = process.env.__SIM_PATH;
+	(async () => {
+		try {
+			const mod = await import(path.resolve(dungeonPath));
+			const spec = mod.default;
+			spec.name = path.basename(dungeonPath, '.js');
+			spec.verbose = false;
+			const result = await main(spec);
+			const summary = { eventCount: result.eventCount, userCount: result.userCount, time: result.time };
+			if (process.send) process.send({ name: spec.name, success: true, summary }, undefined, undefined, () => process.exit(0));
+			else process.exit(0);
+		} catch (err) {
+			console.error(`[${dungeonPath}] Error:`, err.message);
+			if (process.send) process.send({ name: dungeonPath, success: false, error: err.message });
+			process.exit(1);
+		}
+	})();
+} else {
+	// PARENT: fork children with concurrency limit
+	if (args.length === 0) {
+		console.error("Usage: node scripts/run-many.mjs <dungeon1.js> <dungeon2.js> ...");
+		process.exit(1);
+	}
+
+	const limit = CONCURRENCY;
+	let running = 0;
+	const queue = args.map(p => ({ path: p, name: path.basename(p, '.js') }));
+	const results = [];
+	const total = queue.length;
+
+	console.log(`\n${"═".repeat(60)}`);
+	console.log(`🎲 Running ${total} dungeon(s) with concurrency ${limit}`);
+	console.log(`${"═".repeat(60)}\n`);
+
+	function runOne(dungeon) {
+		return new Promise((resolve, reject) => {
+			console.log(`▶ Starting: ${dungeon.name}`);
+			const startTime = Date.now();
+			const child = fork(__filename, [], {
+				env: { ...process.env, __SIM_CHILD: "1", __SIM_PATH: dungeon.path },
+				stdio: ['inherit', 'inherit', 'inherit', 'ipc']
+			});
+			child.on('message', (msg) => {
+				const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+				if (msg.success) {
+					console.log(`✅ Finished: ${dungeon.name} (${elapsed}s)`);
+				} else {
+					console.error(`❌ Failed: ${dungeon.name} - ${msg.error} (${elapsed}s)`);
+				}
+				resolve(msg);
+			});
+			child.on('error', (err) => {
+				console.error(`❌ Fork error: ${dungeon.name}`, err.message);
+				reject(err);
+			});
+			child.on('exit', (code) => {
+				if (code !== 0 && code !== null) {
+					reject(new Error(`${dungeon.name} exited with code ${code}`));
+				}
+			});
+		});
+	}
+
+	function runNext() {
+		while (running < limit && queue.length > 0) {
+			const dungeon = queue.shift();
+			running++;
+			runOne(dungeon)
+				.then(res => results.push(res))
+				.catch(e => results.push({ name: dungeon.name, success: false, error: e.message }))
+				.finally(() => { running--; runNext(); });
+		}
+	}
+	runNext();
+
+	const wait = () => new Promise(resolve => {
+		const check = () => {
+			if (results.length === total) resolve(results);
+			else setTimeout(check, 250);
+		};
+		check();
+	});
+
+	const all = await wait();
+	const succeeded = all.filter(r => r.success).length;
+	const failed = all.filter(r => !r.success).length;
+
+	console.log(`\n${"═".repeat(60)}`);
+	console.log(`🏁 Done: ${succeeded} succeeded, ${failed} failed out of ${total}`);
+	console.log(`${"═".repeat(60)}\n`);
+
+	if (failed > 0) process.exit(1);
+}

package/scripts/verify-runner.mjs

@@ -0,0 +1,42 @@
+/**
+ * Verify Runner — runs a dungeon at constrained params for hook verification.
+ *
+ * Usage: node scripts/verify-runner.mjs <dungeon-path> [run-name]
+ *
+ * Example: node scripts/verify-runner.mjs dungeons/streaming.js verify-streaming
+ */
+import generate from '../index.js';
+import path from 'path';
+
+const dungeonPath = process.argv[2];
+if (!dungeonPath) {
+	console.error('Usage: node scripts/verify-runner.mjs <dungeon-path> [run-name]');
+	process.exit(1);
+}
+
+const runName = process.argv[3] || 'verify-hooks';
+const absolutePath = path.isAbsolute(dungeonPath)
+  ? dungeonPath
+  : path.resolve(process.cwd(), dungeonPath);
+
+const { default: config } = await import(absolutePath);
+
+const results = await generate({
+  ...config,
+  token: "",
+  numUsers: 1000,
+  numEvents: 100_000,
+  format: "json",
+  gzip: false,
+  writeToDisk: true,
+  name: runName,
+  concurrency: 1,
+  verbose: false,
+});
+
+console.log(JSON.stringify({
+  eventCount: results.eventCount,
+  userCount: results.userCount,
+  files: results.files,
+  duration: results.time?.human || results.time?.delta + 'ms'
+}));