amxxpack 0.1.4 → 1.0.0

package/README.md

@@ -27,32 +27,37 @@ npm install -g amxxpack
 ```
 
 ## ▶ Quick start
-- Create new directory for your project
-- Open a terminal inside the project directory
-- Execute `npm init -y` command to init the package
+- Open a terminal inside the project directory (existing or create a new one)
 - Execute `npm install amxxpack --save-dev` command to install `amxxpack` locally
-- Execute `npx amxxpack init` command to create new config
-- Execute `npx amxxpack fetch-compiler` to download latest compiler release
-- Use `npx amxxpack build` command to build the project
-- Adding build scripts *(optional)*
-
-  To use `npm run build` and `npm run watch` to build or watch the project update the `scripts` section in `package.json`:
-  ```json
-    "scripts": {
-      "build": "amxxpack build",
-      "watch": "amxxpack build --watch"
-    }
-  ```
+- Execute `npx amxxpack create .` command to create new config
+- Execute `npx amxxpack install` to download project dependencies (compiler, thirdparty etc.)
+- Use `npm run build` command to build the project
+- Use `npm run watch` command to build the project and watch changes
 
 ## 📋 Commands
-- `amxxpack init` - init config for a new project
+- `amxxpack create <name>` - create new project
+  - `--git` - initialize git
+  - `--nonpm` - don't initialize npm pacakge 
+  - `--version` - project version
+  - `--author` - project author
+  - `--description` - project name
+- `amxxpack config` - initialize project config in current workspace
+- `amxxpack install` - install project dependencies
+  - `--config` - config file
 - `amxxpack build` - command to build the project
   - `--watch` - flag to watch changes
   - `--config` - config file
 - `amxxpack compile <path|glob>` - compile specific plugin in the project
   - `--config` - config file
-- `amxxpack fetch-compiler` - fetch amxmodx compiler
+- `amxxpack new <script|lib|include> [name]` - create new file in the project workspace
   - `--config` - config file
-  - `--version` - compiler version
-  - `--addon` - addon name
-  - `--dev` - search for dev build
+  - `--name` - plugin name
+  - `--version` - plugin version
+  - `--author` - plugin author
+  - `--lib` - library name
+  - `--include` - include list separated by a comma
+  - `--overwrite` - overwrite file if it already exists
+- `amxpack i` - alias to `install` command
+- `amxpack n` - alias to `new` command
+- `amxpack b` - alias to `build` command
+- `amxpack c` - alias to `compile` command

package/lib/builder/builder.d.ts

@@ -1,8 +1,7 @@
-import { IAmxxBuilderConfig } from './types';
+import { IProjectConfig } from '../types';
 export default class AmxxBuilder {
-    private logger;
     private config;
-    constructor(config: IAmxxBuilderConfig);
+    constructor(config: IProjectConfig);
     build(): Promise<void>;
     watch(): Promise<void>;
     buildSrc(): Promise<void>;

package/lib/builder/builder.js

@@ -73,41 +73,19 @@ var mkdirp_1 = __importDefault(require("mkdirp"));
 var glob_promise_1 = __importDefault(require("glob-promise"));
 var chokidar_1 = __importDefault(require("chokidar"));
 var normalize_path_1 = __importDefault(require("normalize-path"));
-var lodash_1 = require("lodash");
 var amxxpc_1 = __importStar(require("./amxxpc"));
-var logger_1 = __importDefault(require("../services/logger"));
 var constants_1 = require("./constants");
+var logger_1 = __importDefault(require("../logger/logger"));
 var AmxxBuilder = /** @class */ (function () {
     function AmxxBuilder(config) {
-        var compiler = config.compiler, input = config.input, output = config.output, rules = config.rules;
-        this.logger = new logger_1.default();
-        this.config = {
-            compiler: {
-                executable: path_1.default.resolve(compiler.executable),
-                include: compiler.include.map(function (include) { return path_1.default.resolve(include); })
-            },
-            input: {
-                scripts: path_1.default.resolve(input.scripts),
-                include: path_1.default.resolve(input.include),
-                assets: path_1.default.resolve(input.assets),
-            },
-            output: {
-                scripts: path_1.default.resolve(output.scripts),
-                plugins: path_1.default.resolve(output.plugins),
-                include: path_1.default.resolve(output.include),
-                assets: path_1.default.resolve(output.assets)
-            },
-            rules: {
-                flatCompilation: (0, lodash_1.get)(rules, 'flatCompilation', true)
-            }
-        };
+        this.config = config;
     }
     AmxxBuilder.prototype.build = function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        this.logger.info('Building...');
+                        logger_1.default.info('Building...');
                         return [4 /*yield*/, this.buildAssets()];
                     case 1:
                         _a.sent();
@@ -117,7 +95,7 @@ var AmxxBuilder = /** @class */ (function () {
                         return [4 /*yield*/, this.buildSrc()];
                     case 3:
                         _a.sent();
-                        this.logger.success('Build finished!');
+                        logger_1.default.success('Build finished!');
                         return [2 /*return*/];
                 }
             });
@@ -248,7 +226,7 @@ var AmxxBuilder = /** @class */ (function () {
                         return [4 /*yield*/, fs_1.default.promises.copyFile(srcPath, destPath)];
                     case 2:
                         _a.sent();
-                        this.logger.info('Script updated:', (0, normalize_path_1.default)(destPath));
+                        logger_1.default.info('Script updated:', (0, normalize_path_1.default)(destPath));
                         return [2 /*return*/];
                 }
             });
@@ -269,7 +247,7 @@ var AmxxBuilder = /** @class */ (function () {
                         return [4 /*yield*/, fs_1.default.promises.copyFile(srcPath, destPath)];
                     case 2:
                         _a.sent();
-                        this.logger.info('Asset updated', (0, normalize_path_1.default)(destPath));
+                        logger_1.default.info('Asset updated', (0, normalize_path_1.default)(destPath));
                         return [2 /*return*/];
                 }
             });
@@ -289,7 +267,7 @@ var AmxxBuilder = /** @class */ (function () {
                         return [4 /*yield*/, fs_1.default.promises.copyFile(srcPath, destPath)];
                     case 2:
                         _a.sent();
-                        this.logger.info('Include updated:', (0, normalize_path_1.default)(destPath));
+                        logger_1.default.info('Include updated:', (0, normalize_path_1.default)(destPath));
                         return [2 /*return*/];
                 }
             });
@@ -312,8 +290,7 @@ var AmxxBuilder = /** @class */ (function () {
     };
     AmxxBuilder.prototype.compilePlugin = function (filePath) {
         return __awaiter(this, void 0, void 0, function () {
-            var srcPath, destDir, srcDir, relateiveSrcPath, result, destPath, relativeFilePath;
-            var _this = this;
+            var srcPath, destDir, srcDir, relateiveSrcPath, executable, result, destPath, relativeFilePath;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -324,14 +301,17 @@ var AmxxBuilder = /** @class */ (function () {
                             destDir = path_1.default.join(destDir, path_1.default.relative(this.config.input.scripts, srcDir));
                         }
                         relateiveSrcPath = path_1.default.relative(process.cwd(), srcPath);
+                        executable = path_1.default.join(this.config.compiler.dir, this.config.compiler.executable);
                         return [4 /*yield*/, (0, mkdirp_1.default)(destDir)];
                     case 1:
                         _a.sent();
                         return [4 /*yield*/, (0, amxxpc_1.default)({
                                 path: srcPath,
                                 dest: destDir,
-                                compiler: this.config.compiler.executable,
-                                includeDir: __spreadArray(__spreadArray([], this.config.compiler.include, true), [
+                                compiler: executable,
+                                includeDir: __spreadArray(__spreadArray([
+                                    path_1.default.join(this.config.compiler.dir, 'include')
+                                ], this.config.include, true), [
                                     this.config.input.include,
                                 ], false)
                             })];
@@ -340,20 +320,20 @@ var AmxxBuilder = /** @class */ (function () {
                         result.output.messages.forEach(function (message) {
                             var startLine = message.startLine, type = message.type, code = message.code, text = message.text;
                             if (type === amxxpc_1.AMXPCMessageType.Error || type === amxxpc_1.AMXPCMessageType.FatalError) {
-                                _this.logger.error("".concat((0, normalize_path_1.default)(relateiveSrcPath), "(").concat(startLine, ")"), type, code, ':', text);
+                                logger_1.default.error("".concat((0, normalize_path_1.default)(relateiveSrcPath), "(").concat(startLine, ")"), type, code, ':', text);
                             }
                             else if (type === amxxpc_1.AMXPCMessageType.Warning) {
-                                _this.logger.warn("".concat((0, normalize_path_1.default)(relateiveSrcPath), "(").concat(startLine, ")"), type, code, ':', text);
+                                logger_1.default.warn("".concat((0, normalize_path_1.default)(relateiveSrcPath), "(").concat(startLine, ")"), type, code, ':', text);
                             }
                             else if (type === amxxpc_1.AMXPCMessageType.Echo) {
-                                _this.logger.debug(text);
+                                logger_1.default.debug(text);
                             }
                         });
                         if (result.success) {
                             destPath = path_1.default.join(destDir, result.plugin);
                             relativeFilePath = path_1.default.relative(process.cwd(), filePath);
-                            this.logger.success('Compilation success:', (0, normalize_path_1.default)(relativeFilePath));
-                            this.logger.info('Plugin updated:', (0, normalize_path_1.default)(destPath));
+                            logger_1.default.success('Compilation success:', (0, normalize_path_1.default)(relativeFilePath));
+                            logger_1.default.info('Plugin updated:', (0, normalize_path_1.default)(destPath));
                         }
                         else {
                             throw new Error("Failed to compile ".concat((0, normalize_path_1.default)(relateiveSrcPath), " : \"").concat(result.error, "\""));
@@ -384,11 +364,10 @@ var AmxxBuilder = /** @class */ (function () {
     AmxxBuilder.prototype.watchDir = function (baseDir, pattern, cb) {
         return __awaiter(this, void 0, void 0, function () {
             var pathPattern, watcher, updateFn;
-            var _this = this;
             return __generator(this, function (_a) {
                 pathPattern = path_1.default.join(baseDir, pattern);
                 watcher = chokidar_1.default.watch(pathPattern, { ignoreInitial: true });
-                updateFn = function (filePath) { return cb(filePath).catch(function (err) { return _this.logger.error(err.message); }); };
+                updateFn = function (filePath) { return cb(filePath).catch(function (err) { return logger_1.default.error(err.message); }); };
                 watcher.on('add', updateFn);
                 watcher.on('change', updateFn);
                 return [2 /*return*/];

package/lib/builder/index.d.ts

@@ -1,2 +1 @@
 export { default } from './builder';
-export * from './types';

package/lib/builder/index.js

@@ -1,14 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -17,4 +7,3 @@ exports.default = void 0;
 // eslint-disable-next-line no-restricted-exports
 var builder_1 = require("./builder");
 Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(builder_1).default; } });
-__exportStar(require("./types"), exports);

package/lib/cli/controller.d.ts

@@ -1,16 +1,20 @@
-import AmxxBuilder, { IAmxxBuilderConfig } from '../builder';
+import AmxxBuilder from '../builder';
+import { IProjectOptions } from './types';
 declare class Controller {
-    loadConfig(configPath: string): Promise<IAmxxBuilderConfig>;
     createBuilder(configPath: string): Promise<AmxxBuilder>;
-    init(projectDir: string): Promise<void>;
+    create(options: IProjectOptions): Promise<void>;
+    config(projectDir: string): Promise<void>;
     compile(scriptPath: string, configPath: string): Promise<void>;
     build(configPath: string, watch: boolean): Promise<void>;
-    fetchCompiler({ configPath, version, dev, addons }: {
-        configPath: string;
-        version: string;
-        dev: boolean;
-        addons: string[];
-    }): Promise<void>;
+    install(configPath: string): Promise<void>;
+    add(configPath: string, type: string, fileName: string, options: {
+        name?: string;
+        version?: string;
+        author?: string;
+        library?: string;
+        overwrite: boolean;
+        include: string[];
+    }): Promise<any>;
 }
 declare const _default: Controller;
 export default _default;

package/lib/cli/controller.js

@@ -40,68 +40,56 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var path_1 = __importDefault(require("path"));
-var fs_1 = __importDefault(require("fs"));
-var mkdirp_1 = __importDefault(require("mkdirp"));
 var builder_1 = __importDefault(require("../builder"));
-var compiler_downloader_1 = __importDefault(require("../compiler-downloader"));
-function resolveConfigPath(configPath) {
-    return path_1.default.isAbsolute(configPath) ? configPath : path_1.default.join(process.cwd(), configPath);
-}
+var compiler_1 = __importDefault(require("../downloaders/compiler"));
+var thirdparty_1 = __importDefault(require("../downloaders/thirdparty"));
+var project_creator_1 = __importDefault(require("./services/project-creator"));
+var template_builder_1 = __importDefault(require("./services/template-builder"));
+var project_config_1 = __importDefault(require("../project-config"));
+var logger_1 = __importDefault(require("../logger/logger"));
 var Controller = /** @class */ (function () {
     function Controller() {
     }
-    Controller.prototype.loadConfig = function (configPath) {
+    Controller.prototype.createBuilder = function (configPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var resolvedPath, config;
+            var projectConfig, builder;
             return __generator(this, function (_a) {
-                resolvedPath = resolveConfigPath(configPath);
-                if (!fs_1.default.existsSync(resolvedPath)) {
-                    // eslint-disable-next-line no-console
-                    console.log('Project is not initialzied! Use "init" command to initialize the project!');
-                    process.exit(1);
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, project_config_1.default.resolve(configPath)];
+                    case 1:
+                        projectConfig = _a.sent();
+                        builder = new builder_1.default(projectConfig);
+                        return [2 /*return*/, builder];
                 }
-                config = require(resolvedPath);
-                return [2 /*return*/, config];
             });
         });
     };
-    Controller.prototype.createBuilder = function (configPath) {
+    Controller.prototype.create = function (options) {
         return __awaiter(this, void 0, void 0, function () {
-            var config, builder;
+            var projectCreator;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.loadConfig(configPath)];
+                    case 0:
+                        projectCreator = new project_creator_1.default(options);
+                        return [4 /*yield*/, projectCreator.createProject()];
                     case 1:
-                        config = _a.sent();
-                        builder = new builder_1.default(config);
-                        return [2 /*return*/, builder];
+                        _a.sent();
+                        return [2 /*return*/];
                 }
             });
         });
     };
-    Controller.prototype.init = function (projectDir) {
+    Controller.prototype.config = function (projectDir) {
         return __awaiter(this, void 0, void 0, function () {
-            var configPath, config, _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var projectCreator;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        configPath = path_1.default.join(projectDir, '.amxxpack.json');
-                        return [4 /*yield*/, fs_1.default.promises.copyFile(path_1.default.join(__dirname, '../../resources/default-config.json'), configPath)];
+                        projectCreator = new project_creator_1.default();
+                        projectCreator.projectDir = projectDir;
+                        return [4 /*yield*/, projectCreator.createProject()];
                     case 1:
-                        _c.sent();
-                        _b = (_a = JSON).parse;
-                        return [4 /*yield*/, fs_1.default.promises.readFile(configPath, 'utf8')];
-                    case 2:
-                        config = _b.apply(_a, [_c.sent()]);
-                        return [4 /*yield*/, (0, mkdirp_1.default)(path_1.default.join(projectDir, config.input.assets))];
-                    case 3:
-                        _c.sent();
-                        return [4 /*yield*/, (0, mkdirp_1.default)(path_1.default.join(projectDir, config.input.include))];
-                    case 4:
-                        _c.sent();
-                        return [4 /*yield*/, (0, mkdirp_1.default)(path_1.default.join(projectDir, config.input.scripts))];
-                    case 5:
-                        _c.sent();
+                        _a.sent();
                         return [2 /*return*/];
                 }
             });
@@ -158,20 +146,89 @@ var Controller = /** @class */ (function () {
             });
         });
     };
-    Controller.prototype.fetchCompiler = function (_a) {
-        var configPath = _a.configPath, version = _a.version, dev = _a.dev, addons = _a.addons;
+    Controller.prototype.install = function (configPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var config, compilerPath;
+            var projectConfig, _i, _a, dependency;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.loadConfig(configPath)];
+                    case 0: return [4 /*yield*/, project_config_1.default.resolve(configPath)];
                     case 1:
-                        config = _b.sent();
-                        compilerPath = path_1.default.parse(config.compiler.executable).dir;
-                        return [4 /*yield*/, (0, compiler_downloader_1.default)({ path: path_1.default.resolve(compilerPath), dists: addons, version: version, dev: dev })];
+                        projectConfig = _b.sent();
+                        return [4 /*yield*/, (0, compiler_1.default)({
+                                path: projectConfig.compiler.dir,
+                                dists: projectConfig.compiler.addons,
+                                version: projectConfig.compiler.version,
+                                dev: projectConfig.compiler.dev
+                            })];
                     case 2:
                         _b.sent();
-                        return [2 /*return*/];
+                        _i = 0, _a = projectConfig.thirdparty.dependencies;
+                        _b.label = 3;
+                    case 3:
+                        if (!(_i < _a.length)) return [3 /*break*/, 6];
+                        dependency = _a[_i];
+                        return [4 /*yield*/, (0, thirdparty_1.default)({
+                                name: dependency.name,
+                                url: dependency.url,
+                                dir: projectConfig.thirdparty.dir
+                            })];
+                    case 4:
+                        _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 3];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Controller.prototype.add = function (configPath, type, fileName, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var projectConfig, includeName, templateBuilder, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, project_config_1.default.resolve(configPath)];
+                    case 1:
+                        projectConfig = _b.sent();
+                        includeName = path_1.default.parse(fileName).base;
+                        templateBuilder = new template_builder_1.default(projectConfig, {
+                            FILE_NAME: fileName,
+                            PLUGIN_NAME: options.name,
+                            PLUGIN_VERSION: options.version,
+                            PLUGIN_AUTHOR: options.author,
+                            LIBRARY_NAME: options.library || includeName.replace(/-/g, '_'),
+                            INCLUDES: options.include,
+                            INCLUDE_NAME: includeName
+                        }, { PLUGIN_NAME: fileName });
+                        _a = type;
+                        switch (_a) {
+                            case 'script': return [3 /*break*/, 2];
+                            case 'include': return [3 /*break*/, 4];
+                            case 'lib': return [3 /*break*/, 6];
+                        }
+                        return [3 /*break*/, 9];
+                    case 2: return [4 /*yield*/, templateBuilder.createFileFromTemplate(path_1.default.join(projectConfig.input.scripts, "".concat(fileName, ".sma")), 'script', options.overwrite)];
+                    case 3:
+                        _b.sent();
+                        return [3 /*break*/, 10];
+                    case 4: return [4 /*yield*/, templateBuilder.createFileFromTemplate(path_1.default.join(projectConfig.input.include, "".concat(fileName, ".inc")), 'include', options.overwrite)];
+                    case 5:
+                        _b.sent();
+                        return [3 /*break*/, 10];
+                    case 6: return [4 /*yield*/, templateBuilder.createFileFromTemplate(path_1.default.join(projectConfig.input.scripts, "".concat(fileName, ".sma")), 'library-script', options.overwrite)];
+                    case 7:
+                        _b.sent();
+                        return [4 /*yield*/, templateBuilder.createFileFromTemplate(path_1.default.join(projectConfig.input.include, "".concat(includeName, ".inc")), 'library-include', options.overwrite)];
+                    case 8:
+                        _b.sent();
+                        return [3 /*break*/, 10];
+                    case 9:
+                        {
+                            logger_1.default.error("Invalid file type \"".concat(type, "\"!"));
+                        }
+                        _b.label = 10;
+                    case 10: return [2 /*return*/];
                 }
             });
         });

package/lib/cli/index.d.ts

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
-export {};
+export { default as program } from './program';
+export { default as controller } from './controller';

package/lib/cli/index.js

@@ -4,5 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.controller = exports.program = void 0;
 var program_1 = __importDefault(require("./program"));
 program_1.default.parse();
+var program_2 = require("./program");
+Object.defineProperty(exports, "program", { enumerable: true, get: function () { return __importDefault(program_2).default; } });
+var controller_1 = require("./controller");
+Object.defineProperty(exports, "controller", { enumerable: true, get: function () { return __importDefault(controller_1).default; } });

package/lib/cli/program.js

@@ -41,20 +41,42 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var commander_1 = require("commander");
+var config_1 = __importDefault(require("../config"));
 var controller_1 = __importDefault(require("./controller"));
 var program = new commander_1.Command();
 program
     .name('AMXXPack CLI')
     .description('Simple AmxModX CLI');
 program
-    .command('init')
+    .command('create')
+    .argument('<name>', 'Project name')
+    .option('--version, -v <version>', 'Project version')
+    .option('--author, -a <author>', 'Project author')
+    .option('--description, -d <author>', 'Project description')
+    .option('--nonpm', 'Don\'t initialize npm package', false)
+    .option('--git', 'Initialize git', false)
+    .action(function (name, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var version, author, description, nonpm, git;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                version = options.V, author = options.A, description = options.D, nonpm = options.nonpm, git = options.git;
+                return [4 /*yield*/, controller_1.default.create({ name: name, version: version, author: author, description: description, nonpm: nonpm, git: git })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+program
+    .command('config')
     .action(function () { return __awaiter(void 0, void 0, void 0, function () {
     var projectDir;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 projectDir = process.cwd();
-                return [4 /*yield*/, controller_1.default.init(projectDir)];
+                return [4 /*yield*/, controller_1.default.config(projectDir)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -63,15 +85,16 @@ program
 }); });
 program
     .command('compile')
+    .alias('c')
     .argument('<path>', 'Script path or glob')
-    .option('--config, -c <path>', 'Config file', '.amxxpack.json')
-    .action(function (str, options) { return __awaiter(void 0, void 0, void 0, function () {
+    .option('--config, -c <path>', 'Config file', config_1.default.projectConfig)
+    .action(function (filePath, options) { return __awaiter(void 0, void 0, void 0, function () {
     var configPath;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 configPath = options.C;
-                return [4 /*yield*/, controller_1.default.compile(str, configPath)];
+                return [4 /*yield*/, controller_1.default.compile(filePath, configPath)];
             case 1:
                 _a.sent();
                 return [2 /*return*/];
@@ -80,9 +103,10 @@ program
 }); });
 program
     .command('build')
+    .alias('b')
+    .option('--config, -c <path>', 'Config file', config_1.default.projectConfig)
     .option('--watch, -w', 'Watch project')
-    .option('--config, -c <path>', 'Config file', '.amxxpack.json')
-    .action(function (str, options) { return __awaiter(void 0, void 0, void 0, function () {
+    .action(function (_argument, options) { return __awaiter(void 0, void 0, void 0, function () {
     var _a, configPath, watch;
     return __generator(this, function (_b) {
         switch (_b.label) {
@@ -96,21 +120,53 @@ program
     });
 }); });
 program
-    .command('fetch-compiler')
-    .option('--config, -c <path>', 'Config file', '.amxxpack.json')
-    .option('--version, -v <version>', 'Version', '1.8.2')
-    .option('--addon, -a <addon>', 'Addon', 'base')
-    .option('--dev, -d', 'Dev build flag', false)
-    .action(function (str, options) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, dev, addon, version, configPath, addons;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
+    .command('install')
+    .alias('i')
+    .option('--config, -c <path>', 'Config file', config_1.default.projectConfig)
+    .action(function (_argument, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var configPath;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
             case 0:
-                _a = options.opts(), dev = _a.D, addon = _a.A, version = _a.V, configPath = _a.C;
-                addons = addon.split(' ');
-                return [4 /*yield*/, controller_1.default.fetchCompiler({ configPath: configPath, version: version, dev: dev, addons: addons })];
+                configPath = options.opts().C;
+                return [4 /*yield*/, controller_1.default.install(configPath)];
             case 1:
-                _b.sent();
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+program
+    .command('new')
+    .alias('n')
+    .arguments('<type> <filename>')
+    .option('--config, -c <path>', 'Config file', config_1.default.projectConfig)
+    .option('--name, -n <name>', 'Plugin name')
+    .option('--version, -v <version>', 'Plugin version')
+    .option('--author, -a <author>', 'Plugin author')
+    .option('--library, -l <library>', 'Library name')
+    .option('--include, -i <include>', 'Add include')
+    .option('--overwrite', 'Overwrite file if it already exists', false)
+    .action(function (type, fileName, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var configPath, name, version, author, library, overwrite, include;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                configPath = options.C, name = options.N, version = options.V, author = options.A, library = options.L, overwrite = options.overwrite;
+                include = options.I ? options.I.split(/[\s|,]/) : [];
+                if (!include.includes('amxmodx')) {
+                    include.unshift('amxmodx');
+                }
+                return [4 /*yield*/, controller_1.default.add(configPath, type, fileName, {
+                        name: name,
+                        version: version,
+                        author: author,
+                        library: library,
+                        include: include,
+                        overwrite: overwrite
+                    })];
+            case 1:
+                _a.sent();
                 return [2 /*return*/];
         }
     });