redscript-mc 1.2.30 → 2.0.0

package/dist/src/mc-test/client.d.ts

@@ -0,0 +1,128 @@
+/**
+ * RedScript MC Test Client
+ *
+ * Connects to a Paper server running TestHarnessPlugin and provides
+ * a fluent API for integration testing compiled datapacks.
+ *
+ * Usage:
+ *   const mc = new MCTestClient('localhost', 25561)
+ *   await mc.command('/function arena:start')
+ *   await mc.ticks(100)
+ *   const score = await mc.scoreboard('Alice', 'kills')
+ *   expect(score).toBe(3)
+ */
+export interface ScoreResult {
+    player: string;
+    obj: string;
+    value: number;
+}
+export interface BlockResult {
+    x: number;
+    y: number;
+    z: number;
+    world: string;
+    type: string;
+    blockData: string;
+}
+export interface EntityResult {
+    uuid: string;
+    name: string;
+    type: string;
+    x: number;
+    y: number;
+    z: number;
+    world: string;
+    tags: string[];
+}
+export interface ChatMessage {
+    tick: number;
+    type: string;
+    sender?: string;
+    message: string;
+}
+export interface GameEvent {
+    tick: number;
+    type: string;
+    player?: string;
+    advancement?: string;
+    cause?: string;
+}
+export interface ServerStatus {
+    online: boolean;
+    tps_1m: number;
+    tps_5m: number;
+    tps_15m: number;
+    players: number;
+    playerNames: string[];
+    worlds: string[];
+    version: string;
+}
+export declare class MCTestClient {
+    private baseUrl;
+    constructor(host?: string, port?: number);
+    private get;
+    private post;
+    /** Check if server is reachable */
+    isOnline(): Promise<boolean>;
+    /** Get server status */
+    status(): Promise<ServerStatus>;
+    /** Run a command on the server (as console sender) */
+    command(cmd: string): Promise<{
+        ok: boolean;
+        cmd: string;
+    }>;
+    /** Wait for N server ticks (50ms each) */
+    ticks(count: number): Promise<void>;
+    /** Wait for 1 second = 20 ticks */
+    seconds(s: number): Promise<void>;
+    /** Get a scoreboard value */
+    scoreboard(player: string, obj: string): Promise<number>;
+    /** Get all scoreboard values for a selector */
+    scoreboardAll(selector: string, obj: string): Promise<ScoreResult[]>;
+    /** Get block at position */
+    block(x: number, y: number, z: number, world?: string): Promise<BlockResult>;
+    /** Get entities matching selector */
+    entities(selector?: string): Promise<EntityResult[]>;
+    /** Get chat log since a tick */
+    chat(since?: number): Promise<ChatMessage[]>;
+    /** Get last N chat messages */
+    chatLast(n: number): Promise<ChatMessage[]>;
+    /** Get events since a tick, optionally filtered by type */
+    events(since?: number, type?: string): Promise<GameEvent[]>;
+    /** Clear chat and event logs */
+    reset(): Promise<void>;
+    /**
+     * Full test reset: clear logs + fill test area with air + kill entities + reset scoreboards.
+     * Call this at the start of each integration test.
+     */
+    fullReset(options?: {
+        x1?: number;
+        y1?: number;
+        z1?: number;
+        x2?: number;
+        y2?: number;
+        z2?: number;
+        clearArea?: boolean;
+        killEntities?: boolean;
+        resetScoreboards?: boolean;
+    }): Promise<void>;
+    /** Reload datapacks */
+    reload(): Promise<void>;
+    /**
+     * Assert a scoreboard value equals expected.
+     * Throws with a descriptive error if it doesn't match.
+     */
+    assertScore(player: string, obj: string, expected: number, msg?: string): Promise<void>;
+    /**
+     * Assert a block type at position.
+     */
+    assertBlock(x: number, y: number, z: number, expectedType: string, world?: string): Promise<void>;
+    /**
+     * Assert chat log contains a message matching substring.
+     */
+    assertChatContains(substring: string, since?: number): Promise<void>;
+    /**
+     * Wait until a scoreboard value equals expected, up to timeout ms.
+     */
+    waitForScore(player: string, obj: string, expected: number, timeoutMs?: number, pollMs?: number): Promise<void>;
+}

package/dist/src/mc-test/client.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * RedScript MC Test Client
+ *
+ * Connects to a Paper server running TestHarnessPlugin and provides
+ * a fluent API for integration testing compiled datapacks.
+ *
+ * Usage:
+ *   const mc = new MCTestClient('localhost', 25561)
+ *   await mc.command('/function arena:start')
+ *   await mc.ticks(100)
+ *   const score = await mc.scoreboard('Alice', 'kills')
+ *   expect(score).toBe(3)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCTestClient = void 0;
+class MCTestClient {
+    constructor(host = 'localhost', port = 25561) {
+        this.baseUrl = `http://${host}:${port}`;
+    }
+    async get(path, params = {}) {
+        const qs = Object.entries(params)
+            .map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`)
+            .join('&');
+        const url = `${this.baseUrl}${path}${qs ? '?' + qs : ''}`;
+        const res = await fetch(url);
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`GET ${path} failed ${res.status}: ${body}`);
+        }
+        return res.json();
+    }
+    async post(path, body = {}) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`POST ${path} failed ${res.status}: ${text}`);
+        }
+        return res.json();
+    }
+    /** Check if server is reachable */
+    async isOnline() {
+        try {
+            const status = await this.get('/status');
+            return status.online;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Get server status */
+    async status() {
+        return this.get('/status');
+    }
+    /** Run a command on the server (as console sender) */
+    async command(cmd) {
+        return this.post('/command', { cmd });
+    }
+    /** Wait for N server ticks (50ms each) */
+    async ticks(count) {
+        await this.post('/tick', { count });
+    }
+    /** Wait for 1 second = 20 ticks */
+    async seconds(s) {
+        await this.ticks(s * 20);
+    }
+    /** Get a scoreboard value */
+    async scoreboard(player, obj) {
+        const result = await this.get('/scoreboard', { player, obj });
+        return result.value;
+    }
+    /** Get all scoreboard values for a selector */
+    async scoreboardAll(selector, obj) {
+        return this.get('/scoreboard', { player: selector, obj });
+    }
+    /** Get block at position */
+    async block(x, y, z, world = 'world') {
+        return this.get('/block', { x, y, z, world });
+    }
+    /** Get entities matching selector */
+    async entities(selector = '@e') {
+        return this.get('/entity', { sel: selector });
+    }
+    /** Get chat log since a tick */
+    async chat(since = 0) {
+        return this.get('/chat', { since });
+    }
+    /** Get last N chat messages */
+    async chatLast(n) {
+        return this.get('/chat', { last: n });
+    }
+    /** Get events since a tick, optionally filtered by type */
+    async events(since = 0, type) {
+        const params = { since };
+        if (type)
+            params.type = type;
+        return this.get('/events', params);
+    }
+    /** Clear chat and event logs */
+    async reset() {
+        await this.post('/reset');
+    }
+    /**
+     * Full test reset: clear logs + fill test area with air + kill entities + reset scoreboards.
+     * Call this at the start of each integration test.
+     */
+    async fullReset(options) {
+        await this.post('/reset', {
+            clearArea: options?.clearArea ?? true,
+            killEntities: options?.killEntities ?? true,
+            resetScoreboards: options?.resetScoreboards ?? true,
+            x1: options?.x1 ?? -50, y1: options?.y1 ?? 0, z1: options?.z1 ?? -50,
+            x2: options?.x2 ?? 50, y2: options?.y2 ?? 100, z2: options?.z2 ?? 50,
+        });
+    }
+    /** Reload datapacks */
+    async reload() {
+        await this.post('/reload');
+        await this.ticks(40); // wait 2s for reload
+    }
+    /**
+     * Assert a scoreboard value equals expected.
+     * Throws with a descriptive error if it doesn't match.
+     */
+    async assertScore(player, obj, expected, msg) {
+        const actual = await this.scoreboard(player, obj);
+        if (actual !== expected) {
+            throw new Error(msg ?? `assertScore failed: ${player}/${obj} expected ${expected}, got ${actual}`);
+        }
+    }
+    /**
+     * Assert a block type at position.
+     */
+    async assertBlock(x, y, z, expectedType, world = 'world') {
+        const block = await this.block(x, y, z, world);
+        if (block.type !== expectedType) {
+            throw new Error(`assertBlock failed: (${x},${y},${z}) expected ${expectedType}, got ${block.type}`);
+        }
+    }
+    /**
+     * Assert chat log contains a message matching substring.
+     */
+    async assertChatContains(substring, since = 0) {
+        const msgs = await this.chat(since);
+        const found = msgs.some(m => m.message.includes(substring));
+        if (!found) {
+            const recent = msgs.map(m => m.message).slice(-5).join(', ');
+            throw new Error(`assertChatContains: "${substring}" not found in chat. Recent: [${recent}]`);
+        }
+    }
+    /**
+     * Wait until a scoreboard value equals expected, up to timeout ms.
+     */
+    async waitForScore(player, obj, expected, timeoutMs = 5000, pollMs = 100) {
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+            try {
+                const val = await this.scoreboard(player, obj);
+                if (val === expected)
+                    return;
+            }
+            catch { /* ignore transient errors */ }
+            await new Promise(r => setTimeout(r, pollMs));
+        }
+        const final = await this.scoreboard(player, obj);
+        throw new Error(`waitForScore: ${player}/${obj} never reached ${expected} (last: ${final})`);
+    }
+}
+exports.MCTestClient = MCTestClient;
+//# sourceMappingURL=client.js.map

package/dist/src/mc-test/runner.d.ts

@@ -0,0 +1,28 @@
+/**
+ * RedScript MC Integration Test Runner
+ *
+ * Compiles a .mcrs file, installs it to a running Paper server,
+ * runs test scenarios, and reports results.
+ *
+ * Usage:
+ *   npx ts-node src/mc-test/runner.ts src/examples/counter.mcrs
+ *
+ * Requires:
+ *   - Paper server running with TestHarnessPlugin
+ *   - MC_SERVER_DIR env var pointing to server directory
+ *   - MC_HOST and MC_PORT env vars (default: localhost:25561)
+ */
+import { MCTestClient } from './client';
+export interface TestCase {
+    name: string;
+    run: (mc: MCTestClient) => Promise<void>;
+}
+export interface TestResult {
+    name: string;
+    passed: boolean;
+    error?: string;
+    durationMs: number;
+}
+export declare function runMCTests(sourceFile: string, tests: TestCase[], options?: {
+    skipInstall?: boolean;
+}): Promise<TestResult[]>;

package/dist/src/mc-test/runner.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * RedScript MC Integration Test Runner
+ *
+ * Compiles a .mcrs file, installs it to a running Paper server,
+ * runs test scenarios, and reports results.
+ *
+ * Usage:
+ *   npx ts-node src/mc-test/runner.ts src/examples/counter.mcrs
+ *
+ * Requires:
+ *   - Paper server running with TestHarnessPlugin
+ *   - MC_SERVER_DIR env var pointing to server directory
+ *   - MC_HOST and MC_PORT env vars (default: localhost:25561)
+ */
+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 });
+exports.runMCTests = runMCTests;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const client_1 = require("./client");
+const compile_1 = require("../compile");
+const MC_HOST = process.env.MC_HOST ?? 'localhost';
+const MC_PORT = parseInt(process.env.MC_PORT ?? '25561');
+const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
+async function runMCTests(sourceFile, tests, options = {}) {
+    const mc = new client_1.MCTestClient(MC_HOST, MC_PORT);
+    // Check server is online
+    console.log(`Connecting to MC server at ${MC_HOST}:${MC_PORT}...`);
+    const online = await mc.isOnline();
+    if (!online) {
+        throw new Error(`MC server not reachable at ${MC_HOST}:${MC_PORT}. Start Paper server first.`);
+    }
+    console.log('✓ Server online');
+    if (!options.skipInstall) {
+        // Compile and install datapack
+        const outDir = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
+        console.log(`Compiling ${sourceFile}...`);
+        const ns = path.basename(sourceFile, '.mcrs');
+        const result = (0, compile_1.compile)(fs.readFileSync(sourceFile, 'utf-8'), { namespace: ns, filePath: sourceFile });
+        if (!result.files) {
+            throw new Error('Compilation failed');
+        }
+        // Write files
+        fs.mkdirSync(outDir, { recursive: true });
+        for (const file of result.files) {
+            const filePath = path.join(outDir, file.path);
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, file.content);
+        }
+        console.log(`✓ Datapack installed to ${outDir}`);
+        // Reload datapacks
+        await mc.command('/reload');
+        await mc.ticks(40); // wait 2s for reload
+        console.log('✓ Datapacks reloaded');
+    }
+    // Run tests
+    const results = [];
+    for (const test of tests) {
+        await mc.reset(); // clear logs before each test
+        const start = Date.now();
+        try {
+            await test.run(mc);
+            results.push({ name: test.name, passed: true, durationMs: Date.now() - start });
+            console.log(`  ✓ ${test.name} (${Date.now() - start}ms)`);
+        }
+        catch (err) {
+            results.push({
+                name: test.name,
+                passed: false,
+                error: err.message,
+                durationMs: Date.now() - start
+            });
+            console.log(`  ✗ ${test.name}: ${err.message}`);
+        }
+    }
+    // Summary
+    const passed = results.filter(r => r.passed).length;
+    const failed = results.length - passed;
+    console.log(`\nResults: ${passed}/${results.length} passed${failed > 0 ? ` (${failed} FAILED)` : ''}`);
+    return results;
+}
+// CLI entry point
+if (require.main === module) {
+    const sourceFile = process.argv[2];
+    if (!sourceFile) {
+        console.error('Usage: ts-node runner.ts <source.mcrs>');
+        process.exit(1);
+    }
+    // Example test suite (replace with actual tests)
+    const exampleTests = [
+        {
+            name: 'server is online',
+            run: async (mc) => {
+                const status = await mc.status();
+                if (!status.online)
+                    throw new Error('Server not online');
+            }
+        },
+        {
+            name: 'datapack loads without errors',
+            run: async (mc) => {
+                await mc.command('/reload');
+                await mc.ticks(20);
+                // If reload didn't crash, we're good
+            }
+        }
+    ];
+    runMCTests(sourceFile, exampleTests)
+        .then(results => {
+        const failed = results.filter(r => !r.passed);
+        process.exit(failed.length > 0 ? 1 : 0);
+    })
+        .catch(err => {
+        console.error(err.message);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=runner.js.map

package/dist/src/mc-test/setup.d.ts

@@ -0,0 +1,11 @@
+/**
+ * MC Test Setup Script
+ *
+ * Pre-compiles all RedScript test fixtures into the datapack directory.
+ * Run this ONCE before starting the Paper server, or before running tests
+ * with a fresh server.
+ *
+ * Usage:
+ *   MC_SERVER_DIR=~/mc-test-server npx ts-node src/mc-test/setup.ts
+ */
+export {};

package/dist/src/mc-test/setup.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * MC Test Setup Script
+ *
+ * Pre-compiles all RedScript test fixtures into the datapack directory.
+ * Run this ONCE before starting the Paper server, or before running tests
+ * with a fresh server.
+ *
+ * Usage:
+ *   MC_SERVER_DIR=~/mc-test-server npx ts-node src/mc-test/setup.ts
+ */
+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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const compile_1 = require("../compile");
+const MC_SERVER_DIR = process.env.MC_SERVER_DIR ?? path.join(process.env.HOME, 'mc-test-server');
+const DATAPACK_DIR = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test');
+const EXAMPLES_DIR = path.join(__dirname, '../examples');
+function writeFixture(source, namespace) {
+    const result = (0, compile_1.compile)(source, { namespace });
+    let fileCount = 0;
+    for (const file of result.files ?? []) {
+        const filePath = path.join(DATAPACK_DIR, file.path);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, file.content);
+        fileCount++;
+    }
+    console.log(`  ✓ ${namespace} (${fileCount} files)`);
+}
+function main() {
+    console.log(`Setting up MC test fixtures in:\n  ${DATAPACK_DIR}\n`);
+    fs.mkdirSync(DATAPACK_DIR, { recursive: true });
+    // Example files
+    const exampleNamespaces = ['counter', 'world_manager'];
+    for (const ns of exampleNamespaces) {
+        const file = path.join(EXAMPLES_DIR, `${ns}.mcrs`);
+        if (fs.existsSync(file)) {
+            writeFixture(fs.readFileSync(file, 'utf-8'), ns);
+        }
+        else {
+            console.log(`  ⚠ ${ns}.mcrs not found, skipping`);
+        }
+    }
+    // Inline test fixtures
+    writeFixture(`
+    @tick
+    fn on_tick() {
+      scoreboard_set("#tick_counter", "ticks", scoreboard_get("#tick_counter", "ticks") + 1)
+    }
+  `, 'tick_test');
+    writeFixture(`
+    fn check_score() {
+      let x: int = scoreboard_get("#check_x", "test_score")
+      if (x > 5) {
+        scoreboard_set("#check_x", "result", 1)
+      } else {
+        scoreboard_set("#check_x", "result", 0)
+      }
+    }
+  `, 'inline_test');
+    console.log('\n✅ All fixtures written. Restart the MC server to load them.');
+    console.log('   Then run: MC_SERVER_DIR=... npx jest mc-integration --testTimeout=60000');
+}
+main();
+//# sourceMappingURL=setup.js.map

package/dist/src/mc-validator/index.d.ts

@@ -0,0 +1,17 @@
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+export declare class MCCommandValidator {
+    private readonly root;
+    private readonly rootChildren;
+    constructor(commandsPath: string);
+    validate(line: string): ValidationResult;
+    private hasRootCommand;
+    private validateExecute;
+    private validateScoreboard;
+    private validateFunction;
+    private validateData;
+    private validateReturn;
+    private validateAgainstTree;
+}