@ovipakla/gm-cli 1.0.0

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,31 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+### Description
+
+A clear and concise description of what the bug is.
+
+---
+### Reproducing steps
+
+Steps to reproduce the behavior:
+1. Go to `...`
+2. Click on `...`
+3. See error `...`
+
+---
+### Expected behavior
+
+A clear and concise description of what you expected to happen.
+
+---
+### Environment
+
+- Version: `vYYMMDD`
+- Target: `win-yyp` | `wasm`

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,22 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+### Description
+
+What is the issue/feature? Why is it needed? 
+
+---
+### Requirements
+
+What is the expected behavior or outcome?
+
+---
+### Test case scenario
+
+How will it be tested or validated?

package/GMFileWatcher.js

@@ -0,0 +1,353 @@
+import childProcess from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import chokidar from 'chokidar';
+import { readFile } from 'fs/promises';
+
+/* ---------------------------------------------------------
+ * GMModule
+ * --------------------------------------------------------- */
+class GMModule {
+  constructor(dir, version, hook = defaultWatcherHook()) {
+    this.dir = dir;
+    this.version = version;
+
+    this.scriptWatcher  = this.createWatcher("src", hook);
+    this.testWatcher  = this.createWatcher("test", hook);
+    this.shaderWatcher  = this.createWatcher("resource/shader", hook);
+
+    this.objectWatchers = this.findTopFolders(path.join(dir, "resource/object"))
+      .map(entry => ({
+        ...entry,
+        watcher: chokidar.watch(entry.dir, hook)
+      }));
+
+    this.sceneWatchers = this.findTopFolders(path.join(dir, "resource/scene"))
+      .map(entry => ({
+        ...entry,
+        watcher: chokidar.watch(entry.dir, hook)
+      }));
+
+    console.log(`♻️  Watching [${dir}] for changes...`);
+  }
+
+  createWatcher(subdir, hook) {
+    return chokidar.watch(path.join(this.dir, subdir), hook);
+  }
+
+  findTopFolders(dir, results = []) {
+    if (!fs.existsSync(dir)) return results;
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const gmlFiles = entries
+      .filter(e => e.isFile() && e.name.endsWith(".gml"))
+      .map(e => e.name);
+
+    if (gmlFiles.length > 0) {
+      results.push({
+        name: path.basename(dir),
+        dir: dir.replace(/^\.\//, ""),
+        files: gmlFiles,
+      });
+      return results;
+    }
+
+    entries
+      .filter(e => e.isDirectory())
+      .forEach(subdir => this.findTopFolders(path.join(dir, subdir.name), results));
+
+    return results;
+  }
+}
+
+function defaultWatcherHook() {
+  return {
+    ignored: /[\/\\]\./,
+    persistent: true,
+    ignoreInitial: true,
+    depth: 99,
+  };
+}
+
+/* ---------------------------------------------------------
+ * GMFileWatcher
+ * --------------------------------------------------------- */
+class GMFileWatcher {
+  constructor(gmPackage, modulesDir, watch = false) {
+    this.gmPath = resolvePath(gmPackage.main);
+    this.modulesDirName = modulesDir;
+    this.modulesDirPath = resolvePath(modulesDir);
+    this.timestamp = "";
+
+    const dependencyEntries = Object.entries(gmPackage.dependencies);
+
+    this.modules = watch
+      ? this.initializeWatchedModules(dependencyEntries)
+      : this.initializeSyncModules(dependencyEntries);
+  }
+
+  initializeWatchedModules(dependencies) {
+    return dependencies.map(([name, version]) => {
+      const gmModule = this.parseModule(name, version);
+      this.syncModuleFiles(name, gmModule.dir, gmModule.objectWatchers, gmModule.sceneWatchers);
+      return gmModule;
+    });
+  }
+
+  initializeSyncModules(dependencies) {
+    dependencies.forEach(([name]) => {
+      const modulePath = path.join(this.modulesDirPath, name);
+      this.syncModuleFiles(name, modulePath);
+    });
+    return [];
+  }
+
+  /* ---------------------------------------------
+   * Sync helpers
+   * --------------------------------------------- */
+  syncModuleFiles(name, moduleDir, objectWatchers = [], sceneWatchers = []) {
+    const src      = path.join(moduleDir, 'src');
+    const test     = path.join(moduleDir, 'test');
+    const shader   = path.join(moduleDir, 'resource/shader');
+
+    this.syncFiles(src,     this.gmPath, `${name}/src`,               'scripts', 'gml');
+    this.syncFiles(test,    this.gmPath, `${name}/test`,              'scripts', 'gml');
+    this.syncFiles(shader,  this.gmPath, `${name}/resource/shader`,   'scripts', 'gml');
+    this.syncFiles(shader,  this.gmPath, `${name}/resource/shader`,   'shaders', 'fsh');
+    this.syncFiles(shader,  this.gmPath, `${name}/resource/shader`,   'shaders', 'vsh');
+
+    objectWatchers?.forEach(entry => {
+      this.syncFiles(
+        entry.dir,
+        path.join(this.gmPath, 'objects', entry.name),
+        `${name}/resource/object/../${entry.name}`,
+        `objects/${entry.name}`,
+        'gml',
+        '/.*',
+        true
+      );
+    });
+
+    sceneWatchers?.forEach(entry => {
+      this.syncFiles(
+        entry.dir,
+        path.join(this.gmPath, 'rooms', entry.name),
+        `${name}/resource/scene/${entry.name}`,
+        `rooms/${entry.name}`,
+        'gml',
+        '/.*',
+        true
+      );
+    });
+  }
+
+  syncFiles = function (source, target, pkgName, gmFolderName, extension, suffix = '/../*.', isObject = false) {
+    childProcess.exec(`find ${source} -iname "*.${extension}"`, (err, stdout) => {
+      const loc = stdout.split('\n')
+        .filter(Boolean)
+        .map(f => this.readFileMetadata(f, extension))
+        .map(script => this.writeIfChanged(script, extension, target, gmFolderName, isObject))
+        .reduce(sumLineChanges, { before: 0, after: 0 });
+
+      const timestamp = new Intl.DateTimeFormat('pl-PL', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+      }).format(new Date()).replaceAll(',', '');
+
+      if (timestamp !== this.timestamp) {
+        this.timestamp = timestamp
+        console.log(`⌚ ${timestamp}`)
+      }
+      
+      logSyncSummary(pkgName, suffix, extension, loc);
+    });
+  }
+
+  /* ---------------------------------------------
+   * Watcher handlers
+   * --------------------------------------------- */
+  parseModule(name, version) {
+    const gmModule = new GMModule(resolvePath(path.join(this.modulesDirName, name)), version);
+
+    const moduleFilter = (p, module) =>
+      path.normalize(p).includes(path.normalize(module.dir));
+
+    gmModule.scriptWatcher.on('change', p => this.modules.filter(m => moduleFilter(p, m)).forEach(() => this.hook(p)));
+    gmModule.testWatcher.on('change', p => this.modules.filter(m => moduleFilter(p, m)).forEach(() => this.hook(p)));
+    gmModule.shaderWatcher.on('change', p => this.modules.filter(m => moduleFilter(p, m)).forEach(() => this.hook(p)));
+
+    gmModule.objectWatchers.forEach(entry => {
+      entry.watcher.on('change', () => this.objectHook(entry));
+    });
+
+    gmModule.sceneWatchers.forEach(entry => {
+      entry.watcher.on('change', () => this.sceneHook(entry));
+    });
+
+    return gmModule;
+  }
+
+  async hook(p) {
+    const pkgName = extractPkgName(p, this.modulesDirName);
+    const source = path.join(this.modulesDirPath, pkgName);
+
+    this.syncModuleFiles(pkgName, source);
+  }
+
+  async objectHook(entry) {
+    this.syncFiles(
+      entry.dir,
+      path.join(this.gmPath, 'objects', entry.name),
+      `${this.modulesDirName}/resource/object/../${entry.name}`,
+      `objects/${entry.name}`,
+      'gml',
+      '/.*',
+      true
+    );
+  }
+
+  async sceneHook(entry) {
+    this.syncFiles(
+      entry.dir,
+      path.join(this.gmPath, 'rooms', entry.name),
+      `${this.modulesDirName}/resource/scene/${entry.name}`,
+      `rooms/${entry.name}`,
+      'gml',
+      '/.*',
+      true
+    );
+  }
+
+  readFileMetadata(filePath, extension) {
+    return {
+      name: path.basename(filePath).replace(`.${extension}`, ''),
+      dir: path.normalize(filePath.replaceAll('./', '')),
+      content: fs.readFileSync(path.normalize(filePath), 'utf8'),
+    };
+  }
+
+  writeIfChanged(script, extension, target, gmFolderName, isObject) {
+    const diffStats = (oldLines, newLines) => {
+      const m = oldLines.length;
+      const n = newLines.length;
+
+      // tablica LCS
+      const dp = Array.from({ length: m + 1 }, () =>
+        Array(n + 1).fill(0)
+      );
+
+      for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+          if (oldLines[i - 1] === newLines[j - 1]) {
+            dp[i][j] = dp[i - 1][j - 1] + 1;
+          } else {
+            dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+          }
+        }
+      }
+
+      const same = dp[m][n];
+      const removed = m - same;
+      const added = n - same;
+      const total = same + added
+
+      return { added, removed, total };
+    }
+
+    const removeZeroFields = (obj) => {
+      return Object.fromEntries(
+        Object.entries(obj).filter(([_, value]) => value !== 0)
+      );
+    }
+
+    const dst = isObject
+      ? path.join(target, `${script.name}.${extension}`)
+      : path.join(target, gmFolderName, `${script.name}/${script.name}.${extension}`);
+
+    if (!fs.existsSync(dst)) {
+      const dstYY = path.join(target, gmFolderName, `${script.name}/${script.name}.yy`);
+      if (!fs.existsSync(dstYY)) {
+        console.log(`⚠️  File ${dstYY} does not exists, cannot sync.`)
+        return {
+          before: 0,
+          after: 0,
+        }
+      }
+
+      fs.writeFileSync(dst, "");
+    }
+
+    const existing = fs.readFileSync(dst, 'utf8');
+    if (existing !== script.content) {
+      const result = removeZeroFields(diffStats(existing.split('\n'), script.content.split('\n')))
+      console.log(`➡️  Save ${script.name}.${extension}:`, result);
+      fs.writeFileSync(dst, script.content, { encoding: 'utf8', flag: 'w' });
+    }
+
+    return {
+      before: existing.split('\n').length,
+      after: script.content.split('\n').length,
+    };
+  }
+}
+
+/* ---------------------------------------------------------
+ * Helpers (pure functions)
+ * --------------------------------------------------------- */
+function resolvePath(p) {
+  return path.join(process.cwd(), path.normalize(p));
+}
+
+function extractPkgName(file, modulesDir) {
+  return file
+    .split(modulesDir)[1]
+    .replaceAll('\\', '/')
+    .split('/')
+    .filter(Boolean)[0];
+}
+
+function sumLineChanges(acc, cur) {
+  acc.before += cur.before;
+  acc.after += cur.after;
+  return acc;
+}
+
+function logSyncSummary(pkgName, suffix, extension, loc) {
+  const newLines = loc.after - loc.before;
+  if (newLines !== 0) {
+    console.log(`🚀 [${pkgName}${suffix}${extension}]:`, { diff: newLines, total: loc.after } );
+  }
+}
+
+/* ---------------------------------------------------------
+ * Public API
+ * --------------------------------------------------------- */
+export async function watch(gmPackagePath, modulesDir = 'gm_modules') {
+  try {
+    return new GMFileWatcher(
+      JSON.parse(await readFile(gmPackagePath, 'utf8')),
+      modulesDir,
+      true
+    );
+  } catch (e) {
+    console.error(`❌ Unable to parse package-gm.json at: ${gmPackagePath}\n${e.message}`);
+    console.error(e.stack);
+  }
+}
+
+export async function sync(gmPackagePath, modulesDir = 'gm_modules') {
+  try {
+    return new GMFileWatcher(
+      JSON.parse(await readFile(gmPackagePath, 'utf8')),
+      modulesDir
+    );
+  } catch (e) {
+    console.error(`❌ Unable to parse package-gm.json at: ${gmPackagePath}\n${e.message}`);
+    console.error(e.stack);
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Alkapivo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# gm-cli
+Gamemaker CLI toolkit. Watch & sync gml sources with yyp project.
+
+# Requirements
+- [Node.js](https://nodejs.org) 18.16^
+- [find](https://en.wikipedia.org/wiki/Find_(Unix))
+
+# Install
+```bash
+npm install
+```
+
+# Usage
+```bash
+gm-cli watch
+```
+
+# Project structure
+```
+- gm_modules:
+  - core: git repo with gml `*.gml` files
+  - visu: git repo with gml `*.gml` files
+- yyp:
+  - datafiles: directory created by gamemaker
+  - extensions: directory created by gamemaker
+  - fonts: directory created by gamemaker
+  - objects: directory created by gamemaker
+  - options: directory created by gamemaker
+  - rooms: directory created by gamemaker
+  - scripts: directory created by gamemaker
+  - shaders: directory created by gamemaker
+  - sounds: directory created by gamemaker
+  - sprites: directory created by gamemaker
+  - game.resource_order: file created by gamemaker
+  - game.yyp: file created by gamemaker
+- package-gm.json: Equivalent of `npm` "package.json"
+```
+Content of `package-gm.json`:
+```json
+{
+  "name": "visu",
+  "version": "1.0.0",
+  "description": "Visu",
+  "main": "yyp",
+  "author": "Alkapivo",
+  "license": "ISC",
+  "dependencies": {
+    "core": "^1.0.0",
+    "visu": "^1.0.0"
+  }
+}
+```
+Note: 
+- `main` is a relative directory path, where `*.yyp` file (gamemaker studio 2.3 project).
+- `dependencies` - keys should match names in `gm_modules` folder

package/app.js

@@ -0,0 +1,397 @@
+#! /usr/bin/env node
+
+import { watch, sync } from './GMFileWatcher.js';
+import path from 'path';
+import { program } from 'commander';
+import { spawn, execSync } from 'child_process';
+import fs from 'fs';
+import readline from 'readline';
+
+
+program.version('26.02.14', '-v, --version, ', 'output the current version');
+program.command('init')
+  .description('CLI creator for package-gm.json')
+  .action(async () => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const askQuestion = (query) => new Promise(resolve => rl.question(query, resolve));
+
+    try {
+      console.log("This utility will walk you through creating a package-gm.json file.");
+      console.log("It only covers the most common items, and tries to guess sensible defaults.");
+
+      const projectPath = process.cwd();
+      const basename = path.basename(projectPath);
+      const version = "1.0.0";
+      const propertyPackage = await askQuestion(`package name: (${basename}) `);
+      const propertyVersion = await askQuestion(`version: (${version}) `);
+      const propertyDescription = await askQuestion('description: ');
+      const propertyGamemaker = await askQuestion('gamemaker project path: ');
+      const propertyTest = await askQuestion('test command: ');
+      const propertyGit = await askQuestion('git repository: ');
+      const propertyKeywords = await askQuestion('keywords: ');
+      const propertyAuthor = await askQuestion('author: ');
+      const propertyLicense = await askQuestion('license: (ISC) ');
+      const data = {
+        package: propertyPackage === null || propertyPackage === '' ? basename : propertyPackage,
+        version: propertyVersion === null || propertyVersion === '' ? version : propertyVersion,
+        description: propertyDescription,
+        main: propertyGamemaker,
+        test: propertyTest,
+        git: propertyGit,
+        keywords: propertyKeywords,
+        author: propertyAuthor,
+        license: propertyLicense,
+        scripts: {},
+        dependencies: {},
+      };
+      
+      const filePath = path.join(projectPath, 'package-gm.json');
+      const dataString = JSON.stringify(data, null, 2);
+
+      console.log(`About to write to ${filePath}:\n\n${dataString}\n\n`);
+      const response = await askQuestion(`Is this OK? (yes) `)
+      if (typeof response === 'string' && (response.includes('y') || response.includes('Y'))) {
+        fs.writeFileSync(filePath, dataString, 'utf8');
+      } else {
+        console.log('Aborted.\n');
+      }
+    } catch (error) {
+      console.error('An error occurred:', error);
+    } finally {
+      rl.close();
+      process.exit(0);
+    }
+  });
+program.command('watch')
+  .description('Watch modules dir and copy code to gamemaker project')
+  .action(() => {
+    watch(path.normalize(path.join(process.cwd(), 'package-gm.json')))
+  });
+program.command('sync')
+  .description('Copy code from modules dir to gamemaker project')
+  .action(() => {
+    sync(path.normalize(path.join(process.cwd(), 'package-gm.json')))
+  });
+program.command('install')
+  .description('Install dependencies listed in package-gm.json to gm_modules folder')
+  .action(function() {
+    const packageJsonPath = 'package-gm.json';
+    const modulesDir = 'gm_modules';
+
+    if (!fs.existsSync(modulesDir)) {
+      fs.mkdirSync(modulesDir);
+    }
+
+    const packageData = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const dependencies = packageData.dependencies;
+    Object.entries(dependencies).forEach(([key, dependency]) => {
+      const modulePath = path.join(modulesDir, key);
+      if (fs.existsSync(modulePath)) {
+        try {
+          execSync('git rev-parse --is-inside-work-tree', { cwd: modulePath, stdio: 'ignore' });
+          console.log(`Syncing ${modulePath} to revision ${dependency.revision}`);
+          execSync('git reset --hard HEAD', { cwd: modulePath, stdio: 'inherit' });
+          execSync('git clean -fdx -e', { cwd: modulePath, stdio: 'inherit' });
+          execSync(`git checkout ${dependency.revision}`, { cwd: modulePath, stdio: 'inherit' });
+        } catch (error) {
+          console.log(`Removing ${modulePath} because it's not a git repository`);
+          fs.rmSync(modulePath, { recursive: true, force: true });
+          console.log(`Initializing ${modulePath} to revision ${dependency.revision}`);
+          execSync(`git clone ${dependency.remote} ${modulePath}`, { stdio: 'inherit' });
+          execSync(`git checkout ${dependency.revision}`, { cwd: modulePath, stdio: 'inherit' });
+        }
+      } else {
+        console.log(`Initializing ${modulePath} to revision ${dependency.revision}`);
+        execSync(`git clone ${dependency.remote} ${modulePath}`, { stdio: 'inherit' });
+        execSync(`git checkout ${dependency.revision}`, { cwd: modulePath, stdio: 'inherit' });
+      }
+    });
+
+    console.log('All dependencies processed.');
+    process.exit(0);
+  })
+program.command('run')
+  .description('Run the script named <foo>')
+  .argument('<foo>', 'script name')
+  .action((foo) => {
+    if (typeof foo !== 'string') {
+      console.log(`missing argument`);
+      console.log(`Exited with code 1`);
+      return process.exit(1);
+    }
+
+    const packageJsonPath = 'package-gm.json';
+    const packageData = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const scriptData = packageData.scripts[foo]
+    if (typeof scriptData !== 'string') {
+      console.log(`script ${foo} wasn't found`);
+      console.log(`Exited with code 1`);
+      return process.exit(1);
+    }
+
+    const shellScript = `#!/bin/bash
+    ${scriptData}
+    `;
+    const bashProcess = spawn("bash", ["-s"], { stdio: ["pipe", "inherit", "inherit"] });
+    bashProcess.stdin.write(shellScript);
+    bashProcess.stdin.end();
+    bashProcess.on("exit", (code) => {
+      console.log(`Exited with code ${code}`);
+      process.exit(code);
+    });
+  });
+program.command('generate')
+  .description('Generate *.yyp IncludedFiles section')
+  .action(function() {
+    function getFilesRecursively(dir, root) {
+      let files = [];
+      for (const entry of fs.readdirSync(dir)) {
+        const fullPath = path.join(dir, entry).replaceAll("\\", "/");
+        if (fs.statSync(fullPath).isDirectory()) {
+          files = files.concat(getFilesRecursively(fullPath, root));
+        } else {
+          const filePath = `datafiles${(fullPath.startsWith(root) ? fullPath.slice(root.length) : fullPath)}`.replaceAll(`/${entry}`, '');
+          const line = `{"$GMIncludedFile":"","%Name":"${entry}","CopyToMask":-1,"filePath":"${filePath}","name":"${entry}","resourceType":"GMIncludedFile","resourceVersion":"2.0",},`;
+          files.push(line);
+        }
+      }
+      return files;
+    }
+
+    function findFileUpwardsSync(filename = "gm-cli.env", maxLevels = 99) {
+      let currentDir = process.cwd();
+      for (let i = 0; i < maxLevels; i++) {
+        const candidate = path.join(currentDir, filename);
+        if (fs.existsSync(candidate)) {
+          return candidate;
+        }
+
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+          break;
+        }
+
+        currentDir = parentDir;
+      }
+
+      return null;
+    }
+
+    function parseEnvFile(filePath) {
+      const content = fs.readFileSync(filePath, "utf8");
+      const result = new Map();
+      content.split(/\r?\n/).forEach(line => {
+        line = line.trim();
+        if (!line || line.startsWith("#")) {
+          return;
+        }
+
+        const match = line.match(/^([^=]+)="(.*)"$/);
+        if (match) {
+          const [, key, value] = match;
+          result.set(key.trim(), value);
+        }
+      });
+
+      return result;
+    }
+
+    const envFile = findFileUpwardsSync();
+    if (envFile === null) {
+      console.error('gm-cli.env was not found')
+      return
+    }
+
+    const envPath = path.dirname(envFile).replaceAll("\\", "/");
+    const envMap = parseEnvFile(envFile);
+    if (!envMap.has("GMS_PROJECT_PATH")) {
+      console.error(`GMS_PROJECT_PATH was not defined in ${envFile}`)
+      return
+    }
+
+    if (!envMap.has("GMS_PROJECT_NAME")) {
+      console.error(`GMS_PROJECT_NAME was not defined in ${envFile}`)
+      return
+    }
+
+    const projectPath = path.join(envPath, envMap.get("GMS_PROJECT_PATH")).replaceAll("\\", "/");
+    const yypPath = path.join(projectPath, `${envMap.get("GMS_PROJECT_NAME")}.yyp`).replaceAll("\\", "/");
+    const yypOldPath = path.join(projectPath, `${envMap.get("GMS_PROJECT_NAME")}.yyp.old`).replaceAll("\\", "/");
+    const yyp = fs.readFileSync(yypPath, "utf8");
+    fs.copyFileSync(yypPath, yypOldPath);
+
+    const datafilesPath = path.join(projectPath, "datafiles").replaceAll("\\", "/")
+    const datafiles = getFilesRecursively(datafilesPath, datafilesPath)
+    const replaced = yyp.replace(/"IncludedFiles"\s*:\s*\[(.*?)\]/s, `"IncludedFiles":[
+    ${datafiles.join("\n    ")}
+  ]`);
+    fs.writeFileSync(yypPath, replaced, "utf8");
+  });
+program.command('make')
+  .description('Build and run gamemaker project')
+  .option('-t, --target <target>', 'available targets: windows')
+  .option('-r, --runtime <type>', 'use VM or YYC runtime')
+  .option('-n, --name <name>', 'The actual file name of the ZIP file that is created')
+  .option('-l, --launch', 'launch the executable after building')
+  .option('-c, --clean', 'make clean build')
+  .action(function() {
+    const targetMap = new Map([ [ 'windows', 'win' ] ])
+    const options = this.opts();
+    const config = {
+      runtime: '$GMS_RUNTIME',
+      target: '$GMS_TARGET',
+      targetExt: 'win',
+      clean: 'false',
+      launch: 'PackageZip',
+      name: '$GMS_PROJECT_NAME',
+    };
+
+    if (options.runtime !== undefined) {
+      config.runtime = options.runtime;
+    }
+
+    if (options.target !== undefined && targetMap.has(options.target)) {
+      config.target = options.target;
+      config.targetExt = targetMap.get(config.target);
+    }
+
+    if (options.clean !== undefined) {
+      config.clean = 'true';
+    }
+
+    if (options.launch !== undefined) {
+      config.launch = 'Run';
+    }
+
+    if (options.name !== undefined && typeof options.name === 'string' && options.name.trim() !== '') {
+      config.name = options.name;
+    }
+
+    const shellScript = `#!/bin/bash
+      function log_info {
+        local timestamp=$(date +"%Y-%m-%d %H:%M:%S")
+        echo -e "$timestamp INFO   [gm-cli::run] $1"
+      }
+
+      function log_error {
+        local timestamp=$(date +"%Y-%m-%d %H:%M:%S")
+        echo -e "$timestamp ERROR  [gm-cli::run] $1"
+      }
+      
+      gm_cli_env_path=""
+      dir=$(realpath "$PWD")
+      while [ "$dir" != "/" ]; do
+        if [ -f "$dir/gm-cli.env" ]; then
+          gm_cli_env_path="$dir/gm-cli.env"
+          log_info "Load configuration '$gm_cli_env_path'"
+          set -a
+          . "$gm_cli_env_path"
+          set +a
+          break
+        fi
+        dir=$(dirname "$dir")
+      done
+
+      igor_path=$GMS_IGOR_PATH
+      if [ -z "$igor_path" ]; then
+        log_error "GMS_IGOR_PATH must be defined! exit 1"
+        exit 1
+      fi
+
+      project_name=$GMS_PROJECT_NAME
+      if [ -z "$project_name" ]; then
+        log_error "GMS_PROJECT_NAME must be defined! exit 1"
+        exit 1
+      fi
+      
+      project_path=$GMS_PROJECT_PATH
+      if [ -z "$project_path" ]; then
+        log_error "GMS_PROJECT_PATH must be defined! exit 1"
+        exit 1
+      fi
+      
+      project_path=$(dirname "$gm_cli_env_path")/$project_path
+      project_path=$(realpath $project_path)
+
+      user_path=$GMS_USER_PATH
+      if [ -z "$user_path" ]; then
+        log_error "GMS_USER_PATH must be defined! exit 1"
+        exit 1
+      fi
+      user_path=$(realpath $user_path)
+
+      runtime_path=$GMS_RUNTIME_PATH
+      if [ -z "$runtime_path" ]; then
+        log_error "GMS_RUNTIME_PATH must be defined! exit 1"
+        exit 1
+      fi
+      runtime_path=$(realpath $runtime_path)
+
+      runtime=${config.runtime}
+      if [ -z "$runtime" ]; then
+        log_error "GMS_RUNTIME must be defined! exit 1"
+        exit 1
+      fi
+
+      target=${config.target}
+      if [ -z "$target" ]; then
+        log_error "GMS_TARGET must be defined! exit 1"
+        exit 1
+      fi
+
+      target_ext=${config.targetExt}
+      if [ -z "$target_ext" ]; then
+        log_error "GMS_TARGET_EXT must be defined! exit 1"
+        exit 1
+      fi
+
+      zip_name=${config.name}
+      echo $zip_name
+      if [ -z "$zip_name" ]; then
+        log_error "--name must be defined! exit 1"
+        exit 1
+      fi
+
+      clean=${config.clean}
+      if [ "$clean" = "true" ]; then
+        log_info "Clean '$project_path/tmp/igor'"
+        rm -rf $project_path/tmp/igor
+        
+        log_info "Execute shell command:\n$igor_path \\ \n  --runtimePath="$runtime_path" \\ \n  --runtime=$runtime \\ \n  --project="$\{project_path\}/$\{project_name\}.yyp" \\ \n  -- $target Clean\n"
+        $igor_path \
+          --runtimePath="$runtime_path" \
+          --runtime=$runtime \
+          --project="$\{project_path\}/$\{project_name\}.yyp" \
+          -- $target Clean
+      fi
+
+      log_info "Clean '$\{project_path\}/tmp/igor/out'"
+      rm -rf $\{project_path\}/tmp/igor/out
+
+      log_info "Execute shell command:\n$igor_path \\ \n --project="$\{project_path\}/$\{project_name\}.yyp" \\ \n --user="$user_path" \\ \n --runtimePath="$runtime_path" \\ \n --runtime=$runtime \\ \n --cache="$\{project_path\}/tmp/igor/cache" \\ \n --temp="$\{project_path\}/tmp/igor/temp" \\ \n --of="$\{project_path\}/tmp/igor/out/$\{project_name\}.win" \\ \n --tf="$\{zip_name\}.zip" \\ \n -- $target ${config.launch}"
+      $igor_path \
+        --project="$\{project_path\}/$\{project_name\}.yyp" \
+        --user="$user_path" \
+        --runtimePath="$runtime_path" \
+        --runtime=$runtime \
+        --cache="$\{project_path\}/tmp/igor/cache" \
+        --temp="$\{project_path\}/tmp/igor/temp" \
+        --of="$\{project_path\}/tmp/igor/out/$\{project_name\}.win" \
+        --tf="$\{zip_name\}.zip" \
+        -- $target ${config.launch};
+
+      exit 0
+    `;
+
+    const bashProcess = spawn("bash", ["-s"], { stdio: ["pipe", "inherit", "inherit"] });
+    bashProcess.stdin.write(shellScript);
+    bashProcess.stdin.end();
+    bashProcess.on("exit", (code) => {
+      console.log(`Exited with code ${code}`);
+      process.exit(code);
+    });
+  });
+program.parse();

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@ovipakla/gm-cli",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.0",
+  "description": "Gamemaker CLI toolkit. Watch & sync gml sources with yyp project.",
+  "main": "app.js",
+  "scripts": {},
+  "author": "Alkapivo",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "chokidar": "^3.5.3",
+    "commander": "^11.1.0",
+    "conf": "^12.0.0"
+  },
+  "bin": {
+    "gm-cli": "app.js"
+  },
+  "type": "module"
+}