redscript-mc 2.6.2 → 3.0.0

package/dist/src/cli.js

@@ -6,6 +6,7 @@
  * Usage:
  *   redscript compile <file> [-o <out>] [--namespace <ns>]
  *   redscript check <file>
+ *   redscript init [project-name]
  *   redscript repl
  *   redscript version
  */
@@ -42,6 +43,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("./index");
 const diagnostics_1 = require("./diagnostics");
@@ -51,10 +55,13 @@ const metadata_1 = require("./builtins/metadata");
 const index_2 = require("./cache/index");
 const deps_1 = require("./cache/deps");
 const incremental_1 = require("./cache/incremental");
+const index_3 = require("./lint/index");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const https = __importStar(require("https"));
 const child_process_1 = require("child_process");
+const archiver_1 = __importDefault(require("archiver"));
+const project_config_1 = require("./config/project-config");
 // Parse command line arguments
 const args = process.argv.slice(2);
 function printUsage() {
@@ -62,9 +69,13 @@ function printUsage() {
 RedScript Compiler v2
 
 Usage:
-  redscript compile <file> [-o <out>] [--namespace <ns>]
+  redscript compile <file> [-o <out>] [--namespace <ns>] [--incremental]
+  redscript publish <file> [-o <out.zip>] [--namespace <ns>] [--mc-version <ver>]
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
+  redscript test <file> [--dry-run] [--mc-url <url>]
   redscript check <file>
+  redscript lint <file> [--max-function-lines <n>]
+  redscript init [project-name]
   redscript fmt <file.mcrs> [file2.mcrs ...]
   redscript generate-dts [-o <file>]
   redscript repl
@@ -72,8 +83,12 @@ Usage:
 
 Commands:
   compile       Compile a RedScript file to a Minecraft datapack
+  publish       Compile and package the datapack as a .zip (ready to install in Minecraft)
   watch         Watch a directory for .mcrs file changes, recompile, and hot reload
+  test          Compile and run @test-annotated functions as tests
   check         Check a RedScript file for errors without generating output
+  lint          Statically analyze a RedScript file for potential issues (warnings)
+  init          Scaffold a new RedScript datapack project
   fmt           Auto-format RedScript source files
   generate-dts  Generate builtin function declaration file (builtins.d.mcrs)
   repl          Start an interactive RedScript REPL
@@ -90,6 +105,9 @@ Options:
                          e.g. --mc-version 1.20.2, --mc-version 1.19
   --lenient              Treat type errors as warnings instead of blocking compilation
   --include <dir>        Add a directory to the import search path (repeatable)
+  --incremental          Enable file-level incremental compilation cache
+  --dry-run              (test) Verify compilation only — no MC server connection needed
+  --mc-url <url>         (test) MC server HTTP API URL for running tests live
   -h, --help             Show this help message
 `);
 }
@@ -217,6 +235,37 @@ function parseArgs(args) {
             result.includeDirs.push(args[++i]);
             i++;
         }
+        else if (arg === '--format') {
+            const format = args[++i];
+            if (format === 'json' || format === 'human') {
+                result.format = format;
+            }
+            i++;
+        }
+        else if (arg === '--check') {
+            result.fmtCheck = true;
+            i++;
+        }
+        else if (arg === '--incremental') {
+            result.incremental = true;
+            i++;
+        }
+        else if (arg === '--max-function-lines') {
+            result.maxFunctionLines = parseInt(args[++i], 10);
+            i++;
+        }
+        else if (arg === '--description') {
+            result.description = args[++i];
+            i++;
+        }
+        else if (arg === '--dry-run') {
+            result.dryRun = true;
+            i++;
+        }
+        else if (arg === '--mc-url') {
+            result.mcUrl = args[++i];
+            i++;
+        }
         else if (!result.command) {
             result.command = arg;
             i++;
@@ -236,7 +285,88 @@ function deriveNamespace(filePath) {
     // Convert to valid identifier: lowercase, replace non-alphanumeric with underscore
     return basename.toLowerCase().replace(/[^a-z0-9]/g, '_');
 }
-function compileCommand(file, output, namespace, sourceMap = false, mcVersionStr, lenient = false, includeDirs) {
+function sanitizeProjectName(name) {
+    return name.trim().toLowerCase().replace(/[^a-z0-9]/g, '_');
+}
+function buildInitFiles(namespace) {
+    return {
+        'src/main.mcrs': `@load
+fn setup(): void {
+  say("Loaded ${namespace}");
+}
+
+@tick(rate=20)
+fn heartbeat(): void {
+  say("Tick from ${namespace}");
+}
+`,
+        'redscript.toml': (0, project_config_1.buildTomlTemplate)(namespace),
+        'redscript.config.json': `${JSON.stringify({
+            namespace,
+            entry: 'src/main.mcrs',
+            outDir: 'dist/',
+            mcVersion: '1.21.4',
+        }, null, 2)}
+`,
+        '.gitignore': `dist/
+.redscript-cache/
+`,
+        'README.md': `# ${namespace}
+
+Minimal RedScript datapack scaffold.
+
+## Quick Start
+
+\`\`\`bash
+redscript compile src/main.mcrs -o dist --namespace ${namespace}
+\`\`\`
+
+Then copy \`dist/\` into your world's datapacks folder and run \`/reload\`.
+
+## Files
+
+- \`src/main.mcrs\` contains \`@load\` and \`@tick\` examples.
+- \`redscript.toml\` stores the project configuration (replaces CLI flags).
+- \`redscript.config.json\` stores legacy project settings.
+`,
+    };
+}
+function initCommand(projectName) {
+    const explicitName = projectName?.trim();
+    const targetDir = explicitName
+        ? path.resolve(process.cwd(), explicitName)
+        : process.cwd();
+    const namespaceSource = explicitName ? path.basename(targetDir) : path.basename(targetDir);
+    const namespace = sanitizeProjectName(namespaceSource);
+    if (!namespace) {
+        console.error('Error: Project name must contain at least one letter or number');
+        process.exit(1);
+    }
+    if (fs.existsSync(targetDir)) {
+        const stat = fs.statSync(targetDir);
+        if (!stat.isDirectory()) {
+            console.error(`Error: Target path is not a directory: ${targetDir}`);
+            process.exit(1);
+        }
+        if (explicitName && fs.readdirSync(targetDir).length > 0) {
+            console.error(`Error: Target directory is not empty: ${targetDir}`);
+            process.exit(1);
+        }
+    }
+    else {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    const files = buildInitFiles(namespace);
+    for (const [relativePath, content] of Object.entries(files)) {
+        const fullPath = path.join(targetDir, relativePath);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content, 'utf-8');
+    }
+    console.log(`✓ Initialized RedScript project in ${targetDir}`);
+    console.log(`  Namespace: ${namespace}`);
+    console.log('  Entry: src/main.mcrs');
+}
+function compileCommand(file, output, namespace, sourceMap = false, mcVersionStr, lenient = false, includeDirs, incremental = false) {
     // Read source file
     if (!fs.existsSync(file)) {
         console.error(`Error: File not found: ${file}`);
@@ -252,6 +382,38 @@ function compileCommand(file, output, namespace, sourceMap = false, mcVersionStr
             process.exit(1);
         }
     }
+    if (incremental) {
+        const cacheDir = path.join(path.dirname(file), '.redscript-cache');
+        const cache = new index_2.FileCache(cacheDir);
+        cache.load();
+        const depGraph = new deps_1.DependencyGraph();
+        const incResult = (0, incremental_1.compileIncremental)([file], cache, depGraph, {
+            namespace,
+            output,
+            generateSourceMap: sourceMap,
+            mcVersion,
+            lenient,
+            includeDirs,
+        });
+        if (incResult.errors.size > 0) {
+            const [failedFile, errorMessage] = incResult.errors.entries().next().value;
+            const source = fs.existsSync(failedFile) ? fs.readFileSync(failedFile, 'utf-8') : '';
+            console.error((0, diagnostics_1.formatError)(new Error(errorMessage), source, failedFile));
+            process.exit(1);
+        }
+        if (incResult.cached > 0) {
+            const entry = cache.get(path.resolve(file));
+            console.log(`✓ Reused cache for ${file}`);
+            console.log(`  Namespace: ${namespace}`);
+            console.log(`  Files: ${entry?.outputFiles?.length ?? 0}`);
+            return;
+        }
+        const compiled = incResult.results.get(path.resolve(file));
+        console.log(`✓ Compiled ${file} to ${output}/`);
+        console.log(`  Namespace: ${namespace}`);
+        console.log(`  Files: ${compiled?.files.length ?? 0}`);
+        return;
+    }
     const source = fs.readFileSync(file, 'utf-8');
     try {
         const result = (0, index_1.compile)(source, { namespace, filePath: file, generateSourceMap: sourceMap, mcVersion, lenient, includeDirs });
@@ -276,7 +438,54 @@ function compileCommand(file, output, namespace, sourceMap = false, mcVersionStr
         process.exit(1);
     }
 }
-function checkCommand(file, namespace) {
+function warningToDiagnostic(warning, defaultFile) {
+    const located = warning.match(/^\[([^\]]+)\]\s+(?:(.*?):)?line (\d+), col (\d+): (.+)$/);
+    if (located) {
+        return {
+            severity: 'warning',
+            kind: located[1],
+            file: located[2] || defaultFile,
+            line: Number(located[3]),
+            col: Number(located[4]),
+            message: located[5],
+        };
+    }
+    const simple = warning.match(/^\[([^\]]+)\]\s+(.+)$/);
+    if (simple) {
+        return {
+            severity: 'warning',
+            kind: simple[1],
+            message: simple[2],
+            file: defaultFile,
+        };
+    }
+    return {
+        severity: 'warning',
+        kind: 'Warning',
+        message: warning,
+        file: defaultFile,
+    };
+}
+function errorToDiagnostic(error) {
+    return {
+        severity: 'error',
+        kind: error.kind,
+        message: error.message,
+        file: error.location.file,
+        line: error.location.line,
+        col: error.location.col,
+    };
+}
+function formatWarningHuman(diagnostic) {
+    if (diagnostic.file && diagnostic.line && diagnostic.col) {
+        return `${diagnostic.file}:${diagnostic.line}:${diagnostic.col}: warning: [${diagnostic.kind}] ${diagnostic.message}`;
+    }
+    if (diagnostic.file) {
+        return `${diagnostic.file}: warning: [${diagnostic.kind}] ${diagnostic.message}`;
+    }
+    return `warning: [${diagnostic.kind}] ${diagnostic.message}`;
+}
+function checkCommand(file, namespace, outputFormat = 'human') {
     // Read source file
     if (!fs.existsSync(file)) {
         console.error(`Error: File not found: ${file}`);
@@ -284,15 +493,34 @@ function checkCommand(file, namespace) {
     }
     const source = fs.readFileSync(file, 'utf-8');
     const ns = namespace ?? deriveNamespace(file);
-    const result = (0, index_1.checkWithWarnings)(source, ns, file);
-    for (const w of result.warnings) {
-        console.error(`Warning: ${w}`);
+    const result = (0, index_1.checkDetailed)(source, ns, file);
+    const warnings = result.warnings.map(w => warningToDiagnostic(w, file));
+    const errors = result.errors.map(errorToDiagnostic);
+    const diagnostics = [...warnings, ...errors];
+    const exitCode = errors.length > 0 ? 2 : warnings.length > 0 ? 1 : 0;
+    if (outputFormat === 'json') {
+        console.log(JSON.stringify({
+            file,
+            namespace: ns,
+            diagnostics,
+            summary: {
+                warnings: warnings.length,
+                errors: errors.length,
+            },
+        }, null, 2));
     }
-    if (result.error) {
-        console.error((0, diagnostics_1.formatError)(result.error, source, file));
-        process.exit(1);
+    else {
+        for (const warning of warnings) {
+            console.error(formatWarningHuman(warning));
+        }
+        for (const error of result.errors) {
+            console.error((0, diagnostics_1.formatError)(error, source, file));
+        }
+        if (exitCode === 0) {
+            console.log('✓ No issues found');
+        }
     }
-    console.log(`✓ No errors found`);
+    process.exit(exitCode);
 }
 async function hotReload(url) {
     try {
@@ -342,6 +570,7 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
         const incResult = (0, incremental_1.compileIncremental)(files, cache, depGraph, {
             namespace,
             output,
+            includeDirs: undefined,
         });
         const timestamp = new Date().toLocaleTimeString();
         // Print warnings from recompiled files
@@ -395,6 +624,109 @@ function watchCommand(dir, output, namespace, hotReloadUrl) {
         }
     });
 }
+/**
+ * Map a McVersion enum value to the corresponding pack_format integer.
+ * https://minecraft.wiki/w/Pack_format
+ */
+function mcVersionToPackFormat(version) {
+    // Use a threshold-based mapping (≥ version → pack_format)
+    if (version >= mc_version_1.McVersion.v1_21_4)
+        return 48;
+    if (version >= mc_version_1.McVersion.v1_21)
+        return 45;
+    if (version >= mc_version_1.McVersion.v1_20_4)
+        return 26;
+    if (version >= mc_version_1.McVersion.v1_20_2)
+        return 22;
+    if (version >= mc_version_1.McVersion.v1_20)
+        return 18;
+    return 15; // 1.19 and below
+}
+/**
+ * Read redscript.config.json from the given directory (if it exists).
+ */
+function readConfig(dir) {
+    const configPath = path.join(dir, 'redscript.config.json');
+    if (fs.existsSync(configPath)) {
+        try {
+            return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            // ignore parse errors
+        }
+    }
+    return {};
+}
+/**
+ * publish command — compile then zip as a Minecraft datapack.
+ */
+async function publishCommand(file, outputZip, namespace, description, mcVersionStr, lenient = false, includeDirs) {
+    if (!fs.existsSync(file)) {
+        console.error(`Error: File not found: ${file}`);
+        process.exit(1);
+    }
+    let mcVersion = mc_version_1.DEFAULT_MC_VERSION;
+    if (mcVersionStr) {
+        try {
+            mcVersion = (0, mc_version_1.parseMcVersion)(mcVersionStr);
+        }
+        catch (e) {
+            console.error(`Error: ${e.message}`);
+            process.exit(1);
+        }
+    }
+    const source = fs.readFileSync(file, 'utf-8');
+    let compileResult;
+    try {
+        compileResult = (0, index_1.compile)(source, {
+            namespace,
+            filePath: file,
+            generateSourceMap: false,
+            mcVersion,
+            lenient,
+            includeDirs,
+        });
+    }
+    catch (err) {
+        console.error((0, diagnostics_1.formatError)(err, source, file));
+        process.exit(1);
+    }
+    for (const w of compileResult.warnings) {
+        console.error(`Warning: ${w}`);
+    }
+    const packFormat = mcVersionToPackFormat(mcVersion);
+    const mcmeta = JSON.stringify({
+        pack: {
+            pack_format: packFormat,
+            description,
+        }
+    }, null, 2);
+    // Ensure output directory exists
+    fs.mkdirSync(path.dirname(path.resolve(outputZip)), { recursive: true });
+    await new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(outputZip);
+        const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+        output.on('close', resolve);
+        archive.on('error', reject);
+        archive.pipe(output);
+        // Add pack.mcmeta at root
+        archive.append(mcmeta, { name: 'pack.mcmeta' });
+        // Add compiled files — skip pack.mcmeta from compile result (we generate our own)
+        // The compile result already produces correct datapack paths, e.g.:
+        //   data/<namespace>/function/setup.mcfunction
+        //   data/minecraft/tags/function/load.json
+        for (const dataFile of compileResult.files) {
+            if (dataFile.path === 'pack.mcmeta')
+                continue;
+            archive.append(dataFile.content, { name: dataFile.path });
+        }
+        void archive.finalize();
+    });
+    console.log(`✓ Published ${file} → ${outputZip}`);
+    console.log(`  Namespace:   ${namespace}`);
+    console.log(`  pack_format: ${packFormat}`);
+    console.log(`  Files:       ${compileResult.files.length}`);
+}
 // Main
 const parsed = parseArgs(args);
 async function main() {
@@ -405,7 +737,7 @@ async function main() {
     // Background update check — non-blocking, only shows notice if newer version exists
     // Skip for repl/upgrade/version to avoid double-printing
     const noCheckCmds = new Set(['upgrade', 'update', 'version', 'repl']);
-    if (!noCheckCmds.has(parsed.command ?? '')) {
+    if (!process.env.REDSCRIPT_NO_UPDATE_CHECK && !noCheckCmds.has(parsed.command ?? '')) {
         checkForUpdates().catch(() => { });
     }
     switch (parsed.command) {
@@ -416,11 +748,55 @@ async function main() {
                 process.exit(1);
             }
             {
-                const namespace = parsed.namespace ?? deriveNamespace(parsed.file);
-                const output = parsed.output ?? './dist';
-                compileCommand(parsed.file, output, namespace, parsed.sourceMap, parsed.mcVersionStr, parsed.lenient, parsed.includeDirs);
+                // Load redscript.toml (walk up from file's directory); CLI args take priority
+                const fileDir = path.dirname(path.resolve(parsed.file));
+                const tomlConfig = (0, project_config_1.loadProjectConfig)(fileDir);
+                const namespace = parsed.namespace
+                    ?? tomlConfig?.project?.namespace
+                    ?? deriveNamespace(parsed.file);
+                const output = parsed.output
+                    ?? tomlConfig?.output?.dir
+                    ?? './dist';
+                const mcVersionStr = parsed.mcVersionStr ?? tomlConfig?.project?.['mc-version'];
+                const includeDirs = parsed.includeDirs
+                    ?? tomlConfig?.compiler?.['include-dirs'];
+                compileCommand(parsed.file, output, namespace, parsed.sourceMap, mcVersionStr, parsed.lenient, includeDirs, parsed.incremental);
             }
             break;
+        case 'publish': {
+            if (!parsed.file) {
+                console.error('Error: No input file specified');
+                printUsage();
+                process.exit(1);
+            }
+            {
+                // Determine project directory
+                const fileDir = path.dirname(path.resolve(parsed.file));
+                // Load redscript.toml first, fall back to legacy redscript.config.json
+                const tomlConfig = (0, project_config_1.loadProjectConfig)(fileDir);
+                const legacyConfig = readConfig(fileDir);
+                const namespace = parsed.namespace
+                    ?? tomlConfig?.project?.namespace
+                    ?? legacyConfig.namespace
+                    ?? deriveNamespace(parsed.file);
+                const description = parsed.description
+                    ?? tomlConfig?.project?.description
+                    ?? legacyConfig.description
+                    ?? `${namespace} datapack`;
+                const mcVersionStr = parsed.mcVersionStr
+                    ?? tomlConfig?.project?.['mc-version']
+                    ?? legacyConfig.mcVersion;
+                const includeDirs = parsed.includeDirs
+                    ?? tomlConfig?.compiler?.['include-dirs'];
+                // Default output: <namespace>.zip in cwd
+                const defaultZip = path.join(process.cwd(), `${namespace}.zip`);
+                const outputZip = parsed.output ?? tomlConfig?.output?.dir
+                    ? path.join(tomlConfig.output.dir, `${namespace}.zip`)
+                    : defaultZip;
+                await publishCommand(parsed.file, outputZip, namespace, description, mcVersionStr, parsed.lenient, includeDirs);
+            }
+            break;
+        }
         case 'watch':
             if (!parsed.file) {
                 console.error('Error: No directory specified');
@@ -429,13 +805,65 @@ async function main() {
             }
             watchCommand(parsed.file, parsed.output ?? './dist', parsed.namespace, parsed.hotReload);
             break;
+        case 'test': {
+            if (!parsed.file) {
+                console.error('Error: No input file specified\nUsage: redscript test <file> [--dry-run] [--mc-url <url>]');
+                process.exit(1);
+            }
+            {
+                const { runTests } = require('./testing/runner');
+                const namespace = parsed.namespace ?? deriveNamespace(parsed.file);
+                await runTests({
+                    filePath: parsed.file,
+                    outputDir: parsed.output,
+                    dryRun: parsed.dryRun ?? !parsed.mcUrl,
+                    mcUrl: parsed.mcUrl,
+                    namespace,
+                });
+            }
+            break;
+        }
         case 'check':
             if (!parsed.file) {
                 console.error('Error: No input file specified');
                 printUsage();
                 process.exit(1);
             }
-            checkCommand(parsed.file, parsed.namespace);
+            {
+                const fileDir = path.dirname(path.resolve(parsed.file));
+                const tomlConfig = (0, project_config_1.loadProjectConfig)(fileDir);
+                const namespace = parsed.namespace ?? tomlConfig?.project?.namespace;
+                checkCommand(parsed.file, namespace, parsed.format ?? 'human');
+            }
+            break;
+        case 'lint':
+            if (!parsed.file) {
+                console.error('Error: No input file specified');
+                printUsage();
+                process.exit(1);
+            }
+            {
+                const namespace = parsed.namespace ?? deriveNamespace(parsed.file);
+                try {
+                    const warnings = (0, index_3.lintFile)(parsed.file, namespace, {
+                        maxFunctionLines: parsed.maxFunctionLines,
+                    });
+                    for (const w of warnings) {
+                        console.log((0, index_3.formatLintWarning)(w));
+                    }
+                    if (warnings.length === 0) {
+                        console.log('✓ No lint issues found');
+                    }
+                    else {
+                        console.log(`\n${warnings.length} lint issue(s) found`);
+                    }
+                    process.exit(warnings.length > 0 ? 1 : 0);
+                }
+                catch (err) {
+                    console.error(`Error: ${err.message}`);
+                    process.exit(2);
+                }
+            }
             break;
         case 'fmt':
         case 'format': {
@@ -445,11 +873,29 @@ async function main() {
                 process.exit(1);
             }
             const { format } = require('./formatter');
+            let changed = 0;
             for (const file of files) {
                 const content = fs.readFileSync(file, 'utf8');
                 const formatted = format(content);
-                fs.writeFileSync(file, formatted);
-                console.log(`Formatted: ${file}`);
+                if (content !== formatted) {
+                    changed++;
+                    if (!parsed.fmtCheck) {
+                        fs.writeFileSync(file, formatted);
+                        console.log(`Formatted: ${file}`);
+                    }
+                    else {
+                        console.log(`Would format: ${file}`);
+                    }
+                }
+                else if (!parsed.fmtCheck) {
+                    console.log(`Already formatted: ${file}`);
+                }
+            }
+            if (parsed.fmtCheck) {
+                if (changed > 0) {
+                    process.exit(1);
+                }
+                console.log('All files are formatted');
             }
             break;
         }
@@ -460,6 +906,9 @@ async function main() {
             console.log(`Generated ${output}`);
             break;
         }
+        case 'init':
+            initCommand(parsed.file);
+            break;
         case 'repl':
             await (0, repl_1.startRepl)(parsed.namespace ?? 'repl');
             break;

package/dist/src/config/project-config.d.ts

@@ -0,0 +1,29 @@
+/**
+ * redscript.toml project configuration file support.
+ *
+ * Provides ProjectConfig interface and loadProjectConfig() which walks up the
+ * directory tree to find the nearest redscript.toml file.
+ */
+export interface ProjectConfig {
+    project?: {
+        name?: string;
+        namespace?: string;
+        'mc-version'?: string;
+        description?: string;
+    };
+    compiler?: {
+        optimization?: number;
+        'include-dirs'?: string[];
+        'no-dce'?: boolean;
+    };
+    output?: {
+        dir?: string;
+    };
+}
+/**
+ * Walk up the directory tree starting at `startDir` to find the nearest
+ * `redscript.toml`.  Returns a parsed ProjectConfig or null if not found.
+ */
+export declare function loadProjectConfig(startDir: string): ProjectConfig | null;
+/** Default template content for a new redscript.toml file. */
+export declare function buildTomlTemplate(namespace: string): string;