sandstone-cli 0.6.5 → 1.0.0

package/lib/commands/create.js

@@ -1,19 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@oclif/command");
-const chalk_1 = __importDefault(require("chalk"));
-const child_process_1 = require("child_process");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const inquirer_1 = __importDefault(require("inquirer"));
-const path_1 = __importDefault(require("path"));
-const util_1 = __importDefault(require("util"));
-const utils_1 = require("../utils");
-const nanoid_1 = require("nanoid");
+import { SemVer } from 'semver';
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import util from 'util';
+import * as child from 'child_process';
+import { nanoid } from 'nanoid';
+import { capitalize, getWorldsList, hasPnpm, hasYarn } from '../utils.js';
 function toJson(obj, pretty = false) {
-    return util_1.default.inspect(obj, {
+    return util.inspect(obj, {
         depth: Number(Infinity),
         colors: false,
         breakLength: Number(Infinity),
@@ -21,165 +15,156 @@ function toJson(obj, pretty = false) {
         maxArrayLength: Number(Infinity),
     });
 }
-class Create extends command_1.Command {
-    async run() {
-        const { args, flags } = this.parse(Create);
-        const projectPath = path_1.default.resolve(args['project-name']);
-        const projectName = path_1.default.basename(projectPath);
-        const projectType = Boolean(await (0, utils_1.getFlagOrPrompt)(flags, 'library', {
-            message: 'Whether your project will be a library for use in other Sandstone projects >',
+export async function createCommand(_project, opts) {
+    const projectPath = path.resolve(_project);
+    const projectName = path.basename(projectPath);
+    const inquirer = (await import("inquirer")).default;
+    const projectType = Boolean((await inquirer.prompt({
+        name: 'projectType',
+        message: 'Whether your project will be a library for use in other Sandstone projects >',
+        type: 'confirm',
+        default: false,
+    })).projectType) === true ? 'library' : 'pack';
+    const sv = (v) => new SemVer(v);
+    const versions = [[sv('0.13.6'), sv('0.5.4')], [sv('0.14.0-alpha.13'), sv('0.5.4')], [sv('1.0.0-alpha.1'), sv('1.0.0')]];
+    const stableIndex = 0;
+    const { version } = await inquirer.prompt({
+        name: 'version',
+        type: 'list',
+        message: 'Which version of Sandstone do you want to use? These are the only supported versions for new projects.',
+        choices: versions.map((v) => {
+            const { prerelease, major, minor } = v[0];
+            const release = `${major}.${minor}`;
+            return {
+                name: prerelease.length === 0 ?
+                    `Release Version ${release}` :
+                    `${capitalize(prerelease[0])} Version ${prerelease[1]} for release ${release}`,
+                value: v,
+                short: v[0].toString(),
+            };
+        }),
+        default: stableIndex,
+    });
+    let packName = projectName;
+    let namespace = projectName.replace(RegExp(/ /g), '_');
+    if (projectType === 'pack') {
+        packName = (await inquirer.prompt({
+            name: 'projectType',
+            message: 'Name of your output pack(s) (can be changed later) >',
+            default: projectName,
             type: 'input',
-            default: false,
-        })) === true ? 'library' : 'pack';
-        const versions = [['0.13.6', '0.5.4'], ['0.14.0-alpha.13', '0.5.4'], ['0.14.0-alpha.20', '0.6.5']];
-        const stableIndex = 0;
-        const { sandstoneVersion } = await inquirer_1.default.prompt({
-            name: 'sandstoneVersion',
-            type: 'list',
-            message: 'Which version of Sandstone do you want to use? These are the only supported versions for new projects.',
-            choices: versions.map((version) => ({
-                name: version[0].includes('alpha') ? `Alpha Version ${version[0].split('.')[3]} for release ${version[0].split('.')[1]}` : `Major Version 0.${version[0].split('.')[1]}`,
-                value: version,
-                short: version[0],
-            })),
-            default: stableIndex,
-        });
-        let packName = '';
-        let namespace = '';
-        if (projectType === 'pack') {
-            packName = await (0, utils_1.getFlagOrPrompt)(flags, 'pack-name', {
-                message: 'Name of your output pack(s) (can be changed later) >',
-                type: 'input',
-                default: projectName,
-            });
-            namespace = await (0, utils_1.getFlagOrPrompt)(flags, 'namespace', {
-                message: 'Default namespace (can be changed later) >',
-                default: 'default',
-            });
+        })).projectType;
+        namespace = (await inquirer.prompt({
+            name: 'namespace',
+            message: 'Default namespace (can be changed later) >',
+            default: namespace,
+            type: 'input',
+        })).namespace;
+    }
+    else {
+        packName += '-testing';
+        namespace += '_test';
+    }
+    // Find the save directory
+    const saveOptions = {};
+    if (version[0].major === 1) {
+        if (opts.root) {
+            saveOptions.root = true;
+        }
+        else if (opts.world) {
+            saveOptions.world = opts.world;
         }
-        // Find the save directory
-        const saveOptions = {};
-        if (sandstoneVersion[0].includes('alpha') && Number(sandstoneVersion[0].split('.')[3]) >= 19) {
-            if (flags['save-root']) {
+        else if (opts.serverPath) {
+            saveOptions.serverPath = opts.serverPath;
+        }
+        else { // TODO: Add support for ssh
+            // User didn't specify a way to save the file. Ask them.
+            const { saveChoice } = await inquirer.prompt({
+                name: 'saveChoice',
+                type: 'list',
+                message: 'Where do you want your pack(s) to be saved (can be changed later)?',
+                choices: [{
+                        name: 'In the root client (.minecraft) folder',
+                        value: 'root',
+                        short: 'Client folder',
+                    }, {
+                        name: 'In a world',
+                        value: 'world',
+                        short: 'World',
+                    }, {
+                        name: 'In a server',
+                        value: 'server-path',
+                        short: 'Server path',
+                    }],
+            });
+            if (saveChoice === 'root') {
                 saveOptions.root = true;
             }
-            else if (flags.world) {
-                saveOptions.world = flags.world;
-            }
-            else if (flags['server-path']) {
-                saveOptions.serverPath = flags['server-path'];
-            }
-            else { // TODO: Add support for ssh
-                // User didn't specify a way to save the file. Ask them.
-                const { saveChoice } = await inquirer_1.default.prompt({
-                    name: 'saveChoice',
+            else if (saveChoice === 'world') {
+                const { world } = await inquirer.prompt({
+                    name: 'World',
+                    message: 'What world do you want to save the packs in? >',
                     type: 'list',
-                    message: 'Where do you want your pack(s) to be saved (can be changed later)?',
-                    choices: [{
-                            name: 'In the root client (.minecraft) folder',
-                            value: 'root',
-                            short: 'Client folder',
-                        }, {
-                            name: 'In a world',
-                            value: 'world',
-                            short: 'World',
-                        }, {
-                            name: 'In a server',
-                            value: 'server-path',
-                            short: 'Server path',
-                        }],
+                    choices: getWorldsList,
                 });
-                if (saveChoice === 'root') {
-                    saveOptions.root = true;
-                }
-                else if (saveChoice === 'world') {
-                    const { world } = await inquirer_1.default.prompt({
-                        name: 'World',
-                        message: 'What world do you want to save the packs in? >',
-                        type: 'list',
-                        choices: utils_1.getWorldsList,
-                    });
-                    saveOptions.world = world;
-                }
-                else { // TODO: Add native folder selector
-                    const { serverPath } = await inquirer_1.default.prompt({
-                        name: 'Server path',
-                        message: 'Where is the server to save the packs in? Relative paths are accepted. >',
-                        type: 'input',
-                    });
-                    saveOptions.serverPath = serverPath;
-                }
+                saveOptions.world = world;
             }
-            if (flags['client-path']) {
-                saveOptions.clientPath = flags['client-path'];
+            else { // TODO: Add native folder selector
+                const { serverPath } = await inquirer.prompt({
+                    name: 'Server path',
+                    message: 'Where is the server to save the packs in? Relative paths are accepted. >',
+                    type: 'input',
+                });
+                saveOptions.serverPath = serverPath;
             }
         }
-        let useYarn = flags.yarn;
-        if (!flags.yarn && !flags.npm && (0, utils_1.hasYarn)()) {
-            useYarn = (await inquirer_1.default.prompt({
-                name: 'useYarn',
-                message: 'What package manager do you want to use? >',
-                type: 'list',
-                choices: ['npm', 'yarn'],
-            })).useYarn === 'yarn';
-        }
-        fs_extra_1.default.mkdirSync(projectPath);
-        // Create project & install dependencies
-        this.log((0, chalk_1.default) `Installing {rgb(229,193,0) sandstone@${sandstoneVersion[0]}}, {rgb(229,193,0) sandstone-cli@${sandstoneVersion[1]}} and {cyan typescript} using {cyan ${useYarn ? 'yarn' : 'npm'}}.`);
-        const exec = (cmd) => (0, child_process_1.execSync)(cmd, { cwd: projectPath });
-        exec('git clone https://github.com/sandstone-mc/sandstone-template.git .');
-        exec(`git checkout ${projectType}-${sandstoneVersion[0]}`);
-        exec('npx rimraf -rf .git');
-        exec(`${useYarn ? 'yarn' : 'npm'} install`);
-        // TODO: Make profiles for either packs or libraries
-        const configPath = path_1.default.join(projectPath, `${projectType === 'library' ? 'test/' : ''}sandstone.config.ts`);
-        // Merge with the config values
-        let templateConfig = await fs_extra_1.default.readFile(configPath, 'utf8');
-        templateConfig = templateConfig.replace('packUid: \'kZZpDK67\'', `packUid: ${toJson((0, nanoid_1.nanoid)(8))}`);
-        let _name = packName;
-        let _namespace = namespace;
-        if (projectType === 'library') {
-            _name += '-testing';
-            _namespace += '_test';
-        }
-        templateConfig = templateConfig.replace('name: \'template\'', `name: ${toJson(_name)}`);
-        templateConfig = templateConfig.replace('namespace: \'default\'', `namespace: ${toJson(_namespace)}`);
-        // TODO: packFormat
-        const opts = toJson(Object.fromEntries(Object.entries(saveOptions).filter(([_, value]) => value !== undefined)));
-        if (opts !== '{}') {
-            templateConfig = templateConfig.replace('saveOptions: {}', `saveOptions: ${opts}`);
+        if (opts.clientPath) {
+            saveOptions.clientPath = opts.clientPath;
         }
-        // Rewrite config
-        fs_extra_1.default.writeFileSync(configPath, templateConfig);
-        const prefix = useYarn ? 'yarn' : 'npm run';
-        this.log((0, chalk_1.default) `{green Success!} Created "${projectName}" at "${projectPath}"`);
-        this.log('Inside that directory, you can run several commands:\n');
-        this.log((0, chalk_1.default) `  {cyan ${prefix} build}:\n    Builds the packs. {cyan ⛏}\n`);
-        this.log((0, chalk_1.default) `  {cyan ${prefix} watch}:\n    Builds the packs, and rebuilds on each file change. {cyan ⛏}\n`);
-        this.log('We suggest that you begin by typing:\n');
-        this.log((0, chalk_1.default) `  {cyan cd} ${projectName}\n  {cyan ${prefix} watch}`);
     }
+    let packageManager = 'npm';
+    const yarn = hasYarn();
+    const pnpm = hasPnpm();
+    if (yarn || pnpm) {
+        const choices = ['npm'];
+        if (yarn)
+            choices.unshift('yarn');
+        if (pnpm)
+            choices.unshift('pnpm');
+        packageManager = (await inquirer.prompt({
+            name: 'packageManager',
+            message: 'What package manager do you want to use? >',
+            type: 'list',
+            choices: choices,
+        })).packageManager;
+    }
+    fs.mkdirSync(projectPath);
+    // Create project & install dependencies
+    console.log(chalk `Installing {rgb(229,193,0) sandstone@${version[0]}}, {rgb(229,193,0) sandstone-cli@${version[1]}} and {cyan typescript} using {cyan ${packageManager}}.`);
+    const exec = (cmd) => child.execSync(cmd, { cwd: projectPath });
+    exec('git clone https://github.com/sandstone-mc/sandstone-template.git .');
+    exec(`git checkout ${projectType}-${version[0]}`);
+    exec('npx rimraf -rf .git');
+    exec(`${packageManager} install`);
+    // TODO: Make profiles for either packs or libraries
+    const configPath = path.join(projectPath, `${projectType === 'library' ? 'test/' : ''}sandstone.config.ts`);
+    // Merge with the config values
+    let templateConfig = await fs.readFile(configPath, 'utf8');
+    templateConfig = templateConfig.replace('packUid: \'kZZpDK67\'', `packUid: ${toJson(nanoid(8))}`);
+    templateConfig = templateConfig.replace('name: \'template\'', `name: ${toJson(packName)}`);
+    templateConfig = templateConfig.replace('namespace: \'default\'', `namespace: ${toJson(namespace)}`);
+    // TODO: packFormat
+    const optsJson = toJson(Object.fromEntries(Object.entries(saveOptions).filter(([_, value]) => value !== undefined)));
+    if (optsJson !== '{}') {
+        templateConfig = templateConfig.replace('saveOptions: {}', `saveOptions: ${optsJson}`);
+    }
+    // Rewrite config
+    fs.writeFileSync(configPath, templateConfig);
+    const prefix = packageManager === 'npm' ? 'npm run' : packageManager;
+    console.log(chalk `{green Success!} Created "${projectName}" at "${projectPath}"`);
+    console.log('Inside that directory, you can run several commands:\n');
+    console.log(chalk `  {cyan ${prefix} build}:\n    Builds the packs. {cyan ⛏}\n`);
+    console.log(chalk `  {cyan ${prefix} watch}:\n    Builds the packs, and rebuilds on each file change. {cyan ⛏}\n`);
+    console.log('We suggest that you begin by typing:\n');
+    console.log(chalk `  {cyan cd} ${projectName}\n  {cyan ${prefix} watch}`);
 }
-exports.default = Create;
-Create.description = 'Create a new Sandstone project.';
-Create.examples = [
-    '$ sand create my-pack',
-];
-Create.flags = {
-    help: command_1.flags.help({ char: 'h' }),
-    yarn: command_1.flags.boolean({ description: 'Use yarn instead of npm.', env: 'USE_YARN', exclusive: ['npm'] }),
-    npm: command_1.flags.boolean({ description: 'Use npm.', env: 'USE_NPM', exclusive: ['yarn'] }),
-    library: command_1.flags.boolean({ char: 't', env: 'LIBRARY', description: 'Whether the project will be a library for use in other Sandstone projects.' }),
-    version: command_1.flags.string({ char: 'v', env: 'SANDSTONE_VERSION', description: 'What version of Sandstone you\'d like to create a project for.' }),
-    'pack-name': command_1.flags.string({ char: 'd', env: 'PACK_NAME', description: 'The name of the pack(s).' }),
-    namespace: command_1.flags.string({ char: 'n', env: 'NAMESPACE', description: 'The default namespace that will be used.' }),
-    'save-root': command_1.flags.boolean({ char: 'r', env: 'SAVE_ROOT', description: 'Save the datapack & resource pack in the .minecraft/datapacks & .minecraft/resource_packs folders. Not compatible with --world.', exclusive: ['world'] }),
-    world: command_1.flags.string({ char: 'w', env: 'WORLD', description: 'The world to save the packs in. Not compatible with --save-root or --server', exclusive: ['save-root', 'server'] }),
-    'server-path': command_1.flags.string({ char: 's', env: 'SERVER_PATH', description: 'The server path to write the server-side packs at. Not compatible with --world.', exclusive: ['world'] }),
-    'client-path': command_1.flags.string({ char: 'c', env: 'CLIENT_PATH', description: 'The client path to write packs at.' }),
-};
-Create.args = [{
-        name: 'project-name',
-        description: 'Name of the project folder. This is not the name of the output pack(s).',
-        required: true,
-    }];

package/lib/commands/index.d.ts

@@ -0,0 +1,3 @@
+export { buildCommand } from './build.js';
+export { createCommand } from './create.js';
+export { watchCommand } from './watch.js';

package/lib/commands/index.js

@@ -0,0 +1,4 @@
+export { buildCommand } from './build.js';
+export { createCommand } from './create.js';
+//export { updateCommand } from './update.js';
+export { watchCommand } from './watch.js';

package/lib/commands/watch.d.ts

@@ -1,29 +1,16 @@
-import { Command, flags } from '@oclif/command';
-export default class Watch extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
-        dry: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        verbose: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        namespace: flags.IOptionFlag<string | undefined>;
-        world: flags.IOptionFlag<string | undefined>;
-        root: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        clientPath: flags.IOptionFlag<string | undefined>;
-        serverPath: flags.IOptionFlag<string | undefined>;
-        name: flags.IOptionFlag<string | undefined>;
-        description: flags.IOptionFlag<string | undefined>;
-        formatVersion: import("@oclif/parser/lib/flags").IOptionFlag<number | undefined>;
-        fullTrace: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        strictErrors: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        production: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        autoReload: import("@oclif/parser/lib/flags").IOptionFlag<number | undefined>;
-    };
-    static args: {
-        name: string;
-        description: string;
-        required: boolean;
-        default: string;
-    }[];
-    run(): Promise<void>;
-}
+type WatchOptions = {
+    dry?: boolean;
+    verbose?: boolean;
+    root?: boolean;
+    fullTrace?: boolean;
+    strictErrors?: boolean;
+    path: string;
+    configPath: string;
+    name?: string;
+    namespace?: string;
+    world?: string;
+    clientPath?: string;
+    serverPath?: string;
+};
+export declare function watchCommand(opts: WatchOptions): Promise<void>;
+export {};

package/lib/commands/watch.js

@@ -1,110 +1,65 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@oclif/command");
-const chokidar_1 = __importDefault(require("chokidar"));
-const buildProject_1 = require("../build/buildProject");
-const path_1 = __importDefault(require("path"));
-const utils_1 = require("../utils");
-const chalk_1 = __importDefault(require("chalk"));
-class Watch extends command_1.Command {
-    async run() {
-        const { args, flags } = this.parse(Watch);
-        let alreadyBuilding = false;
-        let needRebuild = false;
-        let client = null;
-        // TODO: add support for clients & resources that require restarts & world resets, sandstone-server should override the involved environment variables if mods are present that fix it
-        if (flags.autoReload !== undefined) {
-            try {
-                client = (await require('minecraft-protocol')).createClient({
-                    username: 'SandstoneBot',
-                    host: 'localhost',
-                    port: flags.autoReload,
-                });
-            }
-            catch (e) {
-                console.log(chalk_1.default.rgb(255, 204, 0) `Failed to connect to localhost:${flags.autoReload}. The datapack won't be auto reloaded.`);
-            }
+import { register as tsEval } from 'ts-node';
+import chokidar from 'chokidar';
+import path from 'path';
+import { buildProject } from '../build/index.js';
+import { getProjectFolders } from '../utils.js';
+export async function watchCommand(opts) {
+    let alreadyBuilding = false;
+    let needRebuild = false;
+    // let client: Client | null = null
+    // TODO: add support for clients & resources that require restarts & world resets, sandstone-server should override the involved environment variables if mods are present that fix it
+    /*if (flags.autoReload !== undefined) {
+      try {
+        client = (await require('minecraft-protocol')).createClient({
+          username: 'SandstoneBot',
+          host: 'localhost',
+          port: flags.autoReload,
+        })
+      } catch (e) {
+        console.log(chalk.rgb(255, 204, 0)`Failed to connect to localhost:${flags.autoReload}. The datapack won't be auto reloaded.`)
+      }
+    }*/
+    const folders = getProjectFolders(opts.path);
+    async function onFilesChange() {
+        if (alreadyBuilding) {
+            // If the pack is already being built & another change was made,
+            // notify that a rebuild is needed & stop there
+            needRebuild = true;
+            return;
         }
-        const folders = (0, utils_1.getProjectFolders)(args.path);
-        async function onFilesChange(paths) {
-            if (alreadyBuilding) {
-                // If the pack is already being built & another change was made,
-                // notify that a rebuild is needed & stop there
-                needRebuild = true;
-                return;
-            }
-            alreadyBuilding = true;
-            await (0, buildProject_1.buildProject)(flags, folders, paths);
-            client === null || client === void 0 ? void 0 : client.write('chat', { message: '/reload' });
-            alreadyBuilding = false;
-            if (needRebuild) {
-                needRebuild = false;
-                await onFilesChange(paths);
-            }
+        alreadyBuilding = true;
+        await buildProject(opts, folders);
+        //client?.write('chat', { message: '/reload' })
+        alreadyBuilding = false;
+        if (needRebuild) {
+            needRebuild = false;
+            await onFilesChange();
         }
-        // Register ts-node
-        const tsConfigPath = path_1.default.join(folders.rootFolder, 'tsconfig.json');
-        require('ts-node').register({
-            transpileOnly: !flags.strictErrors,
-            project: tsConfigPath,
-        });
-        let timeout = null;
-        let files = [];
-        chokidar_1.default.watch([
-            path_1.default.join(folders.absProjectFolder, '/**/*'),
-            path_1.default.join(folders.sandstoneConfigFolder, 'sandstone.config.ts'),
-            path_1.default.join(folders.rootFolder, 'package.json'),
-            path_1.default.join(folders.rootFolder, 'tsconfig.json'),
-        ]).on('all', (event, path) => {
-            if (event === 'addDir') {
-                return;
-            }
-            files.push(path);
-            if (timeout)
-                clearTimeout(timeout);
-            timeout = setTimeout(() => {
-                onFilesChange(files.length === 0 ? undefined : files);
-                files = [];
-            }, 200);
-        });
     }
+    // Register ts-node
+    const tsConfigPath = path.join(folders.rootFolder, 'tsconfig.json');
+    tsEval({
+        transpileOnly: !opts.strictErrors,
+        project: tsConfigPath,
+    });
+    let timeout = null;
+    let files = [];
+    chokidar.watch([
+        path.join(folders.absProjectFolder, '/**/*'),
+        path.join(folders.sandstoneConfigFolder, 'sandstone.config.ts'),
+        path.join(folders.rootFolder, 'package.json'),
+        path.join(folders.rootFolder, 'tsconfig.json'),
+        /* @ts-ignore */
+    ]).on('all', (event, path) => {
+        if (event === 'addDir') {
+            return;
+        }
+        files.push(path);
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            onFilesChange();
+            files = [];
+        }, 200);
+    });
 }
-exports.default = Watch;
-Watch.description = 'Build the packs, and rebuild them on file change. ⛏';
-Watch.examples = [
-    '$ sand watch',
-    '$ sand watch --verbose',
-    '$ sand watch --verbose --dry',
-];
-Watch.flags = {
-    help: command_1.flags.help({ char: 'h' }),
-    dry: command_1.flags.boolean({ char: 'd', description: 'Do not save the pack. Mostly useful with `verbose`.' }),
-    verbose: command_1.flags.boolean({ char: 'v', description: 'Log all resulting resources: functions, advancements...' }),
-    namespace: command_1.flags.string({ description: 'The default namespace. Override the value specified in the configuration file.' }),
-    world: command_1.flags.string({ description: 'The world to save the datapack in. Override the value specified in the configuration file.' }),
-    root: command_1.flags.boolean({ description: 'Save the datapack & resource pack in the .minecraft/datapacks & .minecraft/resource_packs folders. Override the value specified in the configuration file.' }),
-    clientPath: command_1.flags.string({ name: 'client-path', description: 'Path of the client folder. Override the value specified in the configuration file.' }),
-    serverPath: command_1.flags.string({ name: 'server-path', description: 'Path of the server folder. Override the value specified in the configuration file.' }),
-    // TODO: ssh
-    name: command_1.flags.string({ description: 'Name of the datapack. Override the value specified in the configuration file.' }),
-    description: command_1.flags.string({ description: 'Description of the datapack. Override the value specified in the configuration file.' }),
-    formatVersion: command_1.flags.integer({ name: 'format', description: 'Pack format version. Override the value specified in the configuration file.' }),
-    fullTrace: command_1.flags.boolean({ name: 'full-trace', description: 'Show the full stack trace on errors.' }),
-    strictErrors: command_1.flags.boolean({ description: 'Stop datapack compilation on type errors.', default: false }),
-    production: command_1.flags.boolean({ char: 'p', description: 'Runs Sandstone in production mode. This sets process.env.SANDSTONE_ENV to "production".', default: false }),
-    autoReload: command_1.flags.integer({ description: 'Automatically reload your datapack in-game. Requires to open the world to LAN with cheats enabled, and to specify the port.', helpValue: 'port' }),
-};
-Watch.args = [{
-        name: 'path',
-        description: 'Path of the folder containing source files.',
-        required: true,
-        default: './src',
-    }, {
-        name: 'config-path',
-        description: 'Path of the sandstone.config.ts folder.',
-        required: true,
-        default: '.',
-    }];

package/lib/index.d.ts

@@ -1 +1,2 @@
-export { run } from '@oclif/command';
+#!/usr/bin/env node
+export {};