@brunoluizdesiqueira/bbuilder-cli 1.0.22 → 1.0.23

package/README.md

@@ -6,6 +6,7 @@ CLI para build local de projetos Delphi.
 - suporte a `FAST`, `DEBUG` e `RELEASE`
 - configuração por arquivo `bbuilder.config.json`
 - diagnóstico de ambiente com `doctor`
+- validação de comandos com `validate-commands`
 
 ## Requisitos
 
@@ -41,9 +42,12 @@ Ou use um arquivo manual como este:
   "repoBase": "C:\\git\\bimer",
   "delphiDir": "C:\\Program Files (x86)\\Embarcadero\\Studio\\22.0",
   "envVersion": "11.03.00",
-  "libRoot": "C:\\LibraryDelphiAlexandria\\Externos\\3.00",
-  "libErp": "C:\\LibraryDelphiAlexandria\\ERP\\11.03.00",
-  "libAlterdata": "C:\\LibraryDelphiAlexandria\\LibAlterdata\\1.0.0",
+  "libRoot": "C:\\LibraryDelphiAlexandria",
+  "libExternos": "${libRoot}\\Externos\\3.00",
+  "libErp": "${libRoot}\\ERP\\${envVersion}",
+  "libAlterdata": "${libRoot}\\LibAlterdata\\1.0.0",
+  "exeOutputDir": "C:\\Temp\\${envVersion}\\EXE",
+  "dcuOutputDir": "C:\\Temp\\${envVersion}\\DCU",
   "dependencyPaths": [
     "C:\\git\\bimer\\dependencies",
     "C:\\Program Files (x86)\\Embarcadero\\Studio\\22.0\\lib\\Win64\\release",
@@ -57,6 +61,25 @@ Ou use um arquivo manual como este:
 }
 ```
 
+### Templates de Paths
+
+Os campos de path suportam variáveis que são resolvidas automaticamente:
+
+- `${libRoot}` - caminho base da biblioteca (padrão: `C:\LibraryDelphiAlexandria`)
+- `${envVersion}` - versão do ambiente (padrão: `11.03.00`)
+
+Exemplos:
+- `"${libRoot}\\Externos\\3.00"` → `"C:\\LibraryDelphiAlexandria\\Externos\\3.00"`
+- `"C:\\Temp\\${envVersion}\\EXE"` → `"C:\\Temp\\11.03.00\\EXE"`
+
+Campos que suportam templates:
+- `libRoot` - caminho base da biblioteca
+- `libExternos` - pasta Externos (derivado de libRoot)
+- `libErp` - pasta do ERP (derivado de libRoot e envVersion)
+- `libAlterdata` - pasta LibAlterdata (derivado de libRoot)
+- `exeOutputDir` - diretório de saída do executável
+- `dcuOutputDir` - diretório de saída das units compiladas
+
 `dependencyPaths` varia por máquina e deve ser ajustado por usuário.
 
 ## Resolução da Configuração
@@ -133,6 +156,26 @@ bbuilder config validate
 bbuilder doctor
 ```
 
+### Validação de Comandos
+
+Para verificar quais comandos serão executados sem rodar o build:
+
+```bash
+bbuilder validate-commands --type FAST
+bbuilder validate-commands --type DEBUG
+bbuilder validate-commands --type RELEASE
+```
+
+Opções:
+- `-t, --type` - modo de build (FAST, DEBUG, RELEASE)
+- `-p, --project` - caminho do projeto
+- `-v, --version` - versão do exe
+
+Esta ferramenta é útil para:
+- depuração de problemas de build
+- geração de testes unitários
+- verificação de paths e argumentos
+
 ## Observações de Uso
 
 - o build mostra etapas com tempo decorrido
@@ -159,6 +202,12 @@ Validar configuração:
 bbuilder config validate
 ```
 
+Verificar comandos que serão executados:
+
+```bash
+bbuilder validate-commands --type DEBUG
+```
+
 Erro `Unit not found: 'System'` normalmente indica problema em:
 - `delphiDir`
 - `dependencyPaths`

package/dist/build/compiler.js

@@ -46,6 +46,9 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const output_1 = require("../ui/output");
+function resolveEnvTemplate(template, envVersion) {
+    return template.replace(/\$\{envVersion\}/g, envVersion).replace(/\$envVersion/g, envVersion);
+}
 const delphiEnvCache = new Map();
 function buildCompilerFlags(buildType) {
     const baseDefines = 'DEBUG;ALT_CEF133_0;EUREKALOG';
@@ -140,8 +143,8 @@ async function runCgrc(opts, projectName) {
 async function runDcc64(opts, projectName, workspaceDir) {
     const { flags, defines } = buildCompilerFlags(opts.type);
     const deps = buildDependencies(opts);
-    const exeOut = path.win32.join('C:\\Temp', opts.envVersion, 'EXE');
-    const dcuOut = path.win32.join('C:\\Temp', opts.envVersion, 'DCU');
+    const exeOut = resolveEnvTemplate(opts.exeOutputDir, opts.envVersion);
+    const dcuOut = resolveEnvTemplate(opts.dcuOutputDir, opts.envVersion);
     const delphiEnv = await getDelphiEnvironment(opts.delphiDir);
     if (!fs.existsSync(exeOut))
         fs.mkdirSync(exeOut, { recursive: true });
@@ -187,7 +190,7 @@ function runBuiltExecutable(opts, projectName) {
     const { runAfter } = buildCompilerFlags(opts.type);
     if (!runAfter)
         return;
-    const exeOut = path.win32.join('C:\\Temp', opts.envVersion, 'EXE', `${projectName}.exe`);
+    const exeOut = path.win32.join(resolveEnvTemplate(opts.exeOutputDir, opts.envVersion), `${projectName}.exe`);
     (0, output_1.step)(`Iniciando ${projectName}.exe...`);
     (0, execa_1.default)(exeOut, [], { detached: true, stdio: 'ignore' }).unref();
 }

package/dist/build/validate-commands.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDcc64Command = getDcc64Command;
+exports.getBuiltExecutablePath = getBuiltExecutablePath;
+exports.printCommands = printCommands;
+const path = __importStar(require("path"));
+function getDcc64Command(opts, projectName) {
+    const { flags, defines } = buildCompilerFlags(opts.type);
+    const deps = buildDependencies(opts);
+    const exeOut = resolveEnvTemplate(opts.exeOutputDir, opts.envVersion);
+    const dcuOut = resolveEnvTemplate(opts.dcuOutputDir, opts.envVersion);
+    const nsValue = 'Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;Vcl;Vcl.Imaging;Vcl.Touch;Vcl.Samples;Vcl.Shell;System;Xml;Data;Datasnap;Web;Soap;Winapi;FireDAC.VCLUI;System.Win;';
+    const aliasValue = 'Generics.Collections=System.Generics.Collections;Generics.Defaults=System.Generics.Defaults;WinTypes=Winapi.Windows;WinProcs=Winapi.Windows;DbiTypes=BDE;DbiProcs=BDE;DbiErrs=BDE';
+    const dcc64 = path.win32.join(opts.delphiDir, 'bin', 'dcc64.exe');
+    const args = [
+        ...flags,
+        '--no-config', '-Q', '-H-', '-W-',
+        '-TX.exe',
+        `-A${aliasValue}`,
+        `-D${defines}`,
+        `-E${exeOut}`,
+        `-I${deps}`,
+        `-LE${exeOut}`,
+        `-LN${exeOut}`,
+        `-NU${dcuOut}`,
+        `-NS${nsValue}`,
+        `-O${deps}`,
+        `-R${deps}`,
+        `-U${deps}`,
+        '-K00400000', '-GD',
+        `-NB${exeOut}`,
+        `-NH${exeOut}`,
+        `-NO${dcuOut}`,
+        '-W-', '-W-SYMBOL_PLATFORM', '-W-UNIT_PLATFORM', '-W-DUPLICATE_CTOR_DTOR', '-W-IMPLICIT_STRING_CAST',
+        `${projectName}.dpr`,
+    ];
+    return { exe: dcc64, args, exeOutputDir: exeOut, dcuOutputDir: dcuOut, projectName };
+}
+function getBuiltExecutablePath(opts, projectName) {
+    const exeOut = resolveEnvTemplate(opts.exeOutputDir, opts.envVersion);
+    return { exe: path.win32.join(exeOut, `${projectName}.exe`), projectName };
+}
+function printCommands(opts, projectName) {
+    console.log('\n=== COMANDOS PARA TESTES ===\n');
+    const dcc64 = getDcc64Command(opts, projectName);
+    console.log('--- dcc64 (compilação) ---');
+    console.log('EXE:', dcc64.exe);
+    console.log('ARGS:');
+    dcc64.args.forEach((arg, i) => console.log(`  ${i}: ${arg}`));
+    console.log('\n--- exe (execução pós-build) ---');
+    const exe = getBuiltExecutablePath(opts, projectName);
+    console.log('EXE:', exe.exe);
+    console.log('\n=== FIM COMANDOS ===\n');
+}
+function buildCompilerFlags(buildType) {
+    const baseDefines = 'DEBUG;ALT_CEF133_0;EUREKALOG';
+    const releaseDefines = 'RELEASE;ALT_CEF133_0;EUREKALOG';
+    switch (buildType) {
+        case 'FAST':
+            return { flags: ['-$W+', '-$J+', '-$D+', '-$L+', '-$Y+', '-$O-'], defines: baseDefines };
+        case 'DEBUG':
+            return { flags: ['-B', '-$W+', '-$J+', '-$D+', '-$L+', '-$Y+', '-$O-', '-V', '-VR'], defines: baseDefines };
+        case 'RELEASE':
+            return { flags: ['-B', '-$W+', '-$J+', '-$D0', '-$L-', '-$Y-', '-$O+'], defines: releaseDefines };
+    }
+}
+function buildDependencies(opts) {
+    return opts.dependencyPaths.join(';');
+}
+function resolveEnvTemplate(template, envVersion) {
+    return template
+        .replace(/\$\{envVersion\}/g, envVersion)
+        .replace(/\$envVersion/g, envVersion);
+}

package/dist/cli/program.js

@@ -7,6 +7,7 @@ exports.runCli = runCli;
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const execute_1 = require("../build/execute");
+const validate_commands_1 = require("../build/validate-commands");
 const config_1 = require("../config/config");
 const validate_1 = require("../config/validate");
 const doctor_1 = require("../diagnostics/doctor");
@@ -175,6 +176,20 @@ async function runCli(argv) {
         .command('doctor')
         .description('Diagnostica configuração, paths e binários do ambiente')
         .action(() => (0, doctor_1.runDoctor)(config, resolvedConfigPath)), HELP_EXAMPLES.doctor);
+    program
+        .command('validate-commands')
+        .description('Imprime os comandos que seriam executados (para geração de testes)')
+        .option('-t, --type <FAST|DEBUG|RELEASE>', 'Modo de build')
+        .option('-p, --project <path>', 'Caminho do projeto')
+        .option('-v, --version <version>', 'Versão a injetar')
+        .action(async (opts) => {
+        const buildType = (opts.type?.toUpperCase() || 'DEBUG');
+        const projectPath = opts.project || Object.values(config.projects)[0];
+        const version = opts.version || '11.3.0';
+        const resolved = await (0, prompts_1.promptBuild)(config, buildType, projectPath, version);
+        const projectName = projectPath.split('\\').pop() || projectPath;
+        (0, validate_commands_1.printCommands)(resolved, projectName);
+    });
     if (argv.length <= 2) {
         (0, output_1.banner)();
         const resolved = await (0, prompts_1.promptBuild)(config);

package/dist/config/config.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_CONFIG = exports.CONFIG_ENV_VAR = exports.LEGACY_CONFIG_FILENAME = exports.CONFIG_FILENAME = void 0;
+exports.resolveLibTemplate = resolveLibTemplate;
 exports.buildDefaultDependencyPaths = buildDefaultDependencyPaths;
 exports.getDefaultConfigPath = getDefaultConfigPath;
 exports.getWritableConfigPath = getWritableConfigPath;
@@ -46,54 +47,78 @@ const path = __importStar(require("path"));
 exports.CONFIG_FILENAME = 'bbuilder.config.json';
 exports.LEGACY_CONFIG_FILENAME = 'bimer.config.json';
 exports.CONFIG_ENV_VAR = 'BBUILDER_CONFIG';
+function resolveLibTemplate(template, libRoot, envVersion) {
+    let result = template
+        .replace(/\$\{libRoot\}/g, libRoot)
+        .replace(/\$libRoot/g, libRoot);
+    if (envVersion) {
+        result = result
+            .replace(/\$\{envVersion\}/g, envVersion)
+            .replace(/\$envVersion/g, envVersion);
+    }
+    return result;
+}
 const DEFAULT_CONFIG_BASE = {
     repoBase: 'C:\\git\\bimer',
     delphiDir: 'C:\\Program Files (x86)\\Embarcadero\\Studio\\22.0',
     envVersion: '11.03.00',
-    libRoot: 'C:\\LibraryDelphiAlexandria\\Externos\\3.00',
-    libErp: 'C:\\LibraryDelphiAlexandria\\ERP\\11.03.00',
-    libAlterdata: 'C:\\LibraryDelphiAlexandria\\LibAlterdata\\1.0.0',
+    libRoot: 'C:\\LibraryDelphiAlexandria',
+    libExternos: '${libRoot}\\Externos\\3.00',
+    libErp: '${libRoot}\\ERP\\${envVersion}',
+    libAlterdata: '${libRoot}\\LibAlterdata\\1.0.0',
+    exeOutputDir: 'C:\\Temp\\${envVersion}\\EXE',
+    dcuOutputDir: 'C:\\Temp\\${envVersion}\\DCU',
 };
 function buildDefaultDependencyPaths(params) {
-    const { repoBase, delphiDir, libRoot, libErp, libAlterdata } = params;
+    const { repoBase, delphiDir, libExternos, libErp, libAlterdata } = params;
     return [
         `${repoBase}\\dependencies`,
         `${delphiDir}\\lib\\Win64\\release`,
-        `${libRoot}\\sgcWebSockets\\Win64`,
-        `${libRoot}\\DevExpress\\Win64`,
-        `${libRoot}\\dataset-serialize\\Win64`,
-        `${libRoot}\\UniDAC\\Win64`,
-        `${libRoot}\\EurekaLog\\Common`,
-        `${libRoot}\\EurekaLog\\Win64`,
-        `${libRoot}\\SMImport\\Win64`,
-        `${libRoot}\\SMExport\\Win64`,
-        `${libRoot}\\RXLibrary\\Win64`,
-        `${libRoot}\\ReportBuilder\\Win64`,
-        `${libRoot}\\ComPort\\Win64`,
-        `${libRoot}\\QuickReport\\Win64`,
-        `${libRoot}\\FastMM\\Win64`,
-        `${libRoot}\\Tee\\Win64`,
-        `${libRoot}\\ExtraDevices\\Win64`,
-        `${libRoot}\\ExtraFilter\\Win64`,
+        `${libExternos}\\sgcWebSockets\\Win64`,
+        `${libExternos}\\DevExpress\\Win64`,
+        `${libExternos}\\dataset-serialize\\Win64`,
+        `${libExternos}\\UniDAC\\Win64`,
+        `${libExternos}\\EurekaLog\\Common`,
+        `${libExternos}\\EurekaLog\\Win64`,
+        `${libExternos}\\SMImport\\Win64`,
+        `${libExternos}\\SMExport\\Win64`,
+        `${libExternos}\\RXLibrary\\Win64`,
+        `${libExternos}\\ReportBuilder\\Win64`,
+        `${libExternos}\\ComPort\\Win64`,
+        `${libExternos}\\QuickReport\\Win64`,
+        `${libExternos}\\FastMM\\Win64`,
+        `${libExternos}\\Tee\\Win64`,
+        `${libExternos}\\ExtraDevices\\Win64`,
+        `${libExternos}\\ExtraFilter\\Win64`,
         `${libErp}\\Win64`,
-        `${libRoot}\\ZipForge\\Win64`,
-        `${libRoot}\\FortesReport\\Win64`,
-        `${libRoot}\\TBGWebCharts\\Win64`,
-        `${libRoot}\\EventBus\\Win64`,
-        `${libRoot}\\Horse\\Win64`,
+        `${libExternos}\\ZipForge\\Win64`,
+        `${libExternos}\\FortesReport\\Win64`,
+        `${libExternos}\\TBGWebCharts\\Win64`,
+        `${libExternos}\\EventBus\\Win64`,
+        `${libExternos}\\Horse\\Win64`,
         `${libAlterdata}\\feedbacker`,
         `${libAlterdata}\\rest-client`,
     ];
 }
 exports.DEFAULT_CONFIG = {
     ...DEFAULT_CONFIG_BASE,
-    dependencyPaths: buildDefaultDependencyPaths(DEFAULT_CONFIG_BASE),
+    libExternos: resolveLibTemplate(DEFAULT_CONFIG_BASE.libExternos, DEFAULT_CONFIG_BASE.libRoot),
+    libErp: resolveLibTemplate(DEFAULT_CONFIG_BASE.libErp, DEFAULT_CONFIG_BASE.libRoot, DEFAULT_CONFIG_BASE.envVersion),
+    libAlterdata: resolveLibTemplate(DEFAULT_CONFIG_BASE.libAlterdata, DEFAULT_CONFIG_BASE.libRoot),
+    dependencyPaths: buildDefaultDependencyPaths({
+        ...DEFAULT_CONFIG_BASE,
+        libExternos: resolveLibTemplate(DEFAULT_CONFIG_BASE.libExternos, DEFAULT_CONFIG_BASE.libRoot),
+        libErp: resolveLibTemplate(DEFAULT_CONFIG_BASE.libErp, DEFAULT_CONFIG_BASE.libRoot, DEFAULT_CONFIG_BASE.envVersion),
+        libAlterdata: resolveLibTemplate(DEFAULT_CONFIG_BASE.libAlterdata, DEFAULT_CONFIG_BASE.libRoot),
+    }),
     projects: {
         BimerFaturamento: 'faturamento\\BimerFaturamento',
         Bimer: 'Bimer',
         LiberadorEstoque: 'geral\\gerenteeletronico.jobs.liberadorestoque\\LiberadorEstoque',
         BimerEstoque: 'estoque\\BimerEstoque',
     },
+    exeOutputDir: DEFAULT_CONFIG_BASE.exeOutputDir,
+    dcuOutputDir: DEFAULT_CONFIG_BASE.dcuOutputDir,
 };
 function deriveProjectName(projectPath) {
     const normalized = projectPath.replace(/[\\/]+$/, '');
@@ -167,6 +192,17 @@ function loadConfig(configPath) {
                 ...parsed,
                 projects: normalizeProjects(parsed.projects),
             };
+            const libRoot = merged.libRoot || DEFAULT_CONFIG_BASE.libRoot;
+            const envVersion = merged.envVersion || DEFAULT_CONFIG_BASE.envVersion;
+            if (parsed.libExternos?.includes('${libRoot}') || !parsed.libExternos) {
+                merged.libExternos = resolveLibTemplate(DEFAULT_CONFIG_BASE.libExternos, libRoot);
+            }
+            if (parsed.libErp?.includes('${libRoot}') || !parsed.libErp) {
+                merged.libErp = resolveLibTemplate(DEFAULT_CONFIG_BASE.libErp, libRoot, envVersion);
+            }
+            if (parsed.libAlterdata?.includes('${libRoot}') || !parsed.libAlterdata) {
+                merged.libAlterdata = resolveLibTemplate(DEFAULT_CONFIG_BASE.libAlterdata, libRoot);
+            }
             if (!Array.isArray(parsed.dependencyPaths) || parsed.dependencyPaths.length === 0) {
                 merged.dependencyPaths = buildDefaultDependencyPaths(merged);
             }

package/dist/config/validate.js

@@ -73,6 +73,7 @@ function validateConfigObject(raw) {
         'delphiDir',
         'envVersion',
         'libRoot',
+        'libExternos',
         'libErp',
         'libAlterdata',
     ];
@@ -81,6 +82,15 @@ function validateConfigObject(raw) {
             issues.push({ field, message: 'deve ser uma string não vazia' });
         }
     }
+    const optionalStringFields = [
+        'exeOutputDir',
+        'dcuOutputDir',
+    ];
+    for (const field of optionalStringFields) {
+        if (config[field] !== undefined && !isNonEmptyString(config[field])) {
+            issues.push({ field, message: 'deve ser uma string não vazia se fornecida' });
+        }
+    }
     if (!Array.isArray(config.dependencyPaths) || config.dependencyPaths.length === 0) {
         issues.push({ field: 'dependencyPaths', message: 'deve ser um array com ao menos um path' });
     }

package/dist/diagnostics/doctor.js

@@ -68,6 +68,7 @@ function runDoctor(config, resolvedConfigPath) {
     checks.push(checkPath('delphiDir', config.delphiDir));
     checks.push(checkPath('Delphi runtime Win64', delphiRuntimePath));
     checks.push(checkPath('libRoot', config.libRoot));
+    checks.push(checkPath('libExternos', config.libExternos));
     checks.push(checkPath('libErp', config.libErp));
     checks.push(checkPath('libAlterdata', config.libAlterdata));
     checks.push(checkFile('cgrc.exe', cgrcPath));

package/dist/ui/prompts.js

@@ -55,9 +55,12 @@ async function promptBuild(config, cliType, cliProject, cliVersion) {
         delphiDir: config.delphiDir,
         envVersion: config.envVersion,
         libRoot: config.libRoot,
+        libExternos: config.libExternos,
         libErp: config.libErp,
         libAlterdata: config.libAlterdata,
         dependencyPaths: config.dependencyPaths,
+        exeOutputDir: config.exeOutputDir,
+        dcuOutputDir: config.dcuOutputDir,
     };
 }
 async function runConfigInit(config, configPath) {
@@ -70,18 +73,27 @@ async function runConfigInit(config, configPath) {
         { type: 'input', name: 'envVersion', message: 'Versão do ambiente (ENV):', default: config.envVersion },
         { type: 'input', name: 'libRoot', message: 'LibraryDelphiAlexandria root:', default: config.libRoot },
     ]);
-    const libErp = `C:\\LibraryDelphiAlexandria\\ERP\\${answers.envVersion}`;
+    const libRoot = answers.libRoot || 'C:\\LibraryDelphiAlexandria';
+    const libExternosTemplate = answers.libExternos || '${libRoot}\\Externos\\3.00';
+    const libErpTemplate = answers.libErp || '${libRoot}\\ERP\\${envVersion}';
+    const libAlterdataTemplate = answers.libAlterdata || '${libRoot}\\LibAlterdata\\1.0.0';
+    const exeOutputDir = answers.exeOutputDir || 'C:\\Temp\\${envVersion}\\EXE';
+    const dcuOutputDir = answers.dcuOutputDir || 'C:\\Temp\\${envVersion}\\DCU';
     const newConfig = {
         ...config,
         ...answers,
-        libErp,
-        libAlterdata: config.libAlterdata,
+        libRoot,
+        libExternos: libExternosTemplate,
+        libErp: libErpTemplate,
+        libAlterdata: libAlterdataTemplate,
+        exeOutputDir,
+        dcuOutputDir,
         dependencyPaths: (0, config_1.buildDefaultDependencyPaths)({
             repoBase: answers.repoBase,
             delphiDir: answers.delphiDir,
-            libRoot: answers.libRoot,
-            libErp,
-            libAlterdata: config.libAlterdata,
+            libExternos: (0, config_1.resolveLibTemplate)(libExternosTemplate, libRoot),
+            libErp: (0, config_1.resolveLibTemplate)(libErpTemplate, libRoot, answers.envVersion),
+            libAlterdata: (0, config_1.resolveLibTemplate)(libAlterdataTemplate, libRoot),
         }),
     };
     (0, config_1.saveConfig)(newConfig, configPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunoluizdesiqueira/bbuilder-cli",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "description": "CLI de build local para projetos Delphi do Bimer",
   "license": "ISC",
   "repository": {
@@ -33,7 +33,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "ts-node src/index.ts",
-    "test": "npm run build && node --test test/**/*.test.js",
+    "test": "node --test test/**/*.test.ts",
     "prepack": "npm run build",
     "changeset": "changeset",
     "version-packages": "changeset version",