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

package/scripts/dungeon-to-json.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+/**
+ * Converts a JavaScript dungeon file to JSON that can be loaded into the UI
+ * Usage: node scripts/dungeon-to-json.js <input.js> [output-name]
+ */
+
+import { 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 JavaScript file');
+    console.log('Usage: node scripts/dungeon-to-json.js <input.js> [output-name]');
+    console.log('Example: node scripts/dungeon-to-json.js ./dungeons/my-dungeon.js my-dungeon');
+    process.exit(1);
+}
+
+const inputPath = path.resolve(args[0]);
+const outputName = args[1] || path.basename(inputPath, '.js');
+
+try {
+    // Import the JavaScript module
+    console.log(`📖 Loading ${inputPath}...`);
+    const module = await import(`file://${inputPath}`);
+    const config = module.default;
+
+    if (!config) {
+        throw new Error('No default export found in the module');
+    }
+
+    // Extract hooks if they exist
+    const hooksFunction = config.hook;
+    const hooksString = hooksFunction ? hooksFunction.toString() : null;
+
+    // Create a clean config without the hook function
+    const cleanConfig = { ...config };
+    delete cleanConfig.hook;
+
+    // Convert to JSON-serializable format
+    console.log('🔄 Converting to JSON format...');
+    const schema = convertToJSON(cleanConfig);
+
+    // Create the dungeon state object (same format as UI saves)
+    const dungeonState = {
+        schema,
+        hooks: hooksString,
+        timestamp: new Date().toISOString(),
+        version: '4.0'
+    };
+
+    // Write to JSON file
+    const outputPath = path.join(path.dirname(inputPath), `${outputName}.json`);
+    writeFileSync(outputPath, JSON.stringify(dungeonState, null, 2), 'utf-8');
+
+    console.log(`✅ Successfully created ${outputPath}`);
+    console.log(`\n💡 You can now load this file in the dungeon-master UI:`);
+    console.log(`   Click "Load" and select ${outputName}.json`);
+
+} catch (error) {
+    console.error('❌ Error:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+}
+
+/**
+ * Convert JavaScript config to JSON-serializable format
+ * Detects functions and converts them to object representation
+ */
+function convertToJSON(value) {
+    // Null/undefined
+    if (value === null || value === undefined) {
+        return null;
+    }
+
+    // Primitives
+    if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string') {
+        return value;
+    }
+
+    // Functions - convert to object representation
+    if (typeof value === 'function') {
+        return convertFunctionToObject(value);
+    }
+
+    // Arrays
+    if (Array.isArray(value)) {
+        return value.map(item => convertToJSON(item));
+    }
+
+    // Objects
+    if (typeof value === 'object') {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = convertToJSON(val);
+        }
+        return result;
+    }
+
+    // Fallback
+    return null;
+}
+
+/**
+ * Convert a function to its object representation
+ * Tries to detect the function type and extract parameters
+ */
+function convertFunctionToObject(func) {
+    const funcString = func.toString();
+
+    // Arrow function
+    if (funcString.startsWith('(') || funcString.startsWith('_') || funcString.includes('=>')) {
+        return {
+            functionName: 'arrow',
+            body: funcString
+        };
+    }
+
+    // Bound chance methods (e.g., chance.name.bind(chance))
+    if (funcString.includes('.bind(')) {
+        const match = funcString.match(/chance\.(\w+)\.bind/);
+        if (match) {
+            return {
+                functionName: `chance.${match[1]}`,
+                args: []
+            };
+        }
+    }
+
+    // Try to detect common utility functions
+    // This is a best-effort approach - some complex functions might not be detected
+    const commonFunctions = [
+        'weighNumRange',
+        'weighArray',
+        'weighChoices',
+        'pickAWinner',
+        'date',
+        'integer',
+        'uid',
+        'comma'
+    ];
+
+    for (const fnName of commonFunctions) {
+        if (funcString.includes(fnName)) {
+            // Extract args (this is simplified - real parsing would be more complex)
+            return {
+                functionName: fnName,
+                args: [] // Args would need to be extracted, but that's complex
+            };
+        }
+    }
+
+    // Generic function - just store as arrow function
+    return {
+        functionName: 'arrow',
+        body: funcString
+    };
+}

package/scripts/extract-dungeon-schema.mjs

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+
+/**
+ * Extracts a complete schema from a JavaScript dungeon file.
+ *
+ * Output contains everything about the dungeon EXCEPT:
+ *   - hook function (runtime logic, not schema)
+ *   - credentials (token, serviceAccount, serviceSecret, projectId)
+ *   - execution params (seed, format, gzip, verbose, concurrency, batchSize, writeToDisk, region)
+ *
+ * Property values are simplified:
+ *   - Plain arrays → deduplicated
+ *   - weighNumRange(min,max) arrays → { "$range": [min, max] }
+ *   - Functions (pickAWinner, weighChoices, etc.) → sampled and deduplicated
+ *   - High-cardinality / complex values → type hint
+ *
+ * Usage:
+ *   node scripts/extract-dungeon-schema.mjs <input.js> [output.json]
+ *   node scripts/extract-dungeon-schema.mjs dungeons/vertical/*.js   # batch mode
+ */
+
+import { writeFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { initChance } from '../lib/utils/utils.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+	console.error('Usage: node scripts/extract-dungeon-schema.mjs <dungeon.js> [output.json]');
+	console.error('       node scripts/extract-dungeon-schema.mjs dungeons/vertical/*.js');
+	process.exit(1);
+}
+
+// Batch mode: multiple files
+if (args.length > 2 || (args.length > 1 && args[1].endsWith('.js'))) {
+	for (const file of args) {
+		if (!file.endsWith('.js') && !file.endsWith('.mjs')) continue;
+		try {
+			await processOne(file);
+		} catch (e) {
+			console.error(`  ❌ ${path.basename(file)}: ${e.message}`);
+		}
+	}
+} else {
+	await processOne(args[0], args[1]);
+}
+
+async function processOne(inputFile, outputFile) {
+	const inputPath = path.resolve(inputFile);
+	const baseName = path.basename(inputPath, '.js');
+	const outputPath = outputFile
+		? path.resolve(outputFile)
+		: path.join(path.dirname(inputPath), `${baseName}-schema.json`);
+
+	// Seed RNG for deterministic sampling of function-based properties
+	initChance('schema-extraction');
+
+	const mod = await import(`file://${inputPath}`);
+	const config = mod.default;
+	if (!config) throw new Error('No default export');
+
+	const schema = {};
+
+	// ── Events ──────────────────────────────────────────────────────
+	if (config.events?.length) {
+		schema.events = config.events.map(evt => {
+			const entry = { event: evt.event };
+			if (evt.weight && evt.weight !== 1) entry.weight = evt.weight;
+			if (evt.isFirstEvent) entry.isFirstEvent = true;
+			if (evt.isChurnEvent) entry.isChurnEvent = true;
+			if (evt.returnLikelihood !== undefined) entry.returnLikelihood = evt.returnLikelihood;
+			if (evt.isStrictEvent) entry.isStrictEvent = true;
+			if (evt.isSessionStartEvent) entry.isSessionStartEvent = true;
+			if (evt.properties && Object.keys(evt.properties).length) {
+				const props = extractProps(evt.properties);
+				if (Object.keys(props).length) entry.properties = props;
+			}
+			return entry;
+		});
+	}
+
+	// ── Funnels ─────────────────────────────────────────────────────
+	if (config.funnels?.length) {
+		schema.funnels = config.funnels.map(f => {
+			const entry = { sequence: f.sequence };
+			if (f.name) entry.name = f.name;
+			if (f.isFirstFunnel) entry.isFirstFunnel = true;
+			if (f.conversionRate !== undefined) entry.conversionRate = f.conversionRate;
+			if (f.timeToConvert !== undefined) entry.timeToConvert = f.timeToConvert;
+			if (f.order && f.order !== 'sequential') entry.order = f.order;
+			if (f.weight && f.weight !== 1) entry.weight = f.weight;
+			if (f.requireRepeats) entry.requireRepeats = true;
+			if (f.experiment) entry.experiment = true;
+			if (f.bindPropsIndex !== undefined) entry.bindPropsIndex = f.bindPropsIndex;
+			if (f.conditions) entry.conditions = f.conditions;
+			if (f.props && Object.keys(f.props).length) {
+				const fp = extractProps(f.props);
+				if (Object.keys(fp).length) entry.props = fp;
+			}
+			return entry;
+		});
+	}
+
+	// ── Super props ─────────────────────────────────────────────────
+	if (config.superProps && Object.keys(config.superProps).length) {
+		const sp = extractProps(config.superProps);
+		if (Object.keys(sp).length) schema.superProps = sp;
+	}
+
+	// ── User props ──────────────────────────────────────────────────
+	if (config.userProps && Object.keys(config.userProps).length) {
+		const up = extractProps(config.userProps);
+		if (Object.keys(up).length) schema.userProps = up;
+	}
+
+	// ── Group keys ──────────────────────────────────────────────────
+	if (config.groupKeys?.length) {
+		schema.groupKeys = config.groupKeys.map(gk => {
+			if (Array.isArray(gk)) {
+				const entry = { key: gk[0], count: gk[1] };
+				if (gk[2]) entry.affectsEvents = gk[2];
+				return entry;
+			}
+			return gk;
+		});
+	}
+
+	// ── Group props ─────────────────────────────────────────────────
+	if (config.groupProps && Object.keys(config.groupProps).length) {
+		schema.groupProps = {};
+		for (const [groupKey, props] of Object.entries(config.groupProps)) {
+			schema.groupProps[groupKey] = extractProps(props);
+		}
+	}
+
+	// ── SCD props ───────────────────────────────────────────────────
+	if (config.scdProps && Object.keys(config.scdProps).length) {
+		schema.scdProps = {};
+		for (const [key, scd] of Object.entries(config.scdProps)) {
+			const entry = {};
+			entry.type = scd.type || "user";
+			if (scd.frequency) entry.frequency = scd.frequency;
+			if (scd.timing) entry.timing = scd.timing;
+			if (scd.max !== undefined) entry.max = scd.max;
+			if (scd.values) {
+				const simplified = simplifyValue(scd.values);
+				if (simplified) entry.values = simplified;
+			}
+			schema.scdProps[key] = entry;
+		}
+	}
+
+	writeFileSync(outputPath, JSON.stringify(schema, null, 2) + '\n', 'utf-8');
+	console.log(`  ✅ ${baseName}-schema.json`);
+}
+
+// ── Property extraction ──────────────────────────────────────────────
+
+/**
+ * Extracts a simplified property map from a dungeon properties object.
+ * Returns { key: simplifiedValue } for each property.
+ * Keys are always preserved — complex values get a type hint instead of being omitted.
+ */
+function extractProps(propsObj) {
+	const result = {};
+	for (const [key, value] of Object.entries(propsObj)) {
+		const simplified = simplifyValue(value);
+		if (simplified !== null) {
+			result[key] = simplified;
+		} else {
+			// Always keep the key — use a type hint for unresolvable values
+			result[key] = inferTypeHint(value);
+		}
+	}
+	return result;
+}
+
+/**
+ * Infer a type hint for a value we can't fully resolve.
+ * Tries calling the function first; falls back to string analysis.
+ */
+function inferTypeHint(value) {
+	if (typeof value === 'function') {
+		// Try calling to detect actual output type
+		try {
+			const result = value();
+			if (typeof result === 'function') {
+				try {
+					const inner = result();
+					if (Array.isArray(inner)) {
+						// Drill through nested arrays to find the first object
+						let sample = inner;
+						while (Array.isArray(sample) && sample.length > 0 && Array.isArray(sample[0])) {
+							sample = sample[0];
+						}
+						if (sample.length > 0 && typeof sample[0] === 'object' && sample[0] !== null && !Array.isArray(sample[0])) {
+							return { "$type": "object[]", "$keys": Object.keys(sample[0]) };
+						}
+						return { "$type": "array" };
+					}
+					return { "$type": typeof inner };
+				} catch { return { "$type": "function" }; }
+			}
+			if (typeof result === 'string') return { "$type": "string" };
+			if (typeof result === 'number') return { "$type": "number" };
+			if (typeof result === 'boolean') return { "$type": "boolean" };
+			if (Array.isArray(result)) return { "$type": "array" };
+			return { "$type": typeof result };
+		} catch { /* can't call — fall through to string analysis */ }
+
+		// String analysis fallback
+		const fnStr = value.toString();
+		if (fnStr.includes('guid') || fnStr.includes('uuid')) return { "$type": "string" };
+		if (fnStr.includes('integer')) return { "$type": "number" };
+		return { "$type": "unknown" };
+	}
+	if (Array.isArray(value)) {
+		if (value.length > 0 && typeof value[0] === 'object') return { "$type": "object[]" };
+		return { "$type": "array" };
+	}
+	return { "$type": typeof value };
+}
+
+/**
+ * Simplify a property value to its schema representation.
+ * Returns null if the value is too complex or high-cardinality to represent.
+ */
+function simplifyValue(value) {
+	// Primitives
+	if (typeof value === 'string' || typeof value === 'boolean') return [value];
+	if (typeof value === 'number') return [value];
+
+	// Arrays (plain values or weighNumRange output)
+	if (Array.isArray(value)) {
+		return simplifyArray(value);
+	}
+
+	// Functions: pickAWinner, weighChoices, chance bindings, custom generators
+	if (typeof value === 'function') {
+		return simplifyFunction(value);
+	}
+
+	return null;
+}
+
+/**
+ * Simplify an array value. Detects numeric ranges vs categorical arrays.
+ */
+function simplifyArray(arr) {
+	if (arr.length === 0) return null;
+
+	// Check element types
+	const types = new Set(arr.map(v => typeof v));
+
+	// All numbers — likely weighNumRange output if large, or small explicit list
+	if (types.size === 1 && types.has('number')) {
+		if (arr.length > 10) {
+			// Numeric range (weighNumRange produces 50 elements)
+			const min = Math.min(...arr);
+			const max = Math.max(...arr);
+			// Round to clean integers if values are close to integers
+			const roundedMin = Number.isInteger(min) ? min : Math.round(min * 100) / 100;
+			const roundedMax = Number.isInteger(max) ? max : Math.round(max * 100) / 100;
+			return { "$range": [roundedMin, roundedMax] };
+		}
+		// Small explicit numeric list — deduplicate
+		return [...new Set(arr)];
+	}
+
+	// All strings — deduplicate
+	if (types.size === 1 && types.has('string')) {
+		return [...new Set(arr)];
+	}
+
+	// All booleans — deduplicate
+	if (types.size === 1 && types.has('boolean')) {
+		return [...new Set(arr)];
+	}
+
+	// Mixed primitives (e.g. [true, false, 0.75, 1.0]) — deduplicate
+	if ([...types].every(t => t === 'string' || t === 'number' || t === 'boolean')) {
+		return [...new Set(arr)];
+	}
+
+	// Contains objects/arrays (nested items like makeProducts)
+	if (arr.some(v => typeof v === 'object' && v !== null && !Array.isArray(v))) {
+		// Extract keys from first object to show the shape
+		const firstObj = arr.find(v => typeof v === 'object' && v !== null);
+		if (firstObj) {
+			const keys = Object.keys(firstObj);
+			return { "$type": "object[]", "$keys": keys };
+		}
+	}
+	return null;
+}
+
+/**
+ * Simplify a function-based value by sampling it.
+ * Tries calling first; string analysis only for bound methods.
+ */
+function simplifyFunction(fn) {
+	try {
+		// Try calling the function first
+		const result = fn();
+
+		// Double-wrapped function (e.g. makeProducts returns fn → fn → array)
+		if (typeof result === 'function') {
+			try {
+				const inner = result();
+				if (Array.isArray(inner)) {
+					if (inner.some(v => typeof v === 'object' && v !== null)) return null;
+					return simplifyArray(inner);
+				}
+			} catch { /* inner call failed */ }
+			return null;
+		}
+
+		// Function returned an array (pickAWinner, weighChoices)
+		if (Array.isArray(result)) {
+			return simplifyArray(result);
+		}
+
+		// Function returned a primitive (chance.animal, chance.profession, etc.)
+		if (typeof result === 'string') {
+			// Sample a few times to see if it's low-cardinality
+			const samples = new Set([result]);
+			for (let i = 0; i < 30; i++) {
+				samples.add(fn());
+			}
+			// If < 15 unique values in 30 samples, it's low cardinality — include
+			if (samples.size < 15) {
+				return [...samples].sort();
+			}
+			return null; // high cardinality
+		}
+
+		return null;
+	} catch {
+		return null; // function can't be called standalone — skip
+	}
+}

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';
+}