redscript-mc 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * RedScript CLI
+ *
+ * Usage:
+ *   redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>]
+ *   redscript check <file>
+ *   redscript repl
+ *   redscript version
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * RedScript CLI
+ *
+ * Usage:
+ *   redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>]
+ *   redscript check <file>
+ *   redscript repl
+ *   redscript version
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const cmdblock_1 = require("./codegen/cmdblock");
+const structure_1 = require("./codegen/structure");
+const diagnostics_1 = require("./diagnostics");
+const repl_1 = require("./repl");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Parse command line arguments
+const args = process.argv.slice(2);
+function printUsage() {
+    console.log(`
+RedScript Compiler
+
+Usage:
+  redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--target <target>]
+  redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
+  redscript check <file>
+  redscript repl
+  redscript version
+
+Commands:
+  compile   Compile a RedScript file to a Minecraft datapack
+  watch     Watch a directory for .rs file changes, recompile, and hot reload
+  check     Check a RedScript file for errors without generating output
+  repl      Start an interactive RedScript REPL
+  version   Print the RedScript version
+
+Options:
+  -o, --output <path>    Output directory or file path, depending on target
+  --output-nbt <file>    Output .nbt file path for structure target
+  --namespace <ns>       Datapack namespace (default: derived from filename)
+  --target <target>      Output target: datapack (default), cmdblock, or structure
+  --stats                Print optimizer statistics
+  --hot-reload <url>     After each successful compile, POST to <url>/reload
+                         (use with redscript-testharness; e.g. http://localhost:25561)
+  -h, --help             Show this help message
+
+Targets:
+  datapack  Generate a full Minecraft datapack (default)
+  cmdblock  Generate JSON structure for command block placement
+  structure Generate a Minecraft structure .nbt file with command blocks
+`);
+}
+function printVersion() {
+    const packagePath = path.join(__dirname, '..', 'package.json');
+    try {
+        const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+        console.log(`RedScript v${pkg.version}`);
+    }
+    catch {
+        console.log('RedScript v0.1.0');
+    }
+}
+function parseArgs(args) {
+    const result = {};
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === '-h' || arg === '--help') {
+            result.help = true;
+            i++;
+        }
+        else if (arg === '-o' || arg === '--output') {
+            result.output = args[++i];
+            i++;
+        }
+        else if (arg === '--output-nbt') {
+            result.outputNbt = args[++i];
+            i++;
+        }
+        else if (arg === '--namespace') {
+            result.namespace = args[++i];
+            i++;
+        }
+        else if (arg === '--target') {
+            result.target = args[++i];
+            i++;
+        }
+        else if (arg === '--stats') {
+            result.stats = true;
+            i++;
+        }
+        else if (arg === '--hot-reload') {
+            result.hotReload = args[++i];
+            i++;
+        }
+        else if (!result.command) {
+            result.command = arg;
+            i++;
+        }
+        else if (!result.file) {
+            result.file = arg;
+            i++;
+        }
+        else {
+            i++;
+        }
+    }
+    return result;
+}
+function deriveNamespace(filePath) {
+    const basename = path.basename(filePath, path.extname(filePath));
+    // Convert to valid identifier: lowercase, replace non-alphanumeric with underscore
+    return basename.toLowerCase().replace(/[^a-z0-9]/g, '_');
+}
+function printWarnings(warnings) {
+    if (!warnings || warnings.length === 0) {
+        return;
+    }
+    for (const warning of warnings) {
+        console.error(`Warning [${warning.code}]: ${warning.message}`);
+    }
+}
+function formatReduction(before, after) {
+    if (before === 0)
+        return '0%';
+    return `${Math.round(((before - after) / before) * 100)}%`;
+}
+function printOptimizationStats(stats) {
+    if (!stats)
+        return;
+    console.log('Optimizations applied:');
+    console.log(`  LICM: ${stats.licmHoists} reads hoisted from ${stats.licmLoopBodies} loop bodies`);
+    console.log(`  CSE:  ${stats.cseRedundantReads + stats.cseArithmetic} expressions eliminated`);
+    console.log(`  setblock batching: ${stats.setblockMergedCommands} setblocks -> ${stats.setblockFillCommands} fills (saved ${stats.setblockSavedCommands} commands)`);
+    console.log(`  dead code: ${stats.deadCodeRemoved} commands removed`);
+    console.log(`  constant folding: ${stats.constantFolds} constants folded`);
+    console.log(`  Total mcfunction commands: ${stats.totalCommandsBefore} -> ${stats.totalCommandsAfter} (${formatReduction(stats.totalCommandsBefore, stats.totalCommandsAfter)} reduction)`);
+}
+function compileCommand(file, output, namespace, target = 'datapack', showStats = false) {
+    // Read source file
+    if (!fs.existsSync(file)) {
+        console.error(`Error: File not found: ${file}`);
+        process.exit(1);
+    }
+    const source = fs.readFileSync(file, 'utf-8');
+    try {
+        if (target === 'cmdblock') {
+            const result = (0, index_1.compile)(source, { namespace, filePath: file });
+            printWarnings(result.warnings);
+            // Generate command block JSON
+            const hasTick = result.files.some(f => f.path.includes('__tick.mcfunction'));
+            const hasLoad = result.files.some(f => f.path.includes('__load.mcfunction'));
+            const cmdBlocks = (0, cmdblock_1.generateCommandBlocks)(namespace, hasTick, hasLoad);
+            // Write command block JSON
+            fs.mkdirSync(output, { recursive: true });
+            const outputFile = path.join(output, `${namespace}_cmdblocks.json`);
+            fs.writeFileSync(outputFile, JSON.stringify(cmdBlocks, null, 2));
+            console.log(`✓ Generated command blocks for ${file}`);
+            console.log(`  Output: ${outputFile}`);
+            console.log(`  Blocks: ${cmdBlocks.blocks.length}`);
+            if (showStats) {
+                printOptimizationStats(result.stats);
+            }
+        }
+        else if (target === 'structure') {
+            const structure = (0, structure_1.compileToStructure)(source, namespace, file);
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.writeFileSync(output, structure.buffer);
+            console.log(`✓ Generated structure for ${file}`);
+            console.log(`  Output: ${output}`);
+            console.log(`  Blocks: ${structure.blockCount}`);
+            if (showStats) {
+                printOptimizationStats(structure.stats);
+            }
+        }
+        else {
+            const result = (0, index_1.compile)(source, { namespace, filePath: file });
+            printWarnings(result.warnings);
+            // Default: generate datapack
+            // Create output directory
+            fs.mkdirSync(output, { recursive: true });
+            // Write all files
+            for (const dataFile of result.files) {
+                const filePath = path.join(output, dataFile.path);
+                const dir = path.dirname(filePath);
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(filePath, dataFile.content);
+            }
+            console.log(`✓ Compiled ${file} to ${output}/`);
+            console.log(`  Namespace: ${namespace}`);
+            console.log(`  Functions: ${result.ir.functions.length}`);
+            console.log(`  Files: ${result.files.length}`);
+            if (showStats) {
+                printOptimizationStats(result.stats);
+            }
+        }
+    }
+    catch (err) {
+        console.error((0, diagnostics_1.formatError)(err, source));
+        process.exit(1);
+    }
+}
+function checkCommand(file) {
+    // Read source file
+    if (!fs.existsSync(file)) {
+        console.error(`Error: File not found: ${file}`);
+        process.exit(1);
+    }
+    const source = fs.readFileSync(file, 'utf-8');
+    const error = (0, index_1.check)(source, 'redscript', file);
+    if (error) {
+        console.error((0, diagnostics_1.formatError)(error, source));
+        process.exit(1);
+    }
+    console.log(`✓ ${file} is valid`);
+}
+async function hotReload(url) {
+    try {
+        const res = await fetch(`${url}/reload`, { method: 'POST' });
+        if (res.ok) {
+            console.log(`🔄 Hot reload sent → ${url}`);
+        }
+        else {
+            console.warn(`⚠  Hot reload failed: HTTP ${res.status}`);
+        }
+    }
+    catch (e) {
+        console.warn(`⚠  Hot reload failed (is the server running?): ${e.message}`);
+    }
+}
+function watchCommand(dir, output, namespace, hotReloadUrl) {
+    // Check if directory exists
+    if (!fs.existsSync(dir)) {
+        console.error(`Error: Directory not found: ${dir}`);
+        process.exit(1);
+    }
+    const stat = fs.statSync(dir);
+    if (!stat.isDirectory()) {
+        console.error(`Error: ${dir} is not a directory`);
+        process.exit(1);
+    }
+    console.log(`👁  Watching ${dir} for .rs file changes...`);
+    console.log(`   Output: ${output}`);
+    if (hotReloadUrl)
+        console.log(`   Hot reload: ${hotReloadUrl}`);
+    console.log(`   Press Ctrl+C to stop\n`);
+    // Debounce timer
+    let debounceTimer = null;
+    // Compile all .rs files in directory
+    async function compileAll() {
+        const files = findRsFiles(dir);
+        if (files.length === 0) {
+            console.log(`⚠  No .rs files found in ${dir}`);
+            return;
+        }
+        let hasErrors = false;
+        for (const file of files) {
+            let source = '';
+            try {
+                source = fs.readFileSync(file, 'utf-8');
+                const ns = namespace ?? deriveNamespace(file);
+                const result = (0, index_1.compile)(source, { namespace: ns, filePath: file });
+                printWarnings(result.warnings);
+                // Create output directory
+                fs.mkdirSync(output, { recursive: true });
+                // Write all files
+                for (const dataFile of result.files) {
+                    const filePath = path.join(output, dataFile.path);
+                    const fileDir = path.dirname(filePath);
+                    fs.mkdirSync(fileDir, { recursive: true });
+                    fs.writeFileSync(filePath, dataFile.content);
+                }
+                const timestamp = new Date().toLocaleTimeString();
+                console.log(`✓ [${timestamp}] Compiled ${file} (${result.files.length} files)`);
+            }
+            catch (err) {
+                hasErrors = true;
+                const timestamp = new Date().toLocaleTimeString();
+                console.error(`✗ [${timestamp}] ${(0, diagnostics_1.formatError)(err, source)}`);
+            }
+        }
+        if (!hasErrors) {
+            if (hotReloadUrl)
+                await hotReload(hotReloadUrl);
+            console.log('');
+        }
+    }
+    // Find all .rs files recursively
+    function findRsFiles(directory) {
+        const results = [];
+        const entries = fs.readdirSync(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...findRsFiles(fullPath));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.rs')) {
+                results.push(fullPath);
+            }
+        }
+        return results;
+    }
+    // Initial compile
+    void compileAll();
+    // Watch for changes
+    fs.watch(dir, { recursive: true }, (eventType, filename) => {
+        if (filename && filename.endsWith('.rs')) {
+            // Debounce rapid changes
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+            }
+            debounceTimer = setTimeout(() => {
+                console.log(`📝 Change detected: ${filename}`);
+                void compileAll();
+            }, 100);
+        }
+    });
+}
+// Main
+const parsed = parseArgs(args);
+async function main() {
+    if (parsed.help || !parsed.command) {
+        printUsage();
+        process.exit(parsed.help ? 0 : 1);
+    }
+    switch (parsed.command) {
+        case 'compile':
+            if (!parsed.file) {
+                console.error('Error: No input file specified');
+                printUsage();
+                process.exit(1);
+            }
+            {
+                const namespace = parsed.namespace ?? deriveNamespace(parsed.file);
+                const target = parsed.target ?? 'datapack';
+                const output = target === 'structure'
+                    ? (parsed.outputNbt ?? parsed.output ?? `./${namespace}.nbt`)
+                    : (parsed.output ?? './dist');
+                compileCommand(parsed.file, output, namespace, target, parsed.stats);
+            }
+            break;
+        case 'watch':
+            if (!parsed.file) {
+                console.error('Error: No directory specified');
+                printUsage();
+                process.exit(1);
+            }
+            watchCommand(parsed.file, parsed.output ?? './dist', parsed.namespace, parsed.hotReload);
+            break;
+        case 'check':
+            if (!parsed.file) {
+                console.error('Error: No input file specified');
+                printUsage();
+                process.exit(1);
+            }
+            checkCommand(parsed.file);
+            break;
+        case 'repl':
+            await (0, repl_1.startRepl)(parsed.namespace ?? 'repl');
+            break;
+        case 'version':
+            printVersion();
+            break;
+        default:
+            console.error(`Error: Unknown command '${parsed.command}'`);
+            printUsage();
+            process.exit(1);
+    }
+}
+void main();
+//# sourceMappingURL=cli.js.map

package/dist/codegen/cmdblock/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Command Block Target
+ *
+ * Generates a JSON structure representing command blocks that can be
+ * placed in Minecraft to run the compiled datapack.
+ */
+export interface CommandBlock {
+    type: 'repeat' | 'impulse' | 'chain';
+    command: string;
+    pos: [number, number, number];
+    auto?: boolean;
+    conditional?: boolean;
+}
+export interface CommandBlockStructure {
+    format: 'redscript-cmdblock-v1';
+    namespace: string;
+    blocks: CommandBlock[];
+}
+/**
+ * Generate a command block structure JSON for a given namespace.
+ *
+ * Creates:
+ * - 1 × Repeat block: function <namespace>:__tick
+ * - 1 × Impulse block (auto): function <namespace>:__load
+ */
+export declare function generateCommandBlocks(namespace: string, hasTick: boolean, hasLoad: boolean): CommandBlockStructure;

package/dist/codegen/cmdblock/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Command Block Target
+ *
+ * Generates a JSON structure representing command blocks that can be
+ * placed in Minecraft to run the compiled datapack.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommandBlocks = generateCommandBlocks;
+/**
+ * Generate a command block structure JSON for a given namespace.
+ *
+ * Creates:
+ * - 1 × Repeat block: function <namespace>:__tick
+ * - 1 × Impulse block (auto): function <namespace>:__load
+ */
+function generateCommandBlocks(namespace, hasTick, hasLoad) {
+    const blocks = [];
+    let x = 0;
+    // Load block - impulse with auto (runs once when placed)
+    if (hasLoad) {
+        blocks.push({
+            type: 'impulse',
+            command: `function ${namespace}:__load`,
+            pos: [x, 0, 0],
+            auto: true,
+        });
+        x++;
+    }
+    // Tick block - repeat (runs every tick)
+    if (hasTick) {
+        blocks.push({
+            type: 'repeat',
+            command: `function ${namespace}:__tick`,
+            pos: [x, 0, 0],
+        });
+        x++;
+    }
+    return {
+        format: 'redscript-cmdblock-v1',
+        namespace,
+        blocks,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/codegen/mcfunction/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Code generator: IR → mcfunction datapack
+ *
+ * Output structure:
+ *   <namespace>/
+ *     functions/
+ *       <fn_name>.mcfunction
+ *       <fn_name>/<block_label>.mcfunction   (for control-flow continuations)
+ *     load.mcfunction     (objective setup)
+ *
+ * Variable mapping:
+ *   scoreboard objective: "rs"
+ *   fake player:          "$<varname>"
+ *   temporaries:          "$t0", "$t1", ...
+ *   return value:         "$ret"
+ *   parameters:           "$p0", "$p1", ...
+ */
+import type { IRModule } from '../../ir/types';
+import { type OptimizationStats } from '../../optimizer/commands';
+export interface DatapackFile {
+    path: string;
+    content: string;
+}
+export interface DatapackGenerationResult {
+    files: DatapackFile[];
+    advancements: DatapackFile[];
+    stats: OptimizationStats;
+}
+export interface DatapackGenerationOptions {
+    optimizeCommands?: boolean;
+}
+export declare function countMcfunctionCommands(files: DatapackFile[]): number;
+export declare function generateDatapackWithStats(module: IRModule, options?: DatapackGenerationOptions): DatapackGenerationResult;
+export declare function generateDatapack(module: IRModule): DatapackFile[];