meocord 3.2.2 → 4.0.0-beta.0

package/dist/cjs/core/index.cjs

@@ -3,18 +3,18 @@
 require('reflect-metadata');
 var inversify = require('inversify');
 var discord_js = require('discord.js');
-var theme = require('../_shared/theme-EmG1ZEwV.cjs');
-var controller_decorator = require('../_shared/controller.decorator-eT0oHb8D.cjs');
+var theme = require('../_shared/theme-BXdSoifk.cjs');
+var controller_decorator = require('../_shared/controller.decorator-9nIxOp9y.cjs');
 var lodashEs = require('lodash-es');
 var enum_index = require('../enum/index.cjs');
 var Table = require('cli-table3');
-var metadataKey_enum = require('../_shared/metadata-key.enum-DITxfZlw.cjs');
+var fs = require('fs');
+var path = require('path');
+var metadataKey_enum = require('../_shared/metadata-key.enum-aABGdodb.cjs');
 require('node:util');
 require('dayjs');
 require('dayjs/plugin/utc.js');
 require('dayjs/plugin/timezone.js');
-require('path');
-require('fs');
 require('jiti');
 require('chalk');
 
@@ -507,6 +507,65 @@ class MeoCordApp {
     }
 }
 
+/**
+ * File written beside a bundle that carries native addons, naming the platform it was built for.
+ */ const PLATFORM_MANIFEST = 'meocord.platform.json';
+/** The C library this process runs against, when the runtime can say. */ function detectLibc() {
+    if (process.platform !== 'linux') return undefined;
+    try {
+        const report = process.report?.getReport?.();
+        if (!report?.header) return undefined;
+        return report.header.glibcVersionRuntime ? 'glibc' : 'musl';
+    } catch  {
+        return undefined;
+    }
+}
+/** The platform this process is running on. */ function currentPlatform() {
+    const libc = detectLibc();
+    return {
+        platform: process.platform,
+        arch: process.arch,
+        ...libc && {
+            libc
+        }
+    };
+}
+/** `linux-x64 (glibc)`, `darwin-arm64`. */ function describePlatform({ platform, arch, libc }) {
+    return `${platform}-${arch}${libc ? ` (${libc})` : ''}`;
+}
+/**
+ * Whether native binaries built for one platform can load on another.
+ *
+ * The C library is compared only when both sides are known, so a runtime that cannot report it
+ * is not refused on a guess.
+ */ function isSamePlatform(built, running) {
+    if (built.platform !== running.platform || built.arch !== running.arch) return false;
+    return !built.libc || !running.libc || built.libc === running.libc;
+}
+/**
+ * Stops a bundle from starting on a platform its native addons were not built for.
+ *
+ * A binary for the wrong platform does not fail at startup. It fails when something first loads
+ * it -- for an image library, the first command that renders one -- with a dynamic linker error
+ * that names a file rather than the cause. Checking the manifest up front turns that into one
+ * clear message before the bot goes online.
+ *
+ * @param distDir - Directory holding the manifest. Defaults to the directory of the entry script.
+ */ function assertBuiltForThisPlatform(distDir = process.argv[1] ? path.dirname(process.argv[1]) : undefined) {
+    if (!distDir) return;
+    const manifest = path.join(distDir, PLATFORM_MANIFEST);
+    if (!fs.existsSync(manifest)) return;
+    let built;
+    try {
+        built = JSON.parse(fs.readFileSync(manifest, 'utf8'));
+    } catch  {
+        return;
+    }
+    const running = currentPlatform();
+    if (isSamePlatform(built, running)) return;
+    throw new Error(`This build carries native addons compiled for ${describePlatform(built)}, but is running on ` + `${describePlatform(running)}. Compiled binaries only load on the platform they were built for. ` + 'Build on the same platform you deploy to -- for a container, run `meocord build` inside the image.');
+}
+
 /**
  * Recursively binds a class and all its constructor dependencies to the container in singleton scope.
  */ function bindDependencies(container, cls) {
@@ -536,6 +595,9 @@ class MeoCordFactory {
         if (!meocordConfig) {
             throw new Error('MeoCord config not found. Ensure meocord.config.ts exists.');
         }
+        // Before anything is resolved: a controller or service is what first loads a native addon, and
+        // one built for another platform would otherwise fail there with a linker error.
+        assertBuiltForThisPlatform();
         const container = new inversify.Container();
         // Bind the Discord client as a constant value
         const discordClient = new discord_js.Client(options.clientOptions);

package/dist/cjs/decorator/index.cjs

@@ -2,8 +2,8 @@
 
 require('reflect-metadata');
 var inversify = require('inversify');
-var metadataKey_enum = require('../_shared/metadata-key.enum-DITxfZlw.cjs');
-var controller_decorator = require('../_shared/controller.decorator-eT0oHb8D.cjs');
+var metadataKey_enum = require('../_shared/metadata-key.enum-aABGdodb.cjs');
+var controller_decorator = require('../_shared/controller.decorator-9nIxOp9y.cjs');
 var discord_js = require('discord.js');
 require('../enum/index.cjs');
 

package/dist/cjs/enum/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var metadataKey_enum = require('../_shared/metadata-key.enum-DITxfZlw.cjs');
+var metadataKey_enum = require('../_shared/metadata-key.enum-aABGdodb.cjs');
 
 /**
  * The kinds of interaction a `@Command` method can be bound to.

package/dist/cjs/testing/index.cjs

@@ -2,7 +2,7 @@
 
 require('reflect-metadata');
 var inversify = require('inversify');
-var metadataKey_enum = require('../_shared/metadata-key.enum-DITxfZlw.cjs');
+var metadataKey_enum = require('../_shared/metadata-key.enum-aABGdodb.cjs');
 var discord_js = require('discord.js');
 
 function isValueProvider(p) {
@@ -120,11 +120,7 @@ function isValueProvider(p) {
     }
 }
 
-/**
- * MeoCord Framework
- * Copyright (c) 2025-present Ukasyah Rahmatullah Zada
- * SPDX-License-Identifier: MIT
- */ // ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
 // Framework-agnostic mock function
 //
 // A minimal mock-fn implementation used internally by the testing utilities so

package/dist/esm/bin/app-template/meocord.config.ts.template

@@ -6,19 +6,14 @@ export default {
   // Read from the environment rather than written here: this file is committed, and a
   // token pasted into it is a token pushed to the remote. Copy .env.example to .env.
   discordToken: process.env.DISCORD_TOKEN!,
-  webpack: config => {
-    config.module.rules?.push({
-      test: /\.(md|html)$/i,
-      type: 'asset/source',
-    })
-    config.module.rules?.push({
-      test: /\.(gif|jpg|jpeg|png|svg|woff|woff2|eot|ttf|otf)$/i,
-      type: 'asset/resource',
-      exclude: /node_modules/,
-      generator: {
-        filename: 'assets/[name][ext]',
-      },
-    })
+  rsbuild: config => {
+    // Images, fonts, svg and media are handled by the bundler already. Markdown and HTML are
+    // not, and `asset/source` is what makes `import readme from './readme.md'` give you the
+    // file's text rather than a path to it.
+    config.tools ??= {}
+    config.tools.rspack = (_rspackConfig, { addRules }) => {
+      addRules([{ test: /\.(md|html)$/i, type: 'asset/source' }])
+    }
 
     return config
   },

package/dist/esm/bin/app-template/package.json.template

@@ -16,23 +16,23 @@
   },
   "dependencies": {
     "discord.js": "^14.27.0",
-    "dotenv": "^17.2.4",
+    "dotenv": "^18.0.3",
     "meocord": "^{{version}}"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@typescript-eslint/parser": "^8.58.1",
-    "@vitest/coverage-istanbul": "^4.1.10",
-    "eslint": "^10.2.0",
+    "@typescript-eslint/parser": "^8.70.1",
+    "@vitest/coverage-istanbul": "^5.0.1",
+    "eslint": "^10.11.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-import-x": "^4.17.1",
+    "eslint-plugin-prettier": "^5.5.6",
     "eslint-plugin-unused-imports": "^4.4.1",
-    "globals": "^17.5.0",
-    "prettier": "^3.8.2",
-    "typescript": "^6.0.2",
-    "typescript-eslint": "^8.58.1",
-    "unplugin-swc": "^1.5.7",
-    "vitest": "^4.1.10"
+    "globals": "^17.12.0",
+    "prettier": "^3.9.8",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.70.1",
+    "unplugin-swc": "^2.0.0",
+    "vitest": "^5.0.1"
   }
 }

package/dist/esm/bin/app-template/vitest.config.ts.template

@@ -27,9 +27,13 @@ export default defineConfig({
       // istanbul rather than v8: v8 coverage needs Node's inspector API, which bun does
       // not implement, and this template is expected to run under either runtime.
       provider: 'istanbul',
-      all: false,
       include: ['src/**/*.ts'],
-      exclude: ['src/**/*.spec.ts'],
+      // Naming `include` reports files no test imported, which is the point -- a controller
+      // with no spec should show as zero rather than vanish from the percentage. Those files
+      // are parsed by istanbul rather than transformed by swc, and that parser does not know
+      // about decorators, so anything decorated but untested has to be excluded by hand.
+      // app.ts is wiring rather than logic, and main.ts only boots the app.
+      exclude: ['src/**/*.spec.ts', 'src/app.ts', 'src/main.ts'],
     },
   },
 })

package/dist/esm/bin/builder-template/builder/context-menu.builder.template

@@ -3,10 +3,10 @@ import { CommandBuilder } from 'meocord/decorator'
 import { CommandType } from 'meocord/enum'
 
 @CommandBuilder(CommandType.CONTEXT_MENU)
-export class SampleCommandBuilder {
+export class {{builderClassName}} {
   build() {
     return new ContextMenuCommandBuilder()
-      .setName('sample-context-menu')
+      .setName('{{commandName}}')
       .setType(ApplicationCommandType.User)
   }
 }

package/dist/esm/bin/builder-template/builder/primary-entry-point.builder.template

@@ -12,11 +12,11 @@ import { CommandType } from 'meocord/enum'
 // Discord send the interaction here; `DiscordLaunchActivity` opens the activity without
 // ever reaching the bot.
 @CommandBuilder(CommandType.PRIMARY_ENTRY_POINT)
-export class SampleCommandBuilder {
+export class {{builderClassName}} {
   build() {
     return {
       type: ApplicationCommandType.PrimaryEntryPoint as const,
-      name: 'sample-entry-point',
+      name: '{{commandName}}',
       description: 'Launch the activity',
       handler: EntryPointCommandHandlerType.AppHandler,
       integration_types: [ApplicationIntegrationType.GuildInstall],

package/dist/esm/bin/builder-template/builder/slash.builder.template

@@ -3,8 +3,8 @@ import { CommandBuilder } from 'meocord/decorator'
 import { CommandType } from 'meocord/enum'
 
 @CommandBuilder(CommandType.SLASH)
-export class SampleCommandBuilder {
+export class {{builderClassName}} {
   build() {
-    return new SlashCommandBuilder().setName('sample-slash').setDescription('This is a sample slash command')
+    return new SlashCommandBuilder().setName('{{commandName}}').setDescription('Describe what /{{commandName}} does')
   }
 }

package/dist/esm/bin/builder-template/controller/autocomplete.controller.template

@@ -4,9 +4,10 @@ import { Controller, Autocomplete } from 'meocord/decorator'
 @Controller()
 export class {{className}}AutocompleteController {
 
-  // The option this completes must be declared with `.setAutocomplete(true)` on the
-  // slash command builder, otherwise Discord never sends the interaction.
-  @Autocomplete('sample-slash', 'query')
+  // Completes the `query` option of /{{commandName}} -- the command `meocord g co slash` generates
+  // for the same name. That option must be declared with `.setAutocomplete(true)` on the slash
+  // command's builder, otherwise Discord never sends the interaction.
+  @Autocomplete('{{commandName}}', 'query')
   async completeQuery(interaction: AutocompleteInteraction) {
     const { value } = interaction.options.getFocused(true)
     const choices = ['alpha', 'beta', 'gamma'].filter(choice => choice.startsWith(value))

package/dist/esm/bin/builder-template/controller/context-menu.controller.template

@@ -1,11 +1,11 @@
 import { UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction } from 'discord.js'
 import { Controller, Command } from 'meocord/decorator'
-import { SampleCommandBuilder } from '{{builderImportPath}}'
+import { {{builderClassName}} } from '{{builderImportPath}}'
 
 @Controller()
 export class {{className}}ContextMenuController {
 
-  @Command('sample-context-menu', SampleCommandBuilder)
+  @Command('{{commandName}}', {{builderClassName}})
   async handleContextMenu(interaction: UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction) {
     await interaction.reply('This is sample reply of context menu command.')
   }

package/dist/esm/bin/builder-template/controller/primary-entry-point.controller.template

@@ -1,11 +1,11 @@
 import { PrimaryEntryPointCommandInteraction } from 'discord.js'
 import { Controller, Command } from 'meocord/decorator'
-import { SampleCommandBuilder } from '{{builderImportPath}}'
+import { {{builderClassName}} } from '{{builderImportPath}}'
 
 @Controller()
 export class {{className}}PrimaryEntryPointController {
 
-  @Command('sample-entry-point', SampleCommandBuilder)
+  @Command('{{commandName}}', {{builderClassName}})
   async handleEntryPoint(interaction: PrimaryEntryPointCommandInteraction) {
     await interaction.reply('Launching the activity.')
   }

package/dist/esm/bin/builder-template/controller/slash.controller.template

@@ -1,11 +1,11 @@
 import { ChatInputCommandInteraction } from 'discord.js'
 import { Controller, Command } from 'meocord/decorator'
-import { SampleCommandBuilder } from '{{builderImportPath}}'
+import { {{builderClassName}} } from '{{builderImportPath}}'
 
 @Controller()
 export class {{className}}SlashController {
 
-  @Command('sample-slash', SampleCommandBuilder)
+  @Command('{{commandName}}', {{builderClassName}})
   async handleSampleSlash(interaction: ChatInputCommandInteraction) {
     await interaction.reply('This is sample reply of slash command.')
   }

package/dist/esm/bin/helper/controller-generator.helper.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import { ControllerType } from '../../enum/controller.enum.js';
-import { validateAndFormatName, populateTemplate, createDirectoryIfNotExists, generateFile, toClassName } from '../../util/generator-cli.util.js';
+import { kebabCase } from 'lodash-es';
+import { validateAndFormatName, assertFilesAbsent, populateTemplate, commandNameFor, createDirectoryIfNotExists, generateFile, toClassName } from '../../util/generator-cli.util.js';
 import { fileURLToPath } from 'url';
 
 const __filename$1 = fileURLToPath(import.meta.url);
@@ -14,8 +15,19 @@ class ControllerGeneratorHelper {
    */ generateController(args, type) {
         const { parts, kebabCaseName, className } = validateAndFormatName(args.controllerName);
         const controllerDir = path.join(process.cwd(), 'src', 'controllers', type, ...parts);
-        const template = this.buildControllerTemplate(className, type, parts);
-        this.generateControllerStructure(controllerDir, kebabCaseName, className, type, template);
+        // Every file this would write, checked before any is: a refusal leaves nothing half-made.
+        assertFilesAbsent([
+            ...this.getBuilderConfig(type, className, kebabCaseName, parts) ? [
+                this.builderFilePath(controllerDir, kebabCaseName)
+            ] : [],
+            path.join(controllerDir, `${kebabCaseName}.${type}.controller.ts`),
+            path.join(controllerDir, `${kebabCaseName}.${type}.controller.spec.ts`)
+        ]);
+        const template = this.buildControllerTemplate(className, type, parts, kebabCaseName);
+        this.generateControllerStructure(controllerDir, kebabCaseName, className, type, template, parts);
+    }
+    /** Where a controller's own builder is written: beside it, named after it. */ builderFilePath(controllerDir, kebabCaseName) {
+        return path.join(controllerDir, 'builders', `${kebabCaseName}.builder.ts`);
     }
     /**
    * Builds the controller template content by populating a template with variables.
@@ -23,8 +35,8 @@ class ControllerGeneratorHelper {
    * @param type - The type of the controller, defined in the `ControllerType` enum.
    * @returns The populated template string for the controller.
    * @throws Will throw an error if the controller type is unsupported.
-   */ buildControllerTemplate(className, type, parts = []) {
-        const templateConfig = this.getTemplateConfig(type, className, parts);
+   */ buildControllerTemplate(className, type, parts = [], kebabCaseName = kebabCase(className)) {
+        const templateConfig = this.getTemplateConfig(type, className, parts, kebabCaseName);
         if (!templateConfig) {
             throw new Error(`Unsupported controller type: ${type}`);
         }
@@ -35,7 +47,7 @@ class ControllerGeneratorHelper {
    * @param type - The type of the controller, defined in the `ControllerType` enum.
    * @param className - The name of the controller class.
    * @returns An object containing the template path and variables, or `undefined` if not found.
-   */ getTemplateConfig(type, className, parts = []) {
+   */ getTemplateConfig(type, className, parts, kebabCaseName) {
         const baseDir = path.resolve(__dirname$1, '..', 'builder-template', 'controller');
         const templates = {
             [ControllerType.BUTTON]: 'button.controller.template',
@@ -53,21 +65,25 @@ class ControllerGeneratorHelper {
             [ControllerType.PRIMARY_ENTRY_POINT]: 'primary-entry-point.controller.template'
         };
         const template = templates[type] ? path.resolve(baseDir, templates[type]) : undefined;
-        // The builder is written beside the controller, so a nested controller name moves
-        // it too. Hard-coding `@src/controllers/<type>/builders/...` only ever pointed at
-        // the top-level one, which for a nested name does not exist.
+        // The builder is written beside the controller and named after it, so each controller
+        // imports its own and generating one never touches another's. The path follows any
+        // nesting, since the builder moves with the controller.
         const builderImportPath = [
             '@src/controllers',
             type,
             ...parts,
-            'builders/sample.builder'
+            'builders',
+            `${kebabCaseName}.builder`
         ].join('/');
+        const variables = {
+            className,
+            builderImportPath,
+            builderClassName: `${className}CommandBuilder`,
+            commandName: commandNameFor(parts, kebabCaseName)
+        };
         return template ? {
             template,
-            variables: {
-                className,
-                builderImportPath
-            }
+            variables
         } : undefined;
     }
     /**
@@ -77,8 +93,8 @@ class ControllerGeneratorHelper {
    * @param className - The name of the controller class.
    * @param type - The type of the controller, defined in the `ControllerType` enum.
    * @param controllerTemplate - The populated template string for the controller file.
-   */ generateControllerStructure(controllerDir, kebabCaseName, className, type, controllerTemplate) {
-        this.generateBuilderFile(className, type, controllerDir);
+   */ generateControllerStructure(controllerDir, kebabCaseName, className, type, controllerTemplate, parts) {
+        this.generateBuilderFile(className, kebabCaseName, type, controllerDir, parts);
         createDirectoryIfNotExists(controllerDir);
         const controllerFilePath = path.join(controllerDir, `${kebabCaseName}.${type}.controller.ts`);
         generateFile(controllerFilePath, controllerTemplate);
@@ -97,21 +113,19 @@ class ControllerGeneratorHelper {
    * @param className - The name of the controller class.
    * @param type - The type of the controller, defined in the `ControllerType` enum.
    * @param controllerDir - The absolute path to the controller directory.
-   */ generateBuilderFile(className, type, controllerDir) {
-        const builderConfig = this.getBuilderConfig(type, className);
+   */ generateBuilderFile(className, kebabCaseName, type, controllerDir, parts) {
+        const builderConfig = this.getBuilderConfig(type, className, kebabCaseName, parts);
         if (!builderConfig) return;
         const builderTemplate = populateTemplate(builderConfig.template, builderConfig.variables);
-        const buildersDir = path.join(controllerDir, 'builders');
-        createDirectoryIfNotExists(buildersDir);
-        const builderFilePath = path.join(buildersDir, 'sample.builder.ts');
-        generateFile(builderFilePath, builderTemplate);
+        createDirectoryIfNotExists(path.join(controllerDir, 'builders'));
+        generateFile(this.builderFilePath(controllerDir, kebabCaseName), builderTemplate);
     }
     /**
    * Retrieves the configuration for generating a builder file based on the controller type and class name.
    * @param type - The type of the controller, defined in the `ControllerType` enum.
    * @param className - The name of the controller class.
    * @returns An object containing the builder template path and variables, or `undefined` if not found.
-   */ getBuilderConfig(type, className) {
+   */ getBuilderConfig(type, className, kebabCaseName, parts) {
         const baseDir = path.resolve(__dirname$1, '..', 'builder-template', 'builder');
         const templates = {
             [ControllerType.CONTEXT_MENU]: 'context-menu.builder.template',
@@ -119,11 +133,14 @@ class ControllerGeneratorHelper {
             [ControllerType.PRIMARY_ENTRY_POINT]: 'primary-entry-point.builder.template'
         };
         const template = templates[type] ? path.resolve(baseDir, templates[type]) : undefined;
+        const variables = {
+            className,
+            builderClassName: `${className}CommandBuilder`,
+            commandName: commandNameFor(parts, kebabCaseName)
+        };
         return template ? {
             template,
-            variables: {
-                className
-            }
+            variables
         } : undefined;
     }
 }

package/dist/esm/bin/helper/guard-generator.helper.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import { Logger } from '../../common/logger.js';
 import '../../common/theme.js';
-import { validateAndFormatName, buildTemplate, createDirectoryIfNotExists, generateFile } from '../../util/generator-cli.util.js';
+import { validateAndFormatName, assertFilesAbsent, buildTemplate, createDirectoryIfNotExists, generateFile } from '../../util/generator-cli.util.js';
 
 class GuardGeneratorHelper {
     /**
@@ -20,13 +20,19 @@ class GuardGeneratorHelper {
         const { parts, kebabCaseName, className } = validateAndFormatName(guardName);
         const guardDir = path.join(process.cwd(), 'src', 'guards', ...parts);
         const guardFile = path.join(guardDir, `${kebabCaseName}.guard.ts`);
+        const specFile = path.join(guardDir, `${kebabCaseName}.guard.spec.ts`);
+        // Both files checked before either is written, so an existing guard is never replaced.
+        assertFilesAbsent([
+            guardFile,
+            specFile
+        ]);
         const guardTemplate = buildTemplate(className, 'guard.template');
         const specTemplate = buildTemplate(className, 'guard.spec.template', {
             kebabCaseName
         });
         createDirectoryIfNotExists(guardDir);
         generateFile(guardFile, guardTemplate);
-        generateFile(path.join(guardDir, `${kebabCaseName}.guard.spec.ts`), specTemplate);
+        generateFile(specFile, specTemplate);
     }
     constructor(appName){
         this.appName = appName;

package/dist/esm/bin/helper/service-generator.helper.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import { Logger } from '../../common/logger.js';
 import '../../common/theme.js';
-import { validateAndFormatName, buildTemplate, createDirectoryIfNotExists, generateFile } from '../../util/generator-cli.util.js';
+import { validateAndFormatName, assertFilesAbsent, buildTemplate, createDirectoryIfNotExists, generateFile } from '../../util/generator-cli.util.js';
 
 class ServiceGeneratorHelper {
     /**
@@ -20,13 +20,19 @@ class ServiceGeneratorHelper {
         const { parts, kebabCaseName, className } = validateAndFormatName(serviceName);
         const serviceDir = path.join(process.cwd(), 'src', 'services', ...parts);
         const serviceFile = path.join(serviceDir, `${kebabCaseName}.service.ts`);
+        const specFile = path.join(serviceDir, `${kebabCaseName}.service.spec.ts`);
+        // Both files checked before either is written, so an existing service is never replaced.
+        assertFilesAbsent([
+            serviceFile,
+            specFile
+        ]);
         const serviceTemplate = buildTemplate(className, 'service.template');
         const specTemplate = buildTemplate(className, 'service.spec.template', {
             kebabCaseName
         });
         createDirectoryIfNotExists(serviceDir);
         generateFile(serviceFile, serviceTemplate);
-        generateFile(path.join(serviceDir, `${kebabCaseName}.service.spec.ts`), specTemplate);
+        generateFile(specFile, specTemplate);
     }
     constructor(appName){
         this.appName = appName;